Leitfaden zur Zahlensystem-Umrechnung: Binär, Hexadezimal und Oktal erklärt

Wenn Sie jemals auf einen Hex-Farbcode wie #1A2B3C oder eine Unix-Berechtigung wie chmod 755 gestarrt und sich gefragt haben, woher diese Zahlen kommen, sind Sie nicht allein. Zahlensysteme gehören zu den grundlegenden Konzepten, die die meisten Entwickler täglich verwenden, ohne darüber nachzudenken — bis zu dem Moment, in dem sie tatsächlich zwischen ihnen umrechnen müssen.

Ändern wir das. Dieser Leitfaden erklärt die für die Programmierung relevanten Zahlensysteme, wie man zwischen ihnen umrechnet und wann welches in der Praxis vorkommt.

Was bedeutet „Basis" eigentlich?

Wir zählen in Basis 10 (Dezimalsystem), weil wir zehn Finger haben. Jede Ziffernposition repräsentiert eine Potenz von 10:

  4   2   7
  |   |   |
  |   |   └── 7 × 10⁰ = 7
  |   └────── 2 × 10¹ = 20
  └────────── 4 × 10² = 400
                         ───
                Total = 427

Das ist Stellenwertnotation. Die „Basis" (auch Radix genannt) gibt an, wie viele einzigartige Ziffern im System existieren und womit jede Position multipliziert wird. Basis 10 hat die Ziffern 0–9. Basis 2 hat die Ziffern 0 und 1. Basis 16 hat die Ziffern 0–9 und die Buchstaben A–F.

Das Konzept ist über alle Basen hinweg identisch — nur die Anzahl der verfügbaren Symbole und der Multiplikator pro Position ändern sich.

Binär (Basis 2): Die Sprache der Hardware

Warum Computer binär verwenden

Computer basieren auf Transistoren, und Transistoren haben zwei zuverlässige Zustände: an und aus. Das passt perfekt zu 1 und 0. Man könnte theoretisch einen Computer mit Basis 3 bauen, aber drei Spannungspegel zu unterscheiden ist schwieriger und fehleranfälliger als zwei zu unterscheiden. Das Binärsystem gewinnt, weil es einfach und robust ist.

Binärzahlen lesen

Binär funktioniert genauso wie Dezimal, aber jede Position repräsentiert eine Potenz von 2:

  1   0   1   1   0   1
  |   |   |   |   |   |
  |   |   |   |   |   └── 1 × 2⁰ =  1
  |   |   |   |   └────── 0 × 2¹ =  0
  |   |   |   └────────── 1 × 2² =  4
  |   |   └────────────── 1 × 2³ =  8
  |   └────────────────── 0 × 2⁴ =  0
  └────────────────────── 1 × 2⁵ = 32
                                    ──
                            Total = 45

Also entspricht 101101 im Binärsystem der Dezimalzahl 45. Man liest von rechts nach links und verdoppelt den Stellenwert jedes Mal: 1, 2, 4, 8, 16, 32, 64, 128 …

Bits, Bytes und darüber hinaus

• Bit: eine einzelne Binärziffer (0 oder 1)
• Nibble: 4 Bits (entspricht einer Hexadezimalziffer, Werte 0–15)
• Byte: 8 Bits (Werte 0–255)
• Kilobyte: 1.024 Bytes (2¹⁰)

Ein einzelnes Byte kann 256 verschiedene Werte darstellen. Deshalb passen ASCII-Zeichen in ein Byte, und RGB-Farbkanäle reichen von 0 bis 255.

Grundlagen der Binärarithmetik

Die Addition im Binärsystem folgt denselben Regeln wie im Dezimalsystem, aber der Übertrag erfolgt bei 2 statt bei 10:

    1 0 1 1   (11 in decimal)
  + 0 1 1 0   ( 6 in decimal)
  ─────────
  1 0 0 0 1   (17 in decimal)

Wenn 1 + 1 = 10 im Binärsystem ergibt (genau wie 9 + 1 = 10 im Dezimalsystem), schreibt man 0 und überträgt 1.

Oktal (Basis 8): Das Altsystem

Ein kurzer geschichtlicher Abriss

Das Oktalsystem war in den 1960er und 1970er Jahren bei Maschinen wie dem PDP-8 beliebt, der 12-Bit-Wörter verwendete — sauber in vier Gruppen zu je drei Bits aufteilbar. Jede Oktalziffer entspricht genau drei Binärziffern, was es zu einer praktischen Kurzschreibweise machte.

Wo man Oktal heute noch findet

Der häufigste Anwendungsfall sind die Unix-Dateiberechtigungen. Wenn Sie chmod 755 script.sh eingeben, ist jede Ziffer eine Oktalzahl, die die Berechtigungen Lesen (4), Schreiben (2) und Ausführen (1) darstellt:

7 = 4 + 2 + 1 = rwx  (owner: read, write, execute)
5 = 4 + 0 + 1 = r-x  (group: read, execute)
5 = 4 + 0 + 1 = r-x  (others: read, execute)

Oktalzahlen in der Programmierung verwenden das Präfix 0o (oder einfach eine führende 0 in C, was schon für zahlreiche Bugs gesorgt hat):

const permissions = 0o755;  // 493 in decimal
console.log(permissions.toString(8));  // "755"

Hexadezimal (Basis 16): Der Liebling der Entwickler

Warum Hexadezimal existiert

Das Hexadezimalsystem löst ein praktisches Problem: Binärzahlen werden schnell sehr lang. Die Dezimalzahl 255 ist 11111111 im Binärsystem — acht Ziffern. In Hexadezimal ist es einfach FF. Jede Hexadezimalziffer entspricht genau vier Binärziffern (einem Nibble), was Umrechnungen trivial und Zahlen kompakt macht.

Hexadezimal verwendet die Ziffern 0–9 plus die Buchstaben A–F:

Hexadezimal im Alltag

Webfarben sind die sichtbarste Anwendung von Hexadezimal. #FF5733 lässt sich so aufschlüsseln:

#FF5733
 ││││││
 ││││└┘── Blue:  0x33 = 51
 ││└┘──── Green: 0x57 = 87
 └┘────── Red:   0xFF = 255

Speicheradressen in Debuggern werden in Hexadezimal angezeigt: 0x7FFF5FBFFA10 ist lesbarer als der Dezimalwert 140.734.799.804.944.

MAC-Adressen verwenden durch Doppelpunkte getrennte Hex-Paare: A4:83:E7:2B:00:1F.

Farben in CSS: rgba(255, 87, 51, 1.0) und #FF5733 stellen dieselbe Farbe dar — Hexadezimal ist lediglich kompakter.

Umrechnung zwischen Basen

Dezimal nach Binär

Teilen Sie wiederholt durch 2 und sammeln Sie die Reste — lesen Sie sie von unten nach oben:

45 ÷ 2 = 22 remainder 1  ↑
22 ÷ 2 = 11 remainder 0  │
11 ÷ 2 =  5 remainder 1  │  Read upward:
 5 ÷ 2 =  2 remainder 1  │  101101
 2 ÷ 2 =  1 remainder 0  │
 1 ÷ 2 =  0 remainder 1  │

Ergebnis: 45 dezimal = 101101 binär.

Dezimal nach Hexadezimal

Derselbe Ansatz, aber durch 16 teilen:

427 ÷ 16 = 26 remainder 11 (B)  ↑
 26 ÷ 16 =  1 remainder 10 (A)  │  Read upward: 1AB
  1 ÷ 16 =  0 remainder  1      │

Ergebnis: 427 dezimal = 1AB hexadezimal.

Binär nach Hexadezimal (die einfache Umrechnung)

Gruppieren Sie die Binärziffern in Vierergruppen (von rechts nach links) und rechnen Sie jede Gruppe um:

Binary:  10 1101
Padded:  0010 1101
Groups:   2    D

Result: 0x2D

Überprüfung: 0x2D = 2×16 + 13 = 45 ✓

Hexadezimal nach Binär

Kehren Sie den Vorgang um. Erweitern Sie jede Hexadezimalziffer zu vier Binärziffern:

Hex:    F    A    3
Binary: 1111 1010 0011

Result: 111110100011

Zahlensystem-Notation in Programmiersprachen

Jede wichtige Sprache bietet eine Syntax, um Zahlen in verschiedenen Basen zu schreiben:

// JavaScript
const binary  = 0b101101;   // 45
const octal   = 0o55;       // 45
const hex     = 0x2D;       // 45
const decimal = 45;          // 45

(45).toString(2);   // "101101"
(45).toString(8);   // "55"
(45).toString(16);  // "2d"

parseInt("101101", 2);   // 45
parseInt("55", 8);       // 45
parseInt("2D", 16);      // 45

# Python
binary  = 0b101101   # 45
octal   = 0o55       # 45
hexval  = 0x2D       # 45

bin(45)    # '0b101101'
oct(45)    # '0o55'
hex(45)    # '0x2d'

int("101101", 2)   # 45
int("55", 8)       # 45
int("2D", 16)      # 45

// C / C++
int binary  = 0b101101;   // 45 (C23 / GCC extension)
int octal   = 055;        // 45 (leading zero = octal!)
int hex     = 0x2D;       // 45

Beachten Sie die C-Falle: Eine führende 0 bedeutet oktal. int x = 010; ergibt 8, nicht 10. Darüber sind schon unzählige Programmierer gestolpert.

Praktische Anwendungsfälle

Bitweise Operationen und Flags

const READ    = 0x01;  // 0001
const WRITE   = 0x02;  // 0010
const EXECUTE = 0x04;  // 0100
const ADMIN   = 0x08;  // 1000

let permissions = READ | WRITE;  // 0x03 = 0011
if (permissions & EXECUTE) {
  // check if execute bit is set
}

Debugging und Speicherinspektion

Wenn Sie einen Segmentation Fault an der Adresse 0xDEADBEEF sehen oder Speicher mit 0xCAFEBABE initialisiert wird, handelt es sich um Hex-Konstanten, die gezielt gewählt wurden, weil sie in Speicherabzügen leicht zu erkennen sind. Java-Klassendateien beginnen mit der magischen Zahl 0xCAFEBABE — und ja, jemand hatte Spaß beim Benennen.

Netzwerkprotokolle

IPv6-Adressen verwenden Hexadezimalnotation: 2001:0db8:85a3:0000:0000:8a2e:0370:7334. MAC-Adressen, USB-Hersteller-IDs und Bluetooth-UUIDs nutzen alle die Hexadezimaldarstellung, weil sie Binärdaten kompakt und lesbar hält.

Probieren Sie es selbst aus

Vergessen Sie das manuelle Rechnen. Unser Zahlensystem-Umrechner erledigt Umrechnungen zwischen beliebigen Basen sofort — Dezimal, Binär, Oktal, Hexadezimal oder jede benutzerdefinierte Basis bis 36. Fügen Sie eine Zahl ein, wählen Sie Quell- und Zielbasis, und erhalten Sie das Ergebnis augenblicklich. Alles läuft in Ihrem Browser, es werden keine Daten an einen Server gesendet.

Besonders nützlich ist es, wenn Sie:

• Hexadezimale Speicherabzüge durch Umrechnung in Dezimal debuggen möchten
• Unix-Berechtigungen in Binär/Oktal berechnen müssen
• Farbcodes zwischen Hexadezimal und RGB-Werten überprüfen möchten
• Zwischen Basen umrechnen müssen, die keine Zweierpotenzen sind

Weiterführende Ressourcen

• Base64-Kodierung erklärt — Base64 verwendet einen anderen Ansatz (6-Bit-Gruppen, die auf 64 Zeichen abgebildet werden), um Binärdaten als Text zu kodieren
• Hash-Algorithmen im Vergleich — Hash-Ausgaben werden typischerweise in Hexadezimal dargestellt
• Zahlensystem-Umrechner — rechnen Sie sofort zwischen beliebigen Basen in Ihrem Browser um

---

🛠️ Jetzt ausprobieren: Zahlensystem-Umrechner — rechnen Sie zwischen Binär, Oktal, Dezimal, Hexadezimal und jeder Basis bis 36 um. 100 % clientseitig, komplett kostenlos.