Zahlensysteme umrechnen: Binär, Hexadezimal, Oktal und Dezimal für Entwickler

An einem ganz normalen Nachmittag starrst du auf 0x7FFF5FBFF8C0 im Debugger, wechselst zu einer CSS-Datei um #FF5733 anzupassen und tippst chmod 755 ins Terminal. Drei verschiedene Zahlendarstellungen, dieselbe Arithmetik dahinter. Wenn du beim Umrechnen zwischen Hex und Binär kurz innehalten musst, oder dich fragst, warum Unix ausgerechnet Oktal für Berechtigungen verwendet — dieser Artikel bringt die Zusammenhänge auf den Punkt.

Wir gehen die vier Zahlensysteme durch, die im Programmieralltag auftauchen, drei Umrechnungsmethoden, die sich zu merken lohnen, und konkreten Code in JavaScript, Python, Go und C. Wer die Theorie überspringen und direkt eine Zahl umrechnen will, öffnet unseren Zahlensystem-Konverter — er unterstützt jede Basis von 2 bis 36 mit beliebiger Genauigkeit.

Die vier Zahlensysteme, die jeder Entwickler kennt

Jede Basis existiert in der Programmierung aus einem praktischen Grund.

Binär (Basis 2) — Die Sprache der Maschine

Zwei Ziffern: 0 und 1. Ein Transistor leitet oder sperrt — diese physikalische Einschränkung ergibt das Binärsystem. Du begegnest ihm bei Bitmasken, Feature-Flags, Bit-Operationen und IP-Subnetz-Berechnungen.

Binärzahlen werden schnell unhandlich. Die Dezimalzahl 255 ist binär 11111111 — acht Stellen für einen dreistelligen Wert. Deshalb schreiben Programmierer selten rohes Binär, es sei denn, die Position einzelner Bits spielt eine Rolle.

Oktal (Basis 8) — Die Unix-Kurzschrift

Acht Ziffern: 0 bis 7. Jede Oktalziffer entspricht exakt drei Binärbits — deshalb nutzt Unix Oktal für Dateiberechtigungen. chmod 755 packt drei Gruppen à drei Berechtigungsbits in drei lesbare Ziffern.

In der PDP-11-Ära war Oktal verbreiteter, als Maschinenwörter sich sauber in 3-Bit-Gruppen teilen ließen. Heute ist es fast ausschließlich eine Unix-Berechtigungssache, plus gelegentliche C-Literale mit 0-Präfix (die schon so manchen Bug verursacht haben, wenn jemand 0177 als Dezimal 177 interpretiert).

Dezimal (Basis 10) — Der menschliche Standard

Zehn Ziffern: 0 bis 9. Das ist das System, in dem dein Gehirn standardmäßig rechnet — Portnummern, Array-Indizes, HTTP-Statuscodes, Pixelmaße. Computer rechnen intern nicht dezimal, aber Menschen tun es, also kommt jede benutzerorientierte Zahl in Basis 10 heraus.

Hexadezimal (Basis 16) — Das Schweizer Taschenmesser des Entwicklers

Sechzehn Symbole: 0-9 und A-F. Jede Hex-Ziffer repräsentiert exakt vier Binärbits (ein Nibble). Zwei Hex-Ziffern = ein Byte. Immer.

Hex findest du in Speicheradressen (0x7FFF5FBFF8C0), CSS-Farben (#FF5733), MAC-Adressen (00:1A:2B:3C:4D:5E), UUID-Formaten und Hash-Digests. Es ist die Lingua franca der byteweisen Programmierung.

Teste die Umrechnung zwischen allen vier Systemen in unserem Zahlensystem-Konverter — gib einen Wert in beliebiger Basis ein und sieh, wie die anderen sofort aktualisiert werden.

So funktioniert die Basis-Umrechnung: drei grundlegende Methoden

Du brauchst kein Tool zum Umrechnen, auch wenn es den Vorgang beschleunigt. Drei Methoden decken jeden Fall ab.

Methode 1 — Stellenwert-Entwicklung (beliebige Basis → Dezimal)

Jedes Stellenwertsystem funktioniert gleich: Jede Ziffer wird mit der Basis hoch ihrer Position multipliziert, von rechts nach links ab null gezählt.

Binär 1011:

1×2³ + 0×2² + 1×2¹ + 1×2⁰
= 8   + 0    + 2    + 1
= 11

Hex FF:

15×16¹ + 15×16⁰
= 240   + 15
= 255

Im Code haben die meisten Sprachen eine Parse-Funktion:

parseInt('1011', 2)   // 11
parseInt('FF', 16)    // 255
parseInt('755', 8)    // 493

Methode 2 — Fortgesetzte Division (Dezimal → beliebige Basis)

Für die umgekehrte Richtung: Teile die Dezimalzahl wiederholt durch die Zielbasis und sammle die Reste. Lies sie von unten nach oben.

Dezimal 255 → Hexadezimal:

255 ÷ 16 = 15  Rest 15 (F)
 15 ÷ 16 =  0  Rest 15 (F)
→ Von unten nach oben: FF

Dezimal 42 → Binär:

42 ÷ 2 = 21  Rest 0
21 ÷ 2 = 10  Rest 1
10 ÷ 2 =  5  Rest 0
 5 ÷ 2 =  2  Rest 1
 2 ÷ 2 =  1  Rest 0
 1 ÷ 2 =  0  Rest 1
→ Von unten nach oben: 101010

bin(42)    # '0b101010'
hex(255)   # '0xff'
oct(493)   # '0o755'

Methode 3 — Bit-Gruppierung (Binär ↔ Hex/Oktal direkt)

Diese Methode nutzen erfahrene Entwickler am häufigsten. Da 16 = 2⁴ und 8 = 2³, lässt sich zwischen Binär und Hex (oder Oktal) durch reines Gruppieren umrechnen — keine Rechenoperationen nötig.

Binär → Hex: Gruppiere in Nibbles (4 Bits) von rechts. Fülle die linkeste Gruppe nötigenfalls mit Nullen auf.

Binär:        1010 1111
Hexadezimal:   A    F
→ AF

Binär → Oktal: Gruppiere in Dreierpakete (3 Bits) von rechts.

Binär: 111 101 101
Oktal:  7   5   5
→ 755

Die Nibble-Zuordnungstabelle lohnt sich auswendig zu lernen:

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

Sobald diese Tabelle sitzt, wird Binär-zu-Hex-Umrechnung zur Blickdiagnose.

Basis-Umrechnung in jeder Sprache

Praxiscode in den vier Sprachen, in denen Basis-Umrechnung am häufigsten vorkommt.

JavaScript / TypeScript

// Parsen: String in beliebiger Basis → Zahl
parseInt('FF', 16)          // 255
parseInt('101010', 2)       // 42
parseInt('755', 8)          // 493

// Formatieren: Zahl → String in beliebiger Basis
(255).toString(16)          // 'ff'
(42).toString(2)            // '101010'
(493).toString(8)           // '755'

// Literale
const bin = 0b11111111;     // 255
const oct = 0o377;          // 255
const hex = 0xff;           // 255

// BigInt für Werte jenseits von 2⁵³
const big = BigInt('0xFFFFFFFFFFFFFFFF');
big.toString(2)             // 64 Einsen
big.toString(10)            // '18446744073709551615'

Python

# Dezimal → andere Basen (Strings mit Präfix)
bin(255)          # '0b11111111'
oct(493)          # '0o755'
hex(255)          # '0xff'

# Andere Basen → Dezimal
int('11111111', 2)    # 255
int('FF', 16)         # 255
int('755', 8)         # 493

# Formatierte Ausgabe mit Auffüllung
f'{255:08b}'      # '11111111'  (8-stellig binär, nullgefüllt)
f'{255:02x}'      # 'ff'       (hex kleingeschrieben)
f'{255:02X}'      # 'FF'       (hex großgeschrieben)

# Python-Ganzzahlen haben nativ beliebige Genauigkeit
big = int('F' * 64, 16)   # 256-Bit-Zahl, kein Überlauf

Go

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Formatieren: int → String in beliebiger Basis
    fmt.Println(strconv.FormatInt(255, 16))  // "ff"
    fmt.Println(strconv.FormatInt(255, 2))   // "11111111"
    fmt.Println(strconv.FormatInt(493, 8))   // "755"

    // Parsen: String in beliebiger Basis → int
    n, _ := strconv.ParseInt("FF", 16, 64)  // 255
    fmt.Println(n)

    // Printf-Verben
    fmt.Printf("%b %o %x %d\n", 255, 255, 255, 255)
    // 11111111 377 ff 255
}

C

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

int main() {
    // Ausgabe in Dezimal, Oktal, Hexadezimal
    printf("%d %o %x\n", 255, 255, 255);
    // 255 377 ff

    // Parsen aus beliebiger Basis
    long val = strtol("FF", NULL, 16);   // 255
    long bin = strtol("101010", NULL, 2); // 42

    // Kein eingebautes binäres printf — manuelle Bit-Extraktion:
    uint8_t byte = 0xAF;
    for (int i = 7; i >= 0; i--)
        putchar(((byte >> i) & 1) ? '1' : '0');
    // 10101111

    return 0;
}

Praxisszenarien der Basis-Umrechnung

Fünf Situationen, in denen Basis-Umrechnung zum Arbeitsalltag gehört.

1. Speicheradressen debuggen

Der Debugger zeigt einen Pointer auf 0x7FFF5FBFF8C0. Die letzten zwei Bytes binär umgerechnet — 1000 1100 0000 — verraten eine 64-Byte-Ausrichtung (sechs abschließende Nullen). Ausrichtung beeinflusst Cache-Performance, SIMD-Operationen und Memory-Mapped I/O.

Pointer-Arithmetik ist in Hex ebenfalls übersichtlicher. Ein Offset von 0x100 ab einer Basisadresse sind exakt 256 Bytes — in vielen Embedded-Systemen eine Speicherseite.

2. CSS-Hex-Farben ↔ RGB

Die Farbe #FF5733 besteht aus drei Bytes als Hex-Paare:

Paar	Hex	Dezimal	Kanal
`FF`	FF	255	Rot (max)
`57`	57	87	Grün
`33`	33	51	Blau

Die Kurzschreibweise #F00 wird zu #FF0000 erweitert — reines Rot. Die 8-Zeichen-Variante #FF573380 fügt einen Alpha-Kanal hinzu, wobei 80 (dezimal 128) etwa 50 % Deckkraft entspricht.

3. Unix-Dateiberechtigungen (Oktal)

chmod 755 aufgeschlüsselt:

7 → 111 → rwx  (Eigentümer: Lesen + Schreiben + Ausführen)
5 → 101 → r-x  (Gruppe: Lesen + Ausführen)
5 → 101 → r-x  (Andere: Lesen + Ausführen)

Jede Oktalziffer codiert eine Berechtigungsgruppe, weil drei Berechtigungsbits (Lesen=4, Schreiben=2, Ausführen=1) auf eine einzige Oktalziffer (0-7) abbilden. Gängige Kombinationen:

Oktal	Binär	Berechtigungen	Typischer Einsatz
`755`	`111 101 101`	`rwxr-xr-x`	Ausführbare Dateien
`644`	`110 100 100`	`rw-r--r--`	Reguläre Dateien
`700`	`111 000 000`	`rwx------`	Private Skripte
`600`	`110 000 000`	`rw-------`	SSH-Schlüssel

4. Netzwerk-Subnetz-Berechnungen

Eine /24-Subnetzmaske bedeutet 24 führende Einsen in Binär:

11111111.11111111.11111111.00000000
→ 255.255.255.0

Um die Netzwerkadresse zu ermitteln, verknüpfe IP und Maske mit bitweisem AND:

192.168.1.37   → 11000000.10101000.00000001.00100101
255.255.255.0  → 11111111.11111111.11111111.00000000
AND-Ergebnis   → 11000000.10101000.00000001.00000000
               → 192.168.1.0 (Netzwerkadresse)

Netzwerkingenieure wechseln routinemäßig zwischen Dezimal (IP-Notation), Binär (Subnetzrechnung) und Hexadezimal (Paketmitschnitte). Unser Zahlensystem-Konverter erlaubt die Überprüfung jedes Oktetts einzeln.

5. Hash-Digests und UUIDs lesen

Ein MD5-Hash wie d41d8cd98f00b204e9800998ecf8427e besteht aus 32 Hex-Zeichen — 16 Bytes (128 Bits). Jedes Hex-Paar entspricht einem Byte.

Eine UUID folgt dem Hex-Muster 8-4-4-4-12:

550e8400-e29b-41d4-a716-446655440000

32 Hex-Ziffern mit Bindestrichen — dieselben 128 Bits, anders formatiert. Das Versions-Nibble an Position 13 (die 4 in 41d4) kennzeichnet UUID v4.

Generiere Hashes mit unserem MD5- & SHA-Hash-Generator oder erstelle UUIDs mit unserem UUID-Generator — beide liefern hexadezimale Ausgabe.

Jenseits von Basis 16: Basis 36, Basis 64 und eigene Basen

Die vier Standardbasen decken die meiste Arbeit ab, aber einige andere tauchen in Spezialfällen auf.

Basis 36 — Kompakte alphanumerische Kodierung

Basis 36 nutzt alle 10 Ziffern plus 26 Buchstaben (A-Z) und bietet damit die kompakteste Groß-/Kleinschreibung-unabhängige alphanumerische Darstellung. URL-Kürzungsdienste setzen darauf — YouTube-Video-IDs, Kurzlinks und Datenbank-Kurzschlüssel verwenden häufig Basis 36.

(1000000).toString(36)    // 'lfls'
parseInt('lfls', 36)      // 1000000

Eine Million in vier Zeichen. Für URL-taugliche Kurzbezeichner kaum zu unterbieten.

Basis 64 — Datenkodierung (kein Zahlensystem)

Base64 sieht aus wie eine weitere Basis, dient aber einem anderen Zweck. Statt einen numerischen Wert in einem Stellenwertsystem darzustellen, kodiert Base64 beliebige Binärdaten (Bilder, Dateien, JWT-Tokens) als ASCII-Text. Es verwendet A-Z, a-z, 0-9, + und / — 64 Symbole insgesamt.

Das ist ein Kodierungsschema, kein Zahlensystem. Zum Kodieren und Dekodieren von Base64 nutze unseren Base64-Kodierer & -Dekodierer.

Beliebige Basen (2-36) und wo sie auftreten

Ein paar weitere Basen begegnen dir gelegentlich:

Basis 12 (Duodezimal): Zeitrechnung (12 Stunden), Mengenangaben (ein Dutzend). Manche Mathematiker argumentieren, Basis 12 wäre besser als Basis 10, da 12 mehr Teiler hat.
Basis 60 (Sexagesimal): Zeit (60 Sekunden, 60 Minuten) und Winkel (360°). Aus der babylonischen Mathematik übernommen.
Basis 32: Crockfords Base32-Kodierung für menschenlesbare Bezeichner (ohne verwechselbare Zeichen wie I, L, O). Auch beim Geohashing im Einsatz.

Unser Zahlensystem-Konverter unterstützt jede ganzzahlige Basis von 2 bis 36.

Bitweise Operationen und Basis-Umrechnung

Binär zu verstehen geht über Zahlenumrechnung hinaus — es ist das Fundament für Bit-Operationen, die in Systemprogrammierung, Spieleentwicklung und Berechtigungssystemen allgegenwärtig sind.

const READ  = 0b100;  // 4
const WRITE = 0b010;  // 2
const EXEC  = 0b001;  // 1

// Berechtigungen mit OR kombinieren
const perms = READ | WRITE;  // 0b110 = 6

// Berechtigung mit AND prüfen
(perms & READ)  !== 0   // true  — Leseberechtigung vorhanden
(perms & EXEC)  !== 0   // false — keine Ausführberechtigung

// Berechtigung mit XOR umschalten
perms ^ WRITE   // 0b100 = 4 — Schreibberechtigung entfernt

// Verschiebeoperationen
1 << 3    // 0b1000 = 8  (1 um 3 nach links verschoben)
0xFF >> 4  // 0b00001111 = 15  (Rechtsverschiebung um 4 = Division durch 16)

Feature-Flags, Hardware-Register, Netzwerkprotokolle, Grafikprogrammierung — alles setzt auf Bit-Operationen. Wenn du Binärzahlen fließend liest, hört Bit-Manipulation auf, wie Magie auszusehen.

FAQ

Welche vier Zahlensysteme sind in der Programmierung am wichtigsten?

Binär (Basis 2), Oktal (Basis 8), Dezimal (Basis 10) und Hexadezimal (Basis 16). Binär ist die physische Form der Daten in der Hardware. Oktal dient Unix-Dateiberechtigungen. Dezimal ist der menschliche Standard. Hexadezimal komprimiert Binärdaten lesbar — jede Hex-Ziffer entspricht genau 4 Bits.

Wie rechne ich Binär in Hexadezimal um?

Gruppiere die Bits von rechts in Vierergruppen, fülle die linkeste Gruppe nötigenfalls mit Nullen. Ordne jede Gruppe zu: 0000=0, 0001=1, …, 1010=A, …, 1111=F. Beispiel: Binär 10101111 → Gruppen 1010 1111 → Hex AF. Funktioniert, weil 16 = 2⁴.

Wie rechne ich Hexadezimal in Dezimal um?

Multipliziere jede Hex-Ziffer mit 16 hoch ihrer Position (ganz rechts = 0), dann summiere. Merke: A=10, B=11, C=12, D=13, E=14, F=15. Beispiel: Hex FF = 15×16¹ + 15×16⁰ = 240 + 15 = 255. Im Code: JavaScript parseInt('FF', 16), Python int('FF', 16).

Warum nutzen Entwickler Hexadezimal statt Binär?

Hex ist kompakt. Jede Hex-Ziffer bildet exakt 4 Bits ab, sodass binär 11111111 00001010 zu hex FF0A wird — deutlich kürzer und übersichtlicher. Hex ist der Standard für Speicheradressen, CSS-Farben (#FF5733), MAC-Adressen, Hash-Ausgaben und UUID-Formate.

Was ist ein Nibble und welche Rolle spielt es bei der Hex-Umrechnung?

Ein Nibble sind 4 Bits — ein halbes Byte. Ein Nibble bildet sich exakt auf eine Hex-Ziffer ab, weshalb die Binär-Hex-Umrechnung ein simples Nibble-für-Nibble-Nachschlagen ist. Ein Byte = zwei Nibbles = zwei Hex-Ziffern. Diese saubere 4-Bit-Zuordnung ist der Grund, warum Hex zum Standard für byteweise Daten wurde.

Warum sind Unix-Berechtigungen in Oktal notiert?

Jede Berechtigungsgruppe hat drei Bits: Lesen (4), Schreiben (2), Ausführen (1). Es gibt drei Gruppen (Eigentümer, Gruppe, Andere). Da 2³ = 8, passen drei Berechtigungsbits in eine einzige Oktalziffer. 755 bedeutet Eigentümer=7 (rwx), Gruppe=5 (r-x), Andere=5 (r-x). Oktal ist die natürliche Basis für 3-Bit-Gruppierungen.

Wie gehe ich in JavaScript mit Zahlen größer als 2⁵³ um?

Verwende BigInt. Hänge n an ein Literal oder nutze den BigInt()-Konstruktor: BigInt('0xFFFFFFFFFFFFFFFF').toString(2) liefert den vollständigen 64-Bit-Binärstring. Der Standard-Number-Typ verliert jenseits von 9.007.199.254.740.991 (2⁵³ - 1) an Genauigkeit. Unser Zahlensystem-Konverter nutzt intern BigInt und verarbeitet Zahlen beliebiger Größe ohne Präzisionsverlust.

Wie rechne ich Hexadezimal in Binär um?

Ersetze jede Hex-Ziffer durch ihren 4-Bit-Binärwert über die Nibble-Tabelle in umgekehrter Richtung: 0=0000, 1=0001, …, A=1010, …, F=1111. Beispiel: Hex AF → A (1010) + F (1111) → Binär 10101111. Im Code: JavaScript parseInt('AF', 16).toString(2) oder Python bin(int('AF', 16))[2:].

Wie stelle ich setuid-, setgid- und Sticky-Bits in Oktal dar?

Spezialbits werden als vierte oktale Ziffer vorangestellt: setuid (4), setgid (2), Sticky (1). chmod 4755 aktiviert setuid (passwd läuft so mit den Rechten des Eigentümers). chmod 2755 aktiviert setgid — in Shared-Directories üblich, damit neue Dateien die Gruppe des Verzeichnisses erben. chmod 1777 setzt das Sticky-Bit (wie bei /tmp: jeder darf schreiben, aber nur der Dateieigentümer löschen). In ls -l erscheinen diese Bits als s bzw. t an Stelle des x in der jeweiligen Spalte — Großbuchstabe S/T bedeutet: Bit gesetzt, aber Ausführrecht fehlt (Warnsignal für Fehlkonfiguration).