Leitfaden zu Binärsystem und Basisumrechnung: Visuelles Verständnis von Bitoperationen bis Datenkodierung

Entwickler-Tools

Grundlagen der Zahlensysteme

Vier Gängige Zahlensysteme

Basis Radix Ziffern Präfix Beispiel
Binär 2 0,1 0b 0b1010 = 10
Oktal 8 0-7 0o 0o12 = 10
Dezimal 10 0-9 Keines 10
Hexadezimal 16 0-9,A-F 0x 0xA = 10

Umrechnungsmethoden

Beliebige Basis → Dezimal

Binär 1010 → 1×2³ + 0×2² + 1×2¹ + 0×2⁰ = 8 + 0 + 2 + 0 = 10
Hexadezimal FF → 15×16¹ + 15×16⁰ = 240 + 15 = 255

Dezimal → Beliebige Basis

10 → Binär:
10 ÷ 2 = 5 Rest 0
5 ÷ 2 = 2 Rest 1
2 ÷ 2 = 1 Rest 0
1 ÷ 2 = 0 Rest 1
Von unten lesen: 1010

255 → Hexadezimal:
255 ÷ 16 = 15 Rest 15
15 ÷ 16 = 0 Rest 15
Von unten lesen: FF

Basisumrechnung in JavaScript

// parseInt zu Dezimal
parseInt('1010', 2)    // 10
parseInt('FF', 16)     // 255
parseInt('12', 8)      // 10

// toString zu Zielbasis
(10).toString(2)       // "1010"
(255).toString(16)     // "ff"
(255).toString(8)      // "377"

// Literale
0b1010   // 10
0o12     // 10
0xFF     // 255

Bitoperationen in der Praxis

Sechs Bitoperationen

Operation Symbol Beispiel Ergebnis
AND & 0b1100 & 0b1010 0b1000 (8)
OR ` ` `0b1100
XOR ^ 0b1100 ^ 0b1010 0b0110 (6)
NOT ~ ~0b1100 -0b1101 (-13)
Linksverschiebung << 0b0011 << 2 0b1100 (12)
Rechtsverschiebung >> 0b1100 >> 2 0b0011 (3)

Anwendung 1: Berechtigungssystem

const PERMISSIONS = {
  READ:    1 << 0,  // 0b0001 = 1
  WRITE:   1 << 1,  // 0b0010 = 2
  DELETE:  1 << 2,  // 0b0100 = 4
  ADMIN:   1 << 3,  // 0b1000 = 8
};

// Berechtigungen kombinieren
const editor = PERMISSIONS.READ | PERMISSIONS.WRITE;  // 0b0011 = 3
const admin = PERMISSIONS.READ | PERMISSIONS.WRITE | PERMISSIONS.DELETE | PERMISSIONS.ADMIN;  // 0b1111 = 15

// Berechtigung prüfen
function hasPermission(userPermissions: number, permission: number): boolean {
  return (userPermissions & permission) === permission;
}

hasPermission(editor, PERMISSIONS.READ);    // true
hasPermission(editor, PERMISSIONS.DELETE);  // false
hasPermission(admin, PERMISSIONS.ADMIN);    // true

// Berechtigung hinzufügen
function addPermission(userPermissions: number, permission: number): number {
  return userPermissions | permission;
}

// Berechtigung entfernen
function removePermission(userPermissions: number, permission: number): number {
  return userPermissions & ~permission;
}

Anwendung 2: Flags

const FLAGS = {
  BOLD:      1 << 0,  // 1
  ITALIC:    1 << 1,  // 2
  UNDERLINE: 1 << 2,  // 4
  STRIKETHROUGH: 1 << 3, // 8
};

// Festlegen: Fett + Kursiv
let style = FLAGS.BOLD | FLAGS.ITALIC;  // 3

// Unterstreichung umschalten
style ^= FLAGS.UNDERLINE;  // 7 (Unterstreichung hinzufügen)
style ^= FLAGS.UNDERLINE;  // 3 (Unterstreichung entfernen)

Anwendung 3: RGB-Farbe

// RGB → Zahl
function rgbToNumber(r: number, g: number, b: number): number {
  return (r << 16) | (g << 8) | b;
}

// Zahl → RGB
function numberToRgb(n: number): { r: number; g: number; b: number } {
  return {
    r: (n >> 16) & 0xFF,
    g: (n >> 8) & 0xFF,
    b: n & 0xFF,
  };
}

rgbToNumber(255, 128, 0);     // 0xFF8000 = 16744448
numberToRgb(0xFF8000);        // { r: 255, g: 128, b: 0 }

Anwendung 4: Schnellberechnung

// Multiplikation mit Zweierpotenzen
n * 2     === n << 1
n * 4     === n << 2
n * 8     === n << 3

// Division durch Zweierpotenzen (abschneiden)
n / 2     === n >> 1  // positive Zahlen
Math.floor(n / 2) === n >> 1

// Gerade/Ungerade prüfen
n & 1     // 0 = gerade, 1 = ungerade

// Modulo Zweierpotenzen
n % 4     === n & 3
n % 8     === n & 7
n % 16    === n & 15

// Zwei Werte tauschen (ohne temporäre Variable)
a ^= b; b ^= a; a ^= b;

IEEE 754-Gleitkommazahlen

Doppeltgenaue Struktur (64 Bit)

Vorzeichenbit(1)  Exponentenbits(11)    Mantissenbits(52)
S                 EEEEEEEEEEE           MMMMMMMMMMMM...MMMM

Beispiel: -12.375
Vorzeichen: 1 (negativ)
Exponent: 10000000010 (1026, mit Offset 3)
Mantisse: 1001001100000000...0

Genauigkeitsprobleme

// Klassisches Problem
0.1 + 0.2 === 0.3   // false!
0.1 + 0.2            // 0.30000000000000004

// Ursache: 0.1 und 0.2 sind im Binärsystem unendliche periodische Dezimalzahlen
// 0.1 = 0.0001100110011... (periodisch)
// 0.2 = 0.0011001100110... (periodisch)

// Lösungen
// 1. Ganzzahlige Arithmetik verwenden
(0.1 * 10 + 0.2 * 10) / 10  // 0.3

// 2. toFixed verwenden
(0.1 + 0.2).toFixed(1)       // "0.3"

// 3. EPSILON-Vergleich verwenden
Math.abs(0.1 + 0.2 - 0.3) < Number.EPSILON  // true

Sonderwerte

Number.MAX_SAFE_INTEGER    // 9007199254740991 (2^53 - 1)
Number.MIN_SAFE_INTEGER    // -9007199254740991
Number.MAX_VALUE           // 1.7976931348623157e+308
Number.EPSILON             // 2.220446049250313e-16
Infinity                   // Positiv unendlich
-Infinity                  // Negativ unendlich
NaN                        // Keine Zahl

Base64-Kodierung und Binärdaten

Kodierungsprinzip

3 Bytes (24 Bit) → 4 Base64-Zeichen (je 6 Bit)

Beispiel: "Man"
M = 77  = 01001101
a = 97  = 01100001
n = 110 = 01101110

Kombiniert: 010011010110000101101110
Gruppiert: 010011 010110 000101 101110
Indizes:    19      22      5      46
Zeichen:    T       W       F       u

Ergebnis: "TWFu"

Werkzeug zum Kodieren/Dekodieren verwenden

  1. Öffnen Sie das Base64-Kodierungs-/Dekodierungswerkzeug
  2. Geben Sie Text oder einen Base64-String ein
  3. Klicken Sie auf "Kodieren" oder "Dekodieren"
  4. Unterstützt Base64-Konvertierung von Dateien und Bildern

Hex-Kodierung

Binär → Hex-Zuordnungstabelle

0000 = 0    0100 = 4    1000 = 8    1100 = C
0001 = 1    0101 = 5    1001 = 9    1101 = D
0010 = 2    0110 = 6    1010 = A    1110 = E
0011 = 3    0111 = 7    1011 = B    1111 = F

Häufige Verwendungszwecke

Verwendung Beispiel
Farbwerte #FF8000
MAC-Adresse 00:1A:2B:3C:4D:5E
Hash-Werte a1b2c3d4e5f6...
Speicheradresse 0x7fff5fbff8c0
Binäre Anzeige xxd file.bin

ToolsKu für Basisumrechnung verwenden

  1. Öffnen Sie das Basisumrechnungswerkzeug
  2. Geben Sie einen Wert ein
  3. Wählen Sie die Eingabebasis
  4. Sehen Sie sich die Umrechnungsergebnisse in allen Basen an

FAQ

Warum unterstützen JavaScript-Bitoperationen nur 32 Bit?

JavaScript-Bitoperationen konvertieren Zahlen in 32-Bit-Vorzeichen-Ganzzahlen, Bits über 32 Bit werden abgeschnitten:

0xFFFFFFFF          // 4294967295 (normale Zahl)
0xFFFFFFFF | 0      // -1 (Überlauf bei int32-Konvertierung)

// Bitoperationen mit großen Zahlen erfordern BigInt
(0xFFFFFFFFFn & 0xFFn).toString(16)  // "ff"

Wie kann ich den binären Inhalt einer Datei anzeigen?

# hex dump
xxd file.bin

# Oder verwenden Sie den Hex-Viewer von ToolsKu
# Datei hochladen → hexadezimalen/binären Inhalt anzeigen

Zusammenfassung

Binärdaten sind die Grundlage der Datenverarbeitung — Berechtigungssysteme, Farbkodierung, Gleitkommagenauigkeit und Base64-Kodierung hängen davon ab. Die Beherrschung von Basisumrechnung und Bitoperationen ermöglicht es Ihnen, effizienteren Code auf niedrigerer Ebene zu schreiben. ToolsKu bietet Werkzeuge wie Basisumrechnung, Base64-Kodierung/Dekodierung und mehr, um Ihnen bei der schnellen Bearbeitung von Basis- und Kodierungsproblemen zu helfen.

#二进制#进制转换#位运算#数据可视化#教程