TB naar B omrekenen

Een terabyte is duizend miljard bytes, oftewel 10¹². Een schijf die als 1 TB verkocht wordt heeft precies dat: de ruimte die lijkt te ontbreken is onenigheid over eenheden en geen tekort.

Een byte is acht bits, en dat stond niet altijd vast: de eerste computers gebruikten er zes, zeven of negen. Acht won omdat er een teken in past en omdat het getal netjes in helften uiteenvalt.

Van terabytes naar bytes schuift de komma 12 plaatsen naar rechts, en verder verandert er niets. Geen factor om te onthouden en niets om af te ronden: de cijfers blijven in dezelfde volgorde staan, alleen hun plek verandert.

1.234 TB is 1234000000000000 B — dezelfde cijfers, een stuk opgeschoven. Dat is het waard om te weten, want dit is de enige omrekening die je in één oogopslag controleert: staan er in de uitkomst andere cijfers dan waarmee je begon, dan heeft niet deze omrekening ze veranderd.

Eén terabyte is een biljoen bytes, dus is de omzetting twaalf nullen aan het aantal TB plakken. 2,5 TB wordt zo 2.500.000.000.000 bytes — een getal met dertien cijfers dat in de praktijk vrijwel nooit met de hand geschreven wordt, maar wel voorkomt in configuratiebestanden, API-antwoorden en databasequery's die op de exacte byte moeten kunnen rekenen.

Deze richting is de omgekeerde van wat de meeste mensen zoeken; het komt meestal voor wanneer een systeem een capaciteit of limiet moet instellen op basis van een getal dat elders in terabytes gecommuniceerd is, zoals een opslagquotum dat als "5 TB" in een contract staat maar als exact bytegetal in een databaseveld terecht moet komen.

Is de bron van je terabytegetal decimaal (de fabrikantslezing) of binair (wat een besturingssysteem vaak "TB" noemt terwijl het TiB bedoelt)? Bij 2,5 TB decimaal krijg je 2.500.000.000.000 bytes; bedoelde de bron 2,5 TiB, dan is het echte bytegetal 2.748.779.069.440 — bijna 10 procent meer.

Dat verschil is op deze schaal groot genoeg om een harde limiet echt te laten falen of juist onnodig ruim te maken. Bij het configureren van een systeem dat het exacte bytegetal verwacht, is het de moeite waard om eerst te checken welk systeem de bron van je terabytegetal daadwerkelijk gebruikte.

Bij het handmatig uitschrijven van een bytegetal op deze schaal, groepeer de cijfers in drieën van rechts en tel de groepen: eenheden, duizenden, miljoenen, miljarden, biljoenen. Vier volle groepen na de leidende cijfers wijst op terabyteschaal.

8.000.000.000.000 heeft vier groepen na de leidende 8, wat bevestigt dat het om 8 TB gaat. Eén nul te veel of te weinig verandert het antwoord met een factor tien, en het resultaat blijft er nog steeds aannemelijk uitzien — vandaar dat deze controle het overslaan niet waard is.

Databasevelden die een bestandsgrootte of quotum bijhouden, gebruiken vaak een 64-bit geheel getal in bytes, zonder eenheid erbij — de applicatie die het getal leest, moet zelf weten dat het om bytes gaat en het correct omzetten voor weergave. Vandaar dat een ontwikkelaar die zo'n veld handmatig invult, eerst het terabytegetal naar bytes moet omrekenen.

Ook API's die een uploadlimiet of een quotum communiceren, specificeren dat vaak in bytes in de technische documentatie, zelfs wanneer de gebruikersinterface het in terabytes toont — de twee getallen moeten wel overeenkomen, dus is de omzetting waar de een naar de ander leidt geen vrijblijvende keuze.

Deel het bytegetal terug door een biljoen en vergelijk het resultaat met het oorspronkelijke terabytegetal. 2.500.000.000.000 gedeeld door een biljoen geeft precies 2,5, wat bevestigt dat er geen nul is weggevallen of toegevoegd onderweg.

Deze controle is vooral nuttig wanneer het bytegetal handmatig getypt is in plaats van berekend, want een verkeerd geteld aantal nullen bij het typen is de meest voorkomende fout op deze schaal en de moeilijkste om zonder controle te ontdekken.

Voor vrijwel elk gesprek met een mens — een offerte, een capaciteitsplan, een gebruikersinterface — is het bytegetal de verkeerde eenheid om te tonen; niemand leest "2.500.000.000.000 bytes" liever dan "2,5 TB". Zet alleen om naar bytes op het moment dat een systeem daadwerkelijk het exacte getal nodig heeft.

Bewaar in dat geval het oorspronkelijke terabytegetal ergens naast het bytegetal, zodat een latere lezer niet hoeft te reconstrueren welke afronding en welk systeem (decimaal of binair) tot het bytegetal geleid hebben.