Een handleiding voor ontwikkelaars over talstelsel-omrekenen: binary, hex, octal & decimal

Op een middag staar je naar 0x7FFF5FBFF8C0 in een debugger, dan schakel je over naar een CSS-bestand om #FF5733 aan te passen, en daarna voer je chmod 755 uit in een terminal. Drie verschillende getalsrepresentaties, dezelfde onderliggende rekenkunde. Als je ooit even moest nadenken om hex naar binary om te rekenen, of je je weleens hebt afgevraagd waarom Unix-permissies nou juist octal gebruiken — in deze handleiding valt alles op zijn plek.

We behandelen de vier talstelsels die dagelijks opduiken in programmeerwerk, de drie conversiemethoden die het waard zijn om te onthouden, en echte code in JavaScript, Python, Go en C. Als je de theorie wilt overslaan en gewoon een getal wilt omrekenen, open dan onze Talstelsel-converter — die elk talstelsel van 2 tot 36 verwerkt met onbeperkte precisie.

De vier talstelsels die elke ontwikkelaar gebruikt

Elk talstelsel bestaat in de programmering om een praktische reden, niet door toeval uit de geschiedenis.

Binary (grondtal 2) — de taal van de machine

Twee cijfers: 0 en 1. Een transistor staat aan of uit — die fysieke beperking geeft ons binary. Je komt het direct tegen bij bitmasks, feature flags, bitsgewijze bewerkingen en IP-subnetberekeningen.

Binary wordt snel onhandig. Het decimale getal 255 is 11111111 in binary — acht cijfers voor een waarde die in drie decimale cijfers past. Dat is precies de reden waarom programmeurs zelden onbewerkte binary schrijven, behalve wanneer individuele bitposities ertoe doen.

Octal (grondtal 8) — de Unix-afkorting

Acht cijfers: 0 tot en met 7. Elk octal-cijfer komt overeen met precies drie binary bits, en dat is waarom Unix-bestandspermissies octal gebruiken — chmod 755 verpakt drie groepen van drie permissiebits in drie leesbare cijfers.

Octal had een grotere rol in het PDP-11-tijdperk, toen machinewoorden netjes in 3-bit-groepen werden verdeeld. Tegenwoordig is het vooral een Unix-permissiezaak, plus het af en toe voorkomende C-literal met een 0-prefix (wat meer dan een paar off-by-one-bugs heeft veroorzaakt wanneer iemand 0177 schrijft en decimaal 177 verwacht).

Decimal (grondtal 10) — de menselijke standaard

Tien cijfers: 0 tot en met 9. Dit is het stelsel waarop je brein standaard terugvalt — poortnummers, array-indices, HTTP-statuscodes, pixelafmetingen. Computers denken niet in decimal, maar mensen wel, dus elk getal dat aan de gebruiker wordt getoond, verschijnt in grondtal 10.

Hexadecimal (grondtal 16) — het Zwitserse zakmes van de ontwikkelaar

Zestien symbolen: 0-9 en A-F. Elk hex-cijfer stelt precies vier binary bits voor (een nibble), waardoor hex de ideale compacte representatie van binary-data is. Twee hex-cijfers = één byte. Altijd.

Je ziet hex in geheugenadressen (0x7FFF5FBFF8C0), CSS-kleuren (#FF5733), MAC-adressen (00:1A:2B:3C:4D:5E), UUID-opmaak en hash-samenvattingen. Het is de lingua franca van programmeren op byteniveau.

Probeer alle vier de stelsels om te rekenen in onze Talstelsel-converter — typ een waarde in een willekeurig talstelsel en zie de andere direct bijwerken.

Hoe talstelsel-omrekenen werkt: drie kernmethoden

Je hebt geen tool nodig om tussen talstelsels om te rekenen, al versnelt een tool het zeker. Drie methoden dekken elk geval af.

Methode 1 — Positionele waarden (elk talstelsel → decimal)

Elk positioneel talstelsel werkt op dezelfde manier: elk cijfer wordt vermenigvuldigd met het grondtal verheven tot de macht van zijn positie, geteld van rechts af, beginnend bij nul.

Binary 1011:

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

Hex FF:

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

In code verwerken de meeste talen dit met een parse-functie:

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

Methode 2 — Herhaalde deling (decimal → elk talstelsel)

Om de andere kant op te gaan, deel je het decimale getal herhaaldelijk door het doelgrondtal en verzamel je de restwaarden. Lees de restwaarden van onder naar boven.

Decimal 255 → hexadecimal:

255 ÷ 16 = 15  remainder 15 (F)
 15 ÷ 16 =  0  remainder 15 (F)
→ Read upward: FF

Decimal 42 → binary:

42 ÷ 2 = 21  remainder 0
21 ÷ 2 = 10  remainder 1
10 ÷ 2 =  5  remainder 0
 5 ÷ 2 =  2  remainder 1
 2 ÷ 2 =  1  remainder 0
 1 ÷ 2 =  0  remainder 1
→ Read upward: 101010

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

Methode 3 — Bitgroepering (binary ↔ hex/octal direct)

Dit is de methode die ervaren ontwikkelaars het vaakst gebruiken. Omdat 16 = 2⁴ en 8 = 2³, kun je direct tussen binary en hex (of octal) omrekenen door bits te groeperen — zonder rekenkunde.

Binary → hex: Groepeer in nibbles (4 bits) van rechts. Voeg zo nodig nullen toe aan de meest linkse groep.

Binary:  1010 1111
Hex:      A    F
→ AF

Binary → octal: Groepeer in drietallen (3 bits) van rechts.

Binary:  111 101 101
Octal:    7   5   5
→ 755

De nibble-opzoektabel is de moeite waard om uit je hoofd te leren:

Binary	Hex	Binary	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

Zodra je deze tabel hebt geïnternaliseerd, wordt binary-naar-hex-omrekenen een kwestie van kijken en lezen.

Talstelsel-omrekenen in elke taal

Zo ga je om met talstelsel-omrekenen in de vier talen waar het het meest voorkomt.

JavaScript / TypeScript

// Parsing: string in any base → number
parseInt('FF', 16)          // 255
parseInt('101010', 2)       // 42
parseInt('755', 8)          // 493

// Formatting: number → string in any base
(255).toString(16)          // 'ff'
(42).toString(2)            // '101010'
(493).toString(8)           // '755'

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

// BigInt for values beyond 2⁵³
const big = BigInt('0xFFFFFFFFFFFFFFFF');
big.toString(2)             // 64 ones
big.toString(10)            // '18446744073709551615'

Python

# Decimal → other bases (returns prefixed strings)
bin(255)          # '0b11111111'
oct(493)          # '0o755'
hex(255)          # '0xff'

# Other bases → decimal
int('11111111', 2)    # 255
int('FF', 16)         # 255
int('755', 8)         # 493

# Formatted output with padding
f'{255:08b}'      # '11111111'  (8-digit binary, zero-padded)
f'{255:02x}'      # 'ff'       (2-digit hex, lowercase)
f'{255:02X}'      # 'FF'       (2-digit hex, uppercase)

# Python integers have arbitrary precision by default
big = int('F' * 64, 16)   # 256-bit number, no overflow

Go

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Formatting: int → string in any base
    fmt.Println(strconv.FormatInt(255, 16))  // "ff"
    fmt.Println(strconv.FormatInt(255, 2))   // "11111111"
    fmt.Println(strconv.FormatInt(493, 8))   // "755"

    // Parsing: string in any base → int
    n, _ := strconv.ParseInt("FF", 16, 64)  // 255
    fmt.Println(n)

    // Printf verbs
    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() {
    // Output in decimal, octal, hex
    printf("%d %o %x\n", 255, 255, 255);
    // 255 377 ff

    // Parse from any base
    long val = strtol("FF", NULL, 16);   // 255
    long bin = strtol("101010", NULL, 2); // 42

    // No built-in binary printf — manual extraction:
    uint8_t byte = 0xAF;
    for (int i = 7; i >= 0; i--)
        putchar(((byte >> i) & 1) ? '1' : '0');
    // 10101111

    return 0;
}

Praktische toepassingen van talstelsel-omrekenen

Vijf situaties waarbij talstelsel-omrekenen ophoudt theoretisch te zijn en onderdeel wordt van het dagelijkse werk.

1. Debuggen van geheugenadressen

Je debugger toont een pointer op 0x7FFF5FBFF8C0. De laatste twee bytes omrekenen naar binary — 1000 1100 0000 — laat zien dat het adres uitlijnt op een grens van 64 bytes (zes afsluitende nullen). Uitlijning is bepalend voor cache-prestaties, SIMD-bewerkingen en memory-mapped I/O. De hex-representatie maakt deze patronen in één oogopslag zichtbaar.

Pointerrekenkunde is ook eenvoudiger te redeneren in hex. Offset 0x100 ten opzichte van een basisadres is precies 256 bytes — één pagina in veel embedded systemen. In decimal is dat minder voor de hand liggend.

2. CSS hex-kleuren ↔ RGB

De kleur #FF5733 is drie bytes verpakt als hex-paren:

Paar	Hex	Decimal	Kanaal
`FF`	FF	255	Rood (maximaal)
`57`	57	87	Groen
`33`	33	51	Blauw

Verkorte notatie zoals #F00 wordt uitgebreid naar #FF0000 — puur rood. De 8-cijferige variant #FF573380 voegt een alpha-kanaal toe waarbij 80 (decimaal 128) ongeveer 50% dekking is.

Als je de hex-naar-decimal-koppeling kent, hoef je minder snel naar een kleurenkiezer te grijpen wanneer je een kanaal een bepaald bedrag omhoog of omlaag wilt aanpassen.

3. Unix-bestandspermissies (octal)

chmod 755 valt uiteen als:

7 → 111 → rwx  (owner: read + write + execute)
5 → 101 → r-x  (group: read + execute)
5 → 101 → r-x  (others: read + execute)

Elk octal-cijfer stelt precies één permissiegroep voor, omdat drie permissiebits (read=4, write=2, execute=1) overeenkomen met één octal-cijfer (0-7). Veelvoorkomende patronen:

Octal	Binary	Permissies	Typisch gebruik
`755`	`111 101 101`	`rwxr-xr-x`	Uitvoerbare bestanden, mappen
`644`	`110 100 100`	`rw-r--r--`	Gewone bestanden
`700`	`111 000 000`	`rwx------`	Privéscripts
`600`	`110 000 000`	`rw-------`	SSH-sleutels, geheimen

4. Subnetberekeningen voor netwerken

Een /24-subnetmasker betekent 24 opeenvolgende enen in binary:

11111111.11111111.11111111.00000000
→ 255.255.255.0

Om het netwerkadres te vinden, AND je het IP-adres en het masker in binary:

192.168.1.37   → 11000000.10101000.00000001.00100101
255.255.255.0  → 11111111.11111111.11111111.00000000
AND result     → 11000000.10101000.00000001.00000000
               → 192.168.1.0 (network address)

Netwerkingenieurs rekenen routinematig om tussen decimal (IP-notatie), binary (subnetberekeningen) en soms hex (packet captures). Onze Talstelsel-converter verwerkt elk octet afzonderlijk als je de voorkeur geeft aan een visuele controle.

5. Hash-samenvattingen en UUID’s lezen

Een MD5-hash zoals d41d8cd98f00b204e9800998ecf8427e bestaat uit 32 hex-tekens, die 16 bytes (128 bits) voorstellen. Elk paar hex-cijfers is één byte.

Een UUID volgt het 8-4-4-4-12 hex-patroon:

550e8400-e29b-41d4-a716-446655440000

Dat zijn 32 hex-cijfers gescheiden door koppeltekens — dezelfde 128 bits, alleen anders opgemaakt. De versienibble staat op positie 13 (de 4 in 41d4 betekent UUID v4).

Genereer hashes met onze MD5 & SHA Hash Generator of maak UUID’s aan met onze UUID Generator — beide produceren hex-uitvoer die direct overeenkomt met de binary-representaties die hier worden besproken.

Verder dan grondtal 16: grondtal 36, Base64 en aangepaste talstelsels

De vier standaardtalstelsels dekken het meeste werk, maar een paar andere duiken op in gespecialiseerde contexten.

Grondtal 36 — compacte alfanumerieke codering

Grondtal 36 gebruikt alle 10 cijfers plus 26 letters (A-Z), waardoor je de meest compacte hoofdletterongevoelige alfanumerieke representatie krijgt. URL-verkorters zijn er dol op — YouTube-video-ID’s, korte links en compacte databasesleutels gebruiken vaak grondtal 36.

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

Decimaal 1.000.000 wordt teruggebracht tot maar vier tekens. Voor URL-veilige korte identifiers is dat moeilijk te evenaren.

Base64 — data-codering (geen talstelsel)

Base64 lijkt op een ander talstelsel, maar dient een ander doel. In plaats van een numerieke waarde in een positioneel stelsel voor te stellen, encodeer je met Base64 willekeurige binary-data (afbeeldingen, bestanden, JWT-tokens) als ASCII-tekst. Het gebruikt A-Z, a-z, 0-9, + en / — 64 symbolen in totaal.

De rekenkunde verschilt van talstelsel-omrekenen. Base64 verwerkt invoer in blokken van 3 bytes (24 bits) en produceert vier tekens van 6 bits. Het is een coderingsschema, geen talstelsel.

Gebruik onze Base64 Encoder & Decoder voor het encoderen en decoderen van Base64-data.

Willekeurige talstelsels (2-36) en wanneer ze voorkomen

Een paar andere talstelsels duiken in de praktijk op:

Grondtal 12 (dozenstelsel): Tijd (12 uur), hoeveelheden (een dozijn). Sommige wiskundigen beweren dat grondtal 12 beter zou zijn dan grondtal 10 voor dagelijks gebruik, omdat 12 meer delers heeft.
Grondtal 60 (sexagesimaal): Tijd (60 seconden, 60 minuten) en hoeken (360°). Overgeërfd van de Babylonische wiskunde.
Grondtal 32: Crockford’s Base32-codering voor mensleesbare identifiers (sluit dubbelzinnige tekens zoals I, L, O uit). Ook gebruikt bij geohashing.

Onze Talstelsel-converter ondersteunt elk geheel talstelsel van 2 tot 36.

Bitsgewijze bewerkingen en talstelsel-omrekenen

Binary begrijpen gaat niet alleen over het omrekenen van getallen — het is de basis voor bitsgewijze bewerkingen die opduiken in systeemprogrammering, game-ontwikkeling en permissiesystemen.

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

// Combine permissions with OR
const perms = READ | WRITE;  // 0b110 = 6

// Check a specific permission with AND
(perms & READ)  !== 0   // true  — has read
(perms & EXEC)  !== 0   // false — no exec

// Toggle a permission with XOR
perms ^ WRITE   // 0b100 = 4 — write removed

// Shift operations
1 << 3    // 0b1000 = 8  (1 shifted left by 3)
0xFF >> 4  // 0b00001111 = 15  (right shift by 4 = divide by 16)

Feature flags, hardwareregisters, netwerkprotocollen en grafische programmering leunen allemaal op bitsgewijze bewerkingen. Zodra binary op zijn plek valt, leest bitmanipulatie als gewone logica — geen magie aan te pas.

FAQ

Wat zijn de vier belangrijkste talstelsels in de programmering?

Binary (grondtal 2), octal (grondtal 8), decimal (grondtal 10) en hexadecimal (grondtal 16). Binary is de manier waarop data fysiek bestaat in hardware. Octal komt overeen met Unix-bestandspermissies. Decimal is de standaard voor gebruikers. Hex vat binary samen in een compactere vorm — elk hex-cijfer staat voor precies 4 bits.

Hoe reken ik binary naar hexadecimal om?

Groepeer binary-cijfers in sets van 4 van rechts naar links, en voeg zo nodig nullen toe aan de meest linkse groep. Koppel elke groep: 0000=0, 0001=1, …, 1010=A, …, 1111=F. Voorbeeld: binary 10101111 → groepen 1010 1111 → hex AF. Dit werkt omdat 16 = 2⁴.

Hoe reken ik hexadecimal naar decimal om?

Vermenigvuldig elk hex-cijfer met 16 verheven tot de macht van zijn positie (meest rechts = 0) en tel alles bij elkaar op. A=10, B=11, C=12, D=13, E=14, F=15. Voorbeeld: hex FF = 15×16¹ + 15×16⁰ = 240 + 15 = 255. In code: JavaScript parseInt('FF', 16), Python int('FF', 16).

Waarom gebruiken programmeurs hexadecimal in plaats van binary?

Hex is compact. Elk hex-cijfer komt overeen met precies 4 bits, dus 11111111 00001010 in binary wordt FF0A in hex — veel korter en gemakkelijker te scannen. Hex is de standaard voor geheugenadressen, CSS-kleuren (#FF5733), MAC-adressen, hash-uitvoer en UUID-opmaak.

Wat is een nibble en waarom is het belangrijk voor hex-omrekenen?

Een nibble is 4 binary bits — de helft van een byte. Één nibble komt overeen met precies één hex-cijfer, waardoor binary-naar-hex-omrekenen gewoon een nibble-voor-nibble-opzoekactie is. Eén byte = twee nibbles = twee hex-cijfers. Deze nette 4-bit-koppeling is de reden waarom hex de standaard werd voor het voorstellen van data op byteniveau.

Waarom worden Unix-bestandspermissies in octal geschreven?

Drie permissiebits (read=4, write=2, execute=1) per groep, drie groepen (eigenaar, groep, anderen). Omdat 2³ = 8, komt elke groep van drie bits overeen met één octal-cijfer. 755 betekent eigenaar=7 (rwx), groep=5 (r-x), anderen=5 (r-x). Octal is het natuurlijke talstelsel voor 3-bit-groeperingen.

Hoe ga ik om met getallen groter dan 2⁵³ in JavaScript?

Gebruik BigInt. Voeg n toe aan een literal of gebruik de BigInt()-constructor: BigInt('0xFFFFFFFFFFFFFFFF').toString(2) produceert de volledige 64-bit binary string. Standaard Number verliest precisie boven 9.007.199.254.740.991 (2⁵³ - 1). Onze Talstelsel-converter gebruikt intern BigInt, zodat getallen van elke omvang zonder precisieverlies worden verwerkt.

Hoe reken ik hexadecimal naar binary om?

Vervang elk hex-cijfer door zijn 4-bit binary equivalent, met dezelfde nibble-tabel in omgekeerde volgorde: 0=0000, 1=0001, …, A=1010, …, F=1111. Voorbeeld: hex AF → A (1010) + F (1111) → binary 10101111. In code: JavaScript parseInt('AF', 16).toString(2) of Python bin(int('AF', 16))[2:].

Waarom hebben CSS hex-kleuren soms 3, 6 of 8 cijfers?

Alle drie de vormen verwijzen naar hetzelfde RGB-model, maar geven een andere precisie en transparantie weer. 3-cijferig #F0A is een afkorting die uitbreidt naar #FF00AA (elk cijfer verdubbeld). 6-cijferig #FF00AA is de standaard RGB-vorm — twee hex-cijfers per kanaal. 8-cijferig #FF00AA80 voegt een alpha-kanaal toe als een vierde byte, waarbij 80 (decimaal 128) ~50% dekking is. Moderne browsers accepteren alle drie; ontwerpers kiezen de kortste vorm die de bedoeling bewaart.