GB-bájt átváltás: pontosan 1 GB = 1 000 000 000 B
Ez az oldal abban tér el a legtöbb hasonló konverziós eszköztől, hogy kizárólag a decimális SI-tényezőt alkalmazza: 1 GB = 1 000 000 000 bájt. Nem használja a bináris 2³⁰ faktort (1 GiB = 1 073 741 824 bájt). A két konvenciót folyamatosan összekeverik: a merevlemez- és SSD-gyártók decimális GB-ban adják meg a kapacitást, miközben számos operációs rendszer bináris GiB-ban számol, de „GB”-ként címkézi az értéket. Ez az oldal a pontos decimális eredményt adja, és tartalmazza az inverz faktort is: 1 B = 1,00000000000·10⁻⁹ GB.
A decimális és bináris prefixumok eredete – miért létezik két szabvány?
A történet az 1960-as évekig nyúlik vissza, amikor a számítógépek memóriája és tárolókapacitása olyan értékekben nőtt, hogy a bájt helyett nagyobb egységekre volt szükség. A Nemzetközi Mértékegységrendszer (SI) a fizikai mennyiségekre – például kilogramm, méter, watt – egységes decimális prefixumokat definiált: kilo‑ = 10³, mega‑ = 10⁶, giga‑ = 10⁹. Mivel a számítástechnika bináris architektúrára épül, a mérnökök elkezdték ezeket a prefixumokat 2¹⁰ = 1024, 2²⁰ = 1 048 576, 2³⁰ = 1 073 741 824 értelemben használni. Hardveres környezetben (például DRAM-ok méretezésekor) 1 kilobájt tényleg 1024 bájtot jelentett, mert a memóriacímzés hatványai így illeszkedtek a tervezéshez.
A merevlemez-gyártók azonban az 1970-es évektől a decimális értelmezést választották. Amikor egy 10 MB-os lemezt dobott piacra valaki, az 10 000 000 bájtot jelentett, nem 10 485 760 bájtot. A marketing osztályon ez egyszerűbb volt – a decimális szám nagyobbnak tűnt. Az eltérés évtizedekig nem zavart senkit, mert a kapacitás-különbség kicsi volt (2,4% 1 GB-nál). Ahogy a tárolók mérete terabájtokba nőtt, a százalékos eltérés nőtt (1 TB-nál már 9,95%), és a felhasználók elkezdték észrevenni: az újonnan vásárolt 1 TB-os külső meghajtó a Windowsban csak ~931 GB-ot mutat.
Az IEC (Nemzetközi Elektrotechnikai Bizottság) 1998-ban próbálta rendezni a káoszt: bevezette a kibi‑, mebi‑, gibi‑ stb. prefixumokat (KiB, MiB, GiB). A GiB pontosan 2³⁰ bájt. Azóta a szabvány létezik, de az operációs rendszerek és alkalmazások lassan vették át: a macOS 10.6 óta (2009) decimális GB-ban mutatja a kapacitást, a Linux parancssori eszközei többsége az -h (human-readable) kapcsolóval GiB-ban számol, a Windows pedig a File Explorerben bináisan értelmezett „GB”-ot jelenít meg a mai napig.
A matematika: hogyan működik a 10⁹-es faktor
A GB-bájt átváltás szigorúan a 10-es hatványokon alapul:
1 GB = 1 × 10⁹ B = 1 000 000 000 B
Ha x GB-ot kell bájtba váltani, a számítás: x × 1 000 000 000 = eredmény bájtban.
Visszafelé: y bájtot GB-ba váltani: y / 1 000 000 000 = eredmény GB-ban, ami megegyezik az y × 1,00000000000·10⁻⁹ képlettel.
Mintaértékek:
| GB (decimális) | B (decimális) |
|---|---|
| 0 | 0 |
| 0,5 | 500 000 000 |
| 1 | 1 000 000 000 |
| 2,5 | 2 500 000 000 |
| 10 | 10 000 000 000 |
| 100 | 100 000 000 000 |
| 1000 (1 TB) | 1 000 000 000 000 |
A bemenet csak nem‑negatív szám lehet. A nulla megengedett, ekkor 0 bájt az eredmény. Nagyon nagy bemenetek esetén az oldal tudományos jelölést használ, de a szorzatot pontosan megtartja – nincs kerekítés.
Miért nem stimmel a „250 GB-os” SSD a számítógépen?
A leggyakoribb hiba, amit a felhasználók elkövetnek: vesznek egy 250 GB-os SSD-t, és a Windows azt mutatja, hogy ~232 GB. A gyártó 250 000 000 000 bájtot tett a lapkákra. Az operációs rendszer ezt elosztja 1 073 741 824‑gyel, és ~232,83 GiB-ot kap. Címkézni viszont „250 GB”-ként szokta. A különbség nem rejtett partíció vagy szoftverhiba, hanem pusztán mértékegység‑konvenció.
Ugyanez a helyzet a felhőtárhely‑szolgáltatóknál: a Google Drive, Dropbox, OneDrive a kvótákat decimális GB-ban mérik. Ha egy tárhelykvóta 15 GB, az 15 000 000 000 bájt fájlok és mappák számára. Ha a rendszergazda egy 1 TB-os limitet állít be a felhasználónak, az 1 000 000 000 000 bájt, nem 1 099 511 627 776. Aki bináris GiB-ban számol és decimális GB-os kvótát ad meg, az alulkalkulálhatja a tényleges kapacitást.
Gyakorlati alkalmazások: kinek és miért kell pontos decimális bájtátváltás?
IT‑szakemberek: Egy rendszergazda, aki több tucat merevlemezt vásárol adatközpontba, a gyártói specifikációkat decimális GB-ban kapja. Ha a RAID‑kártya vagy a SAN‑rendszer is decimális alapon számol, a kalkuláció pontos. Ahol a rétegelt tárolórendszerek (például NetApp, Dell EMC) a kapacitást SI‑egységekben adják meg, ott a GiB‑ra váltás csak félreértéshez vezet.
Felhőarchitektúrák: Az AWS és az Azure is decimális GB‑ban számlázza a tárhelyet és az adatátvitelt. Egy EBS‑kötet létrehozásakor 100 GB‑ot adsz meg – a szolgáltató 100 000 000 000 bájtot allokál. A figyelőrendszerek (CloudWatch, Azure Monitor) is decimálisan jelentik a használatot. Aki binárisan számol és a felhő‑dashboardot ellenőrzi, szisztematikus eltérést fog látni.
Fejlesztők: Fájlméret‑kezelő függvényekben, adatbázis‑mezőméretezésnél vagy hálózati protokoll‑fejléceknél el kell dönteni, hogy melyik konvenciót használják. A HTTP Content‑Length fejléc bájtban adja meg a méretet, de ha egy alkalmazás GB‑ban kérdezi le a fájlméretet, és decimális osztást használ, akkor a GiB‑ra váltó függvény hibás értéket ad vissza. Az SI‑konvenció itt is egyértelmű: 1 GB a fenti fejléchez képest 1 000 000 000 bájt.
Felhasználók, akik külső meghajtót vásárolnak: A gyártói dobozon 2 TB szerepel. A számítógép 1,81 TB‑ot mutat. A vásárló reklamációval fordul a boltba, pedig nincs jogos panasz – a gyártó a decimális 2 000 000 000 000 bájtot szállította, az operációs rendszer bináris 2 TiB-ot (2 199 023 255 552 bájt) várna. Az eltérés 9,95%. Az oldal segít megérteni, hogy a decimális GB‑ból hány bájt lesz.
A kapcsolódó digitális mértékegységek rendszere
A bájt a legalapvetőbb egység. A decimális SI‑rendszerben:
- 1 kilobyte (kB) = 10³ B = 1 000 B
- 1 megabyte (MB) = 10⁶ B = 1 000 000 B
- 1 gigabyte (GB) = 10⁹ B = 1 000 000 000 B
- 1 terabyte (TB) = 10¹² B = 1 000 000 000 000 B
- 1 petabyte (PB) = 10¹⁵ B = 1 000 000 000 000 000 B
A bináris IEC‑rendszerben:
- 1 kibibyte (KiB) = 2¹⁰ B = 1 024 B
- 1 mebibyte (MiB) = 2²⁰ B = 1 048 576 B
- 1 gibibyte (GiB) = 2³⁰ B = 1 073 741 824 B
- 1 tebibyte (TiB) = 2⁴⁰ B = 1 099 511 627 776 B
A különbség 1 GB és 1 GiB között 73 741 824 bájt, ami a 250 GB-os SSD példában ~2,7 GB-os eltérést okoz a Windows által jelzett kapacitásban.
Nagy számok kezelése és a tudományos jelölés
Amikor a bemenet nagyon nagy (például 10 000 GB), a kimenet 10 000 000 000 000 bájt, amit az oldal 1·10¹³ B formában is megjeleníthet. A pontosság nem sérül: a 10⁹‑es szorzó egész szám, a végeredmény egész bájt, kivéve, ha a bemenet tizedestörtet tartalmaz (például 0,5 GB → 500 000 000 B). A nagyon kis bemenetek (például 0,000001 GB) esetén a fordított konverzió is működik: 0,000001 GB = 1 000 B.
Az inverz faktor pontossága: 1 B = 1,00000000000·10⁻⁹ GB. Ez 11 tizedesjegyig pontos, ami gyakorlatilag bármilyen valós számítási igényt lefed. A legtöbb alkalmazás számára elegendő a 10⁻⁹-es szorzó, de a honlap a plusz nullákat is megjeleníti az egyértelműség kedvéért.
Gyakran Ismételt Kérdések
1. Miért van eltérés a gyári kapacitás (GB) és az operációs rendszer által mutatott kapacitás között? A gyártók decimális GB-ban (1 GB = 1 000 000 000 bájt) számolnak, a Windows és sok Linux-eszköz bináris GiB‑ban (1 GiB = 1 073 741 824 bájt), de azt „GB”-ként jelöli ki. A különbség kb. 2,4% 1 GB-nál, 9,95% 1 TB-nál.
2. Ez az oldal GiB-ra vált? Nem. Csak decimális GB-ba (SI) vált bájtba. A GiB-ra váltáshoz 1 073 741 824‑gyel kellene szorozni, ezt az oldal nem használja.
3. Beírhatok negatív számot? Nem. A bemenet csak nem‑negatív szám lehet. Negatív érték esetén az oldal nem ad értelmes eredményt. Nulla engedélyezett.
4. Mit tegyek, ha a fájlrendszerem bináris alapon számol, de decimális GB-ban akarok dolgozni? Használd ezt az oldalt a konverzióhoz. Például egy 500 GiB-os fájlrendszer 500 × 1 073 741 824 = 536 870 912 000 bájt = 536,87 GB decimálisan.
5. Hogyan számoljak vissza bájtból decimális GB-ba? Oszd el a bájtok számát 1 000 000 000‑dal. Az oldal ezt is támogatja a fordított irányú bevitellel.
6. Hol használnak még decimális GB-ot a tárológyártókon kívül? A felhőszolgáltatók (AWS, Azure, GCP) a tárhely- és adatátviteli kvótákat, az adatközponti hálózati berendezések és a hálózati protokollok (HTTP, FTP) méretjelölései is decimális bájtban vagy decimális prefixumokban vannak megadva. A legtöbb adatbázis‑kezelő rendszer (pl. PostgreSQL) a tábla méretét bájtban tárolja, de a felhasználói felületen gyakran GB-ban jeleníti meg decimálisan.