Skip to content

Twee-complement calculator voor getallen met teken

Typ een geheel getal met teken en krijg teken-magnitude, één-complement, twee-complement en offset-binair in één keer, van 4 tot 64 bit. Of plak bits of een hex-byte en lees alle vijf de interpretaties naast elkaar.

Geen tracking Draait in je browser Gratis
Alles wordt lokaal in je browser berekend — niets van wat je typt wordt geüpload.
Bitbreedte

Decimaal naar machinerepresentatie

Typ een geheel getal met teken. Alle vier de representaties worden tegelijk berekend — je hoeft niet vooraf te weten welke jouw systeem gebruikt.

Probeer deze
Codering Bits Hex
Teken-magnitude 1000 0101 85
Één-complement 1111 1010 FA
Twee-complement 1111 1011 FB
Offset-binair 0111 1011 7B

Bitpatroon naar waarde

Je vond een byte in een geheugendump of een register en weet niet hoe die gelezen hoort te worden. Plak hem en zie in één keer wat hij onder elke interpretatie betekent — welke de juiste is hangt af van het systeem dat hem produceerde, dus ze staan er allemaal.

Gelezen als Waarde
Zonder teken 251
Teken-magnitude -123
Één-complement -4
Twee-complement -5
Offset-binair 123
8-bits referentietabel

Berekend door dezelfde motor als de tool hierboven, dus deze waarden kunnen er niet van afwijken.

Decimaal Teken-magnitude Één-complement Twee-complement Offset-binair Hex
127 0111 1111 0111 1111 0111 1111 1111 1111 7F
100 0110 0100 0110 0100 0110 0100 1110 0100 64
10 0000 1010 0000 1010 0000 1010 1000 1010 0A
5 0000 0101 0000 0101 0000 0101 1000 0101 05
1 0000 0001 0000 0001 0000 0001 1000 0001 01
0 0000 0000 0000 0000 0000 0000 1000 0000 00
-1 1000 0001 1111 1110 1111 1111 0111 1111 FF
-5 1000 0101 1111 1010 1111 1011 0111 1011 FB
-10 1000 1010 1111 0101 1111 0110 0111 0110 F6
-100 1110 0100 1001 1011 1001 1100 0001 1100 9C
-127 1111 1111 1000 0000 1000 0001 0000 0001 81
-128 — — 1000 0000 0000 0000 80
Waardebereiken per bitbreedte
Breedte Twee-complement / offset-binair Teken-magnitude / één-complement
4 -8 … 7 -7 … 7
8 -128 … 127 -127 … 127
16 -32768 … 32767 -32767 … 32767
32 -2147483648 … 2147483647 -2147483647 … 2147483647
64 -9223372036854775808 … 9223372036854775807 -9223372036854775807 … 9223372036854775807
Elke codering wordt in de testsuite vastgelegd voor alle vijf de breedtes, inclusief het volledige 4-bits bereik, beide nulpatronen en de meest negatieve waarde bij elke breedte. De 64-bits resultaten worden gecontroleerd tegen BigInt.asIntN en BigInt.asUintN van JavaScript zelf. — Go Tools-team · Sep 9, 2026

Gebouwd en geverifieerd door het engineeringteam van Go Tools.

Korte antwoorden

Wat is −5 in 8-bits twee-complement?

11111011 11111011, oftewel 0xFB.

Wat is het bereik van een byte met teken?

-128 … 127 −128 tot 127 in twee-complement; −127 tot 127 in teken-magnitude en één-complement.

Hoe zet ik een twee-complementpatroon terug om in een getal?

waarde − 2^n Is de bovenste bit 0, lees het dan als zonder teken; is die 1, trek dan 2^n af van de lezing zonder teken.

Betekent 0xFF nu −1 of 255?

−1 of 255 −1 als byte met teken, 255 als byte zonder teken. De bits alleen beslissen dat niet.

Wat is twee-complement?

Twee-complement beantwoordt een hardwarevraag, geen wiskundige: hoe sla je negatieve getallen zo op dat de opteller die je al gebouwd hebt blijft werken? De truc is om −x weer te geven met het patroon van 2^n − x. Optellen loopt dan modulo 2^n rond en komt op het juiste antwoord uit zonder enige uitzondering voor tekens, en daarom is er voor aftrekken geen aparte schakeling nodig.

Daar volgen twee dingen uit, en allebei duiken ze op in echte bugs. Ten eerste is het bereik asymmetrisch: acht bits dekken −128 tot 127, niet −128 tot 128, omdat de patronen verdeeld moeten worden en er geen negatieve nul is om het gelijk te trekken. Ten tweede is het teken geen vlaggetje dat je eraf kunt halen — de bovenste bit van 11111011 is 1, maar de waarde is −5 en niet −123, dus een negatief getal lezen betekent het hele woord interpreteren en niet naar één bit kijken.

Teken-magnitude en één-complement zijn de twee ontwerpen die het aflegden. Ze zijn nog steeds het kennen waard, omdat drijvende komma volgens IEEE 754 de teken-magnitude-indeling heeft behouden en omdat juist die vergelijking twee-complement onvermijdelijk laat lijken in plaats van willekeurig.

// -5 as an 8-bit byte, three ways to arrive at the same pattern
0b00000101        // 5
~0b00000101       // 11111010  ones' complement of 5
~0b00000101 + 1   // 11111011  two's complement = -5

// In JavaScript the width matters: bitwise operators are 32-bit,
// so anything wider has to go through BigInt.
BigInt.asIntN(8, 0xFBn)                 // -5n
BigInt.asUintN(8, -5n)                  // 251n
BigInt.asIntN(64, 0xFFFFFFFFFFFFFFFBn)  // -5n

// C23 made two's complement mandatory for signed integers.
// Before that, the other two encodings were legal but unused.

Wat deze calculator doet

Vier coderingen tegelijk

Teken-magnitude, één-complement, twee-complement en offset-binair worden samen berekend. Offset-binair is degene die de meeste calculators weglaten, en juist die blijven ADC-datasheets gebruiken.

Omgekeerd opzoeken vanuit een bitpatroon

Plak de bits of de hex die je werkelijk hebt en zie alle vijf de lezingen, die zonder teken inbegrepen. Dit is de richting die je nodig hebt als een dump niet klopt met het getal dat het apparaat rapporteert.

Kloppend tot 64 bit

Elke waarde wordt met BigInt afgehandeld, dus 0xFFFFFFFFFFFFFF9C komt uit op −100 en niet op wat een afkapping naar 32 bit ervan zou maken.

Eerlijk over wat geen representatie heeft

Bij breedte 8 heeft −128 geen teken-magnitude- en geen één-complementvorm. De tabel zegt dat ook, in plaats van een patroon af te drukken dat dat getal niet betekent.

Negatieve nul zichtbaar gemaakt

Voer 0 in en het tweede bitpatroon voor nul in teken-magnitude en één-complement wordt getoond, wat het helderste argument is voor waarom twee-complement heeft gewonnen.

Referentietabellen zonder JavaScript

De 8-bits vergelijkingstabel en de bereiken per breedte worden bij het bouwen van de pagina gerenderd, door dezelfde motor die de live velden aandrijft, zodat ze er niet van kunnen afwijken.

Hoe dit zich verhoudt tot andere manieren van controleren

De conversie van je eigen taal

Runtime-API

BigInt.asIntN, int.from_bytes(..., signed=True) in Python en de typen met vaste breedte in C geven het gezaghebbende antwoord voor de code die je schrijft. Gebruik die in de code; gebruik deze pagina als je een waarde voor je hebt en geen interpreter open staat.

De geheugenweergave van een debugger

IDE-functie

Toont de waarde met het type dat het programma heeft opgegeven, precies het stuk informatie dat een bitpatroon mist. Het helpt niet als de bytes over een verbinding binnenkwamen zonder opgegeven type — en dat is het geval waarvoor deze pagina bedoeld is.

Talstelsel omrekenen

Deze site

Rekent om tussen talstelsels, maar alleen voor niet-negatieve waarden — negatieve getallen worden daar expliciet geweigerd, omdat een talstelsel geen mening heeft over hoe een teken wordt opgeslagen. Weergave met teken is het werk van deze pagina; gebruik de talstelselconverter voor de groottes.

IEEE 754-converter

Deze site

De tegenhanger voor drijvende komma. Die houdt een teken-magnitude-indeling aan in plaats van twee-complement en geeft de exponent een bias van 2^(e−1)−1, dus de twee pagina's beantwoorden verschillende vragen over hetzelfde woord geheugen.

Uitgewerkte voorbeelden

−5 als 8-bits byte

-5, breedte 8
teken-magnitude    1000 0101
één-complement     1111 1010
twee-complement    1111 1011  (0xFB)
offset-binair      0111 1011

De drie coderingen zijn het eens over de tekenbit en oneens over al het overige. Alleen de regel met het twee-complement is wat een C-int8_t daadwerkelijk bevat.

De byte 0xFB, op vijf manieren gelezen

0xFB, breedte 8
zonder teken       251
teken-magnitude    -123
één-complement     -4
twee-complement    -5
offset-binair      123

−128 heeft geen teken-magnitudevorm

-128, breedte 8
teken-magnitude    geen representatie
één-complement     geen representatie
twee-complement    1000 0000  (0x80)
offset-binair      0000 0000

Teken-magnitude en één-complement offeren allebei een bitpatroon op aan negatieve nul, dus lopen ze van −127 tot 127 en halen ze −128 niet. Tools die hier een byte afdrukken, zitten fout.

Een 64-bits registerwaarde

0xFFFFFFFFFFFFFF9C, breedte 64
twee-complement    -100
zonder teken       18446744073709551516

Alles boven 32 bit moet met BigInt. De operatoren |, << en >>> van JavaScript kappen stilzwijgend af op 32 bit, en daarom geven sommige online calculators hier een verkeerd antwoord in plaats van een foutmelding.

Zo gebruik je de complement-calculator

  1. 1

    Kies de bitbreedte

    4, 8, 16, 32 of 64. Dit is geen weergavevoorkeur — dezelfde bits betekenen bij andere breedtes andere getallen, dus een verkeerde keuze verandert het antwoord.

  2. 2

    Voer een decimaal getal met teken in

    Typ een geheel getal, minteken inbegrepen. Alle vier de coderingen werken bij tijdens het typen, samen met de hexadecimale vorm van elk.

  3. 3

    Of werk terug vanuit de bits

    Plak een binaire reeks of een 0x-waarde in het omgekeerde veld om te zien wat dat exacte patroon onder elke interpretatie betekent, inclusief de lezing zonder teken.

  4. 4

    Lees de opmerkingen als ze verschijnen

    De pagina markeert de twee gevallen waar mensen over struikelen: de meest negatieve waarde die geen teken-magnitude- of één-complementvorm heeft, en nul die in die twee coderingen een tweede bitpatroon krijgt.

Fouten die verkeerde antwoorden opleveren

De +1 vergeten

De bits omkeren levert het één-complement op. Daar stoppen scheelt één met het twee-complement, en die fout is makkelijk te missen omdat het resultaat er nog steeds als een aannemelijk negatief getal uitziet.

✗ Fout 
5   = 00000101
~5  = 11111010   <- ones' complement, not -5
✓ Correct 
5        = 00000101
~5       = 11111010
~5 + 1   = 11111011   <- -5 in two's complement

32-bits bitoperatoren op een 64-bits waarde gebruiken

JavaScript kapt de operanden van bitoperatoren af op 32 bit. De bovenste helft verdwijnt zonder foutmelding, dus het resultaat is fout in plaats van afwezig.

✗ Fout 
0xFFFFFFFFFFFFFFFB        // 18446744073709552000  -- the literal is already rounded
~0xFFFFFFFFFFFFFFFB + 1   // 0  -- silently wrong, expected -5
✓ Correct 
BigInt.asIntN(64, 0xFFFFFFFFFFFFFFFBn)   // -5n

Een negatieve waarde met nullen verbreden

Verbreden door met nullen aan te vullen behoudt het getal alleen als het positief is. Bij een negatieve waarde moet de tekenbit over de nieuwe bits worden herhaald.

✗ Fout 
int8  0xFB  (-5)
int16 0x00FB  (251)   <- zero-extended
✓ Correct 
int8  0xFB  (-5)
int16 0xFFFB  (-5)    <- sign-extended

De meest negatieve waarde een teken-magnitudevorm geven

In acht bits heeft −128 geen teken-magnitude- en geen één-complementrepresentatie, omdat beide coderingen één patroon opofferen aan negatieve nul. Er 10000000 voor afdrukken verwart het antwoord van het twee-complement met een codering die dat getal niet kan uitdrukken.

✗ Fout 
-128 sign-magnitude: 10000000   <- that pattern means -0
✓ Correct 
-128 sign-magnitude: no representation at width 8
-128 two's complement: 10000000

Wanneer je dit echt nodig hebt

Een sensorregister uitlezen
Een temperatuurregister geeft 0xFF9C terug. Zonder teken is dat 65436, en dat is geen temperatuur. Bij breedte 16 toont de twee-complementregel −100, en met een schaalfactor van 0,1 °C vertelt de sensor je −10,0 °C.
Een protocol met ongetypeerde velden debuggen
Modbus, CAN en de meeste binaire telemetrie dragen ruwe woorden zonder informatie over het teken. Als een client en een apparaat het oneens zijn over een waarde, wijst het vergelijken van beide lezingen van hetzelfde woord meestal aan welke kant de verkeerde aanname deed.
Studiestof over computerarchitectuur
Teken-magnitude, één-complement, twee-complement en offset-binair zijn de standaardvier in een inleidend vak. Ze naast elkaar bij dezelfde breedte zien maakt de verschillen zichtbaar in plaats van iets om uit je hoofd te leren.
Een integer-overflow achterhalen
Als een teller van 2147483647 naar −2147483648 springt, laat het bekijken van beide als 32-bits patronen zien dat de carry in de tekenbit is beland. De waarde werd geen onzin; hij liep precies rond zoals de codering voorschrijft.
Serialisatiecode schrijven
Controleer één negatieve waarde per breedte op deze pagina voordat je een zelfgeschreven encoder vertrouwt. Een tekenfout is zo gemaakt en levert uitvoer op die er structureel prima uitziet, tot het eerste echte negatieve getal binnenkomt.

Hoe de vier coderingen zijn opgebouwd

Teken-magnitude
De bovenste bit is het teken en de overige n−1 bits vormen de grootte, gelezen als een gewoon getal zonder teken. Het bereik loopt van −(2^(n−1)−1) tot 2^(n−1)−1, is symmetrisch en heeft twee nullen. Het is de indeling die IEEE 754 voor drijvende komma gebruikt.
Één-complement
Een negatieve waarde is de bitsgewijze inverse van zijn grootte, oftewel 2^n − 1 − x. Zelfde bereik en dezelfde twee nullen als teken-magnitude. Optellen vereist een rondgaande carry, precies de complicatie die twee-complement wegneemt. In het Engels is de plaats van de apostrof geen typefout: ones' complement verwijst naar een woord van allemaal enen, terwijl two's complement naar één macht van twee verwijst.
Twee-complement
Een negatieve waarde −x wordt opgeslagen als 2^n − x. Het bereik loopt van −2^(n−1) tot 2^(n−1)−1, is bewust asymmetrisch en heeft één nul. Optellen, aftrekken en het vermenigvuldigen van het lage woord zijn alle drie tekenonafhankelijk, en dat is de hele reden dat het gewonnen heeft.
Offset-binair
Slaat value + 2^(n−1) op, zodat −2^(n−1) alleen nullen wordt en de patronen in dezelfde volgorde sorteren als de waarden die ze coderen. Het is gelijk aan het twee-complementpatroon met de bovenste bit omgeklapt. Pas op met de naamgeving: de exponentvelden van IEEE 754 hebben een bias van 2^(e−1)−1, één minder dan de offset die hier wordt gebruikt.
Waarom het rekenwerk BigInt gebruikt
JavaScript zet de operanden van &, |, ~ en de schuifoperatoren eerst om naar 32-bits gehele getallen en daarna terug, zodat een 64-bits waarde zijn bovenste helft verliest zonder dat er een fout wordt opgeworpen. Elke conversie op deze pagina gebeurt in plaats daarvan op gehele getallen met willekeurige precisie, en ook daarom komen de 64-bits uitersten hier exact uit.

Waarden met teken goed afhandelen

Leg eerst de breedte vast
Een bitpatroon heeft geen waarde totdat je zegt hoe breed het veld is. De meeste meningsverschillen tussen een datasheet en een debugger komen erop neer dat de ene kant 16 bit aanneemt en de andere 32.
Behandel de meest negatieve waarde als uitzondering
Hem negatief maken loopt bij elke breedte over — in twee-complement is −(−128) nog steeds −128 voor een byte met teken. Elke code die een absolute waarde berekent heeft een plan nodig voor deze invoer, en elke testsuite hoort hem te bevatten.
Leid nooit uit de data af of er een teken is
Geen enkele inspectie van de bits kan je vertellen of een veld een teken heeft. Haal het uit de datasheet, het schema of de structdefinitie; gokken werkt tot de eerste negatieve waarde in productie langskomt.
Doe tekenextensie bij het verbreden
Een 8-bits 0xFB als 0x00FB naar een 16-bits veld kopiëren maakt van −5 het getal 251. Een waarde met teken verbreden betekent de tekenbit herhalen, wat 0xFFFB oplevert.
Gebruik liever de conversie van de taal zelf
BigInt.asIntN in JavaScript, int.from_bytes(..., signed=True) in Python en typen met vaste breedte in C zeggen wat ze bedoelen en vangen de randgevallen af. Een zelfgeschreven ~x + 1 is waar de breedtefouten vandaan komen.

Veelgestelde vragen

Wat is twee-complement, in één zin?
Het is de afspraak waarbij een negatief getal −x wordt opgeslagen als het bitpatroon van 2^n − x, waardoor optellen en aftrekken dezelfde schakeling gebruiken en de getallenlijn precies één nul heeft.
Hoe bereken ik een twee-complement met de hand?
Schrijf de grootte binair op, keer elke bit om en tel er 1 bij op. Voor 5 in acht bits: 00000101 → 11111010 → 11111011. Alleen omkeren levert het één-complement op, en daarom schelen de twee altijd precies 1.
Waarom past −128 wel in een byte met teken en +128 niet?
Twee-complement is bewust scheef. Met n bits dekt het −2^(n−1) tot 2^(n−1)−1, omdat het geen patroon verspilt aan negatieve nul zoals teken-magnitude en één-complement dat wel doen. Dat extra plekje valt aan de negatieve kant.
Is 11111011 gelijk aan −5 of aan 251?
Allebei, en de bits kunnen je niet vertellen welke van de twee. Het antwoord hangt af van het type dat het producerende systeem heeft opgegeven. Daarom toont de omgekeerde lezing op deze pagina elke interpretatie tegelijk in plaats van er één voor je te kiezen — pak de regel die bij jouw int8_t of uint8_t hoort.
Wat is offset-binair en waar kom ik het tegen?
Offset-binair (ook excess-K of biased genoemd) slaat value + 2^(n−1) op, zodat de kleinste waarde alleen nullen is en het sorteren van de ruwe patronen als getallen zonder teken ook de waarden mét teken op volgorde zet. Je ziet het in de uitvoer van ADC's en DAC's en in audiosampleformaten. Let op: de exponenten van IEEE 754 gebruiken een andere bias — 2^(e−1)−1 in plaats van 2^(e−1) — dus neem dat getal niet over.
Waarom leest een Modbus-register 65436 terwijl de sensor −100 zegt?
Modbus vervoert 16-bits woorden zonder enige typeinformatie, dus een client die uitgaat van waarden zonder teken toont 65436, terwijl het apparaat de twee-complementwaarde −100 bedoelde. Plak 65436 hier als hex 0xFF9C bij breedte 16 en de regel met het twee-complement laat de bedoelde lezing zien.
Worden teken-magnitude en één-complement nog gebruikt?
Voor gehele getallen zelden — vrijwel elke huidige processor gebruikt twee-complement, en C23 heeft dat eindelijk verplicht gesteld. Ze blijven relevant omdat drijvende komma volgens IEEE 754 een teken-magnitude-indeling aanhoudt, en omdat ze nog steeds in tentamenvragen over computerarchitectuur opduiken.
Waarom geven sommige calculators een fout antwoord bij 64-bits waarden?
De bitoperatoren van JavaScript zetten hun operanden eerst om naar 32-bits gehele getallen, dus een pagina die ~x + 1 gebruikt verliest stilzwijgend de bovenste helft van een 64-bits waarde en meldt een aannemelijk maar fout resultaat. Deze tool gebruikt overal BigInt, en daarom komen de 64-bits regels hier overeen met wat je debugger toont.
Wat is negatieve nul en waarom is dat belangrijk?
In teken-magnitude betekenen 00000000 en 10000000 allebei nul; in één-complement zijn dat 00000000 en 11111111. Twee vergelijkingen die gelijk zouden moeten uitvallen, kunnen daardoor bit voor bit ongelijk zijn. Twee-complement heeft één nul, en dat heeft een hele klasse van uitzonderingen in de hardware weggenomen.
Wordt iets wat ik typ naar een server gestuurd?
Nee. De pagina levert de conversiemotor aan je browser en voert die daar uit. Registerdumps en firmwarewaarden komen vaak uit systemen die je niet zomaar mag delen, dus je hoeft hier niets op je woord te geloven — open het netwerktabblad en je ziet dat er geen enkel verzoek uitgaat.

Gerelateerde tools

Alle tools bekijken →

Talstelsel omrekenen — online converter

Omrekentools

Reken je getal direct om tussen binair, hex, decimaal, octaal en elk talstelsel (2-36). Gratis en privé — alles draait in je browser.

chmod-calculator — Linux-bestandsrechten

Omrekentools

Reken Linux-bestandsrechten om tussen octaal (755, 644) en rwx-symbolen. Genereer kant-en-klare chmod-commando's en herken riskante instellingen zoals 777 — gratis, alles draait in je browser.

Color converter — HEX, RGB, HSL & OKLCH

Omrekentools

Converteer HEX naar RGB, HSL, OKLCH, OKLAB en CMYK in je browser — kopieer elk formaat met één klik. Gratis, geen account, je kleuren verlaten de pagina nooit.

Hex naar CMYK converter

Omrekentools

Converteer HEX-kleuren naar CMYK in je browser. Naïeve sRGB-gebaseerde benadering voor printvoorbeelden. Gratis, geen account, je kleuren blijven lokaal.

Hex naar HSL converter

Omrekentools

Converteer elke hex-kleur naar HSL in je browser — 3-cijferig, 6-cijferig en 8-cijferig hex met alpha worden allemaal ondersteund. Gratis, direct, geen account, je kleuren verlaten de pagina nooit.

Hex naar OKLCH converter

Omrekentools

Converteer HEX naar OKLCH voor Tailwind v4 design-tokens. Live perceptueel-uniforme uitvoer met Display P3 gamut-waarschuwingen. Gratis, alleen in je browser.