GB naar B omrekenen

GB
1000000000B

1 GB = 1000000000 B

Tik een waarde in en de omrekening van gigabyte naar byte loopt mee terwijl je typt. De factor is precies 1000000000: zoveel B komt er op 1 GB. De berekening gebeurt op je eigen apparaat; na het laden vraagt deze pagina geen server meer iets.

  • Waar het draait In je browser. Het getal dat je intikt komt nooit in een verzoek terecht.
  • Exact per definitie 1 GB is precies 1000000000 B — een definitie, geen afgeronde factor.
  • Antwoordt terwijl je typt Geen knop, geen wachten. Het antwoord staat al op de pagina voordat er een script draait.

gigabyte naar byte in de praktijk

  • 64 GB is 64000000000 B

    — een eenvoudige telefoon.

  • 1000 GB is 1000000000000 B

    — een schijf die als een terabyte verkocht wordt.

  • 0,005 GB is 5000000 B

    — een foto die met de telefoon is gemaakt.

  • 0,000001024 GB is 1024 B

    — een kibibyte, en daar begint de verwarring.

gigabyte en byte in één oogopslag

Elk getal in deze tabel is berekend uit dezelfde definitie als de rekenmachine gebruikt, dus de tabel kan niet afwijken van het antwoord hierboven.
GBB
11000000000
22000000000
55000000000
1010000000000
5050000000000
100100000000000
500500000000000
10001000000000000

gigabyte en byte

Een gigabyte is een miljard bytes, in de decimale betekenis die schijffabrikanten, databundels en videogroottes hanteren.

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.

Hier schuift alleen de komma

Van gigabytes naar bytes schuift de komma 9 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 GB is 1234000000000 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.

Het ruwe getal dat een configuratieveld vraagt

Genoeg instellingen nemen een getal aan zonder eenheid, en de documentatie zegt bytes. Een objectopslag-partgrootte, een verzoeklichaamlimiet, een buffergrootte in een databaseconfiguratie: allemaal willen ze een geheel getal, en dat getal voor één gigabyte is 1.000.000.000.

De reden om naar de binaire eenheid te grijpen in plaats van naar een rond decimaal getal is dat het omringende systeem vrijwel zeker al binair is. Geheugenpagina’s, blokgroottes en bufferoewijzingen zijn machten van twee.

Een G-achtervoegsel dat decimaal lijkt en dat niet is

De conventie in operationele tooling is dat een kale k, m of g 1.024, 1.048.576 of 1.073.741.824 betekent. De JVM-heapvlaggen werken zo, dus -Xmx4g reserveert 4.294.967.296 bytes. Docker-geheugen- en opslaglimieten werken zo.

De GNU coreutils gaan een stap verder en accepteren beide spellingen: een enkele letter is binair en een tweeletterige vorm eindigend op B is decimaal. dd bs=1G kopieert in blokken van 1.073.741.824 bytes en dd bs=1GB in blokken van 1.000.000.000.

De 4 GiB-grens en waar ze nog opduikt

Twee tot de macht tweeëndertig is 4.294.967.296, en dat getal is een muur in plaats van een conventie. Het is de grootste waarde die een 32-bit geheel getal zonder teken kan bevatten, dus alles dat een lengte in 32 bits opslaat stopt daar.

De grens duikt nog op waar het modern lijkt. Oudere archiefformaten, bepaalde uploadpaden en een lange staart aan drivers dragen 32-bit lengtes, en elk daarvan faalt ergens tussen 4,29 GB en 4,30 GB in plaats van bij een rond decimaal getal.

Quota’s en levenscyclusregels willen het gehele getal

Interfaces die op grootte schaal werken nemen bytes aan, omdat bytes ondubbelzinnig zijn en de actie geautomatiseerd is. Objectopslag-levenscyclusregels filteren op een objectgrootte in bytes; cgroup-geheugenlimieten zijn bytewaarden.

Deze waarden worden ook vaak eenmaal geschreven en jarenlang geraadpleegd. Een levenscyclusregel die objecten boven 128 GB naar koudere opslag verplaatst blijft dat doen lang nadat iedereen die de drempel koos verder is gegaan.

Geheugen en schijf bedoelen verschillende gigabytes in hetzelfde bestand

Een deploymentmanifest specificeert routinematig geheugen en opslag naast elkaar, en de twee sectoren erachter gebruiken het voorvoegsel verschillend. Geheugen wordt geadresseerd in machten van twee, dus een module verkocht als 16 GB bevat 17.179.869.184 bytes.

Welke een platform bedoelt voor een bepaald veld is een documentatievraag en geen giswerk. Containerruntimes bedoelen doorgaans binaire eenheden voor geheugen; blokopslag en objectopslag zijn doorgaans decimaal.

Een limiet 7,4 procent te laag instellen is een belastingsafhankelijke bug

Een geheugenlimiet die 7,4 procent kleiner is dan bedoeld faalt niet bij het uitrollen. Ze faalt zodra het proces de bovenkant van zijn normale werkbereik bereikt, wat onder belasting gebeurt — en ze faalt als een beëindiging in plaats van een foutmelding.

De verdediging is het bedoelde vergelijken met het draaiende systeem in plaats van met het bestand. Lees de limiet terug van het platform, in bytes, en vergelijk die met het bedoelde getal.

Het getal controleerbaar maken voor de volgende persoon

Tien cijfers in een configuratiebestand zijn op het eerste gezicht niet te verifiëren, en tien verkeerde cijfers zien er precies zo uit als tien juiste. Waar het formaat een echte taal is of rekenkunde ondersteunt, schrijf dan 4 1024 * 3.

Het is ook de moeite waard vast te leggen waarom het getal is wat het is. Een geheugenlimiet gekozen uit een profiel onder piekbelasting en een limiet gekozen omdat het de volgende tier was worden om totaal verschillende redenen herzien.

GB naar B omrekenen: veelgestelde vragen

Hoeveel is 1 GB in B?

1 GB is 1000000000 B. De waarde is exact en niet afgerond: de verhouding tussen gigabyte en byte ligt per definitie vast.

Wordt wat ik intik ergens heen gestuurd?

Nee. De berekening gebeurt in je browser. Je kunt de verbinding verbreken en gewoon doorrekenen, en dat is meteen de eenvoudigste manier om het na te gaan.

Waarom toont mijn schijf minder ruimte dan erop staat?

Omdat twee verschillende eenheden dezelfde naam dragen. Fabrikanten rekenen 1 GB = 1.000.000.000 bytes; Windows toont gibibytes, dus 1.073.741.824 bytes, maar noemt ze «GB». Dezelfde schijf lijkt daardoor zeven procent kleiner. Er is niets verdwenen.

Andersom: byte naar gigabyte

Eén B is 1e-9 GB. Het is dezelfde verhouding achterstevoren gelezen, dus een uitkomst van de ene pagina die je door de andere haalt, moet weer uitkomen waar hij begon.

Waar deze cijfers vandaan komen

Wat deze pagina over informatie-eenheden beweert, is na te gaan, en dit zijn de documenten die de zaak beslechten.

Hoe deze pagina werkt

De factor is een constante op de pagina en de som is vier bewerkingen, dus er gaat niets ergens heen en er hoeft ook niets heen. Het getal dat je intikt verlaat de browser niet — er is geen verzoek waarin het zou kunnen meereizen.