データ容量の単位換算｜KBとKiB・GBとGiBの違い（1000と1024）

上の換算欄に数と単位を入れると、1000進（KB・MB・GB・TB・PB）と1024進（KiB・MiB・GiB・TiB・PiB）の値、バイト数とビット数が一覧で出ます。GB・TB・MB を選んだときは、Windows で何と表示されるかと、何％少なく見えるかも出ます。使い方の詳細は「換算ツールの使い方」の節にまとめました。

flowchart TD
    A[製品の表示 500GB] --> B[500,000,000,000 バイト]
    B --> C[1000で3回割る]
    B --> D[1024で3回割る]
    C --> E[500 GB<br>macOS・製品の箱]
    D --> F[465.66 GiB<br>Windows は GB と表示]

よく調べられることの答えを先にまとめます。

この記事で実際に動かしたもの：500,000,000,000バイト（製品表示の500GB）の中身の無いファイルを作り、Linux の ls・du・numfmt・df・free・dd、Python・Node.js・Java・Go・PHP、PostgreSQL の pg_size_pretty で表示させました。1,000,000,000バイトのディスクイメージを ext4 でフォーマットし、使える容量も測っています。

確認環境：Ubuntu 24.04.5 LTS（Linux 6.18）の上で、GNU coreutils 9.4 の ls・du・df・numfmt・dd、procps-ng 4.0.4 の free、e2fsprogs 1.47.0 の mkfs.ext4・dumpe2fs を使いました。プログラムは Python 3.13.18、Node.js 22.23.4、OpenJDK 21.0.12.1、Go 1.24.7、PHP 8.3.6 で実行し、PostgreSQL 16.15 は作業用のフォルダーに作ったデータベースを UNIX ソケットだけで起動して確かめています。ディスクイメージはマウントせず、フォーマットの結果を dumpe2fs で読んでいます。換算ツールの表示は Chromium（Chrome for Testing 153・Playwright 1.63）で 127.0.0.1 の確認用ページを開いて確かめ、入力中に外部への通信が起きないことも確かめました。Windows と macOS の表示の決まりは Microsoft Learn と Apple の公式サポート、2進接頭辞の定義は NIST、coreutils のオプションは GNU の公式マニュアル、PostgreSQL・Kubernetes の単位は各公式ドキュメントで確かめています。図は mermaid 11.16.0 で描画を確かめました（確認日 2026年11月7日）。

KBとKiB・MBとMiB・GBとGiBの違い（1000と1024）

この節では、KB と KiB がなぜ別の単位なのか、どちらが「正しい」のかが分かります。

KB（キロバイト）は1000バイト、KiB（キビバイト）は1024バイトです。「キロ」は1キロメートル＝1000メートルと同じ SI 接頭辞で、1000倍を表します。コンピューターは2進数で動くため、2の10乗＝1024が1000に近いことから、以前は1024バイトのことも「1KB」と呼んでいました。この2つを区別するために、国際電気標準会議（IEC）が1998年12月に2進接頭辞（キビ・メビ・ギビ…）を承認し、1999年1月に IEC 60027-2 の追補として公表しました（NIST の説明）。

NIST は、2進接頭辞は SI（国際単位系）の一部ではないこと、SI の「kilo」は1000を意味することを明記しています。つまり、規格どおりに書くなら「1KB＝1000バイト」で、1024バイトを表したいときは「1KiB」と書きます。ただし Windows のように、1024進で計算した値に KB・MB・GB と付けて表示するソフトも今も多く、同じ「GB」でも1000進か1024進かは、表示している側の決まりを確かめないと分かりません。

データ容量の単位換算ツールの使い方

この節では、記事の冒頭に置いた換算ツールで何ができるか、どの順に使うと早いかが分かります。

Chromium で見本ボタンを押したときの表示は次のとおりです（1024進の列の値と説明文を抜き出しています）。

• TB を選ぶと、説明文には Windows で見慣れた「GB」の形（1TB なら約 931.3 GB）と、TB の形（0.909495 TB）の両方が出ます。どちらも同じ表の「931.3 GiB」「0.909495 TiB」の行と同じ値です。
• 0より小さい数を入れると「0以上の数を入れます。」と出て、表は出ません。
• 入力した値はブラウザの中で計算され、外部には送信されません（入力中の通信が0件だったことを確かめました）。

単位の一覧と換算表（B・KB〜PB と KiB〜PiB）

この節では、各単位のバイト数・読み方と、1GBは何MBかといった換算の答えが一覧で分かります。

単位どうしの換算は、1000進どうし・1024進どうしで閉じています。

• 1GB＝1000MB、1MB＝1000KB、1TB＝1000GB（1000進）
• 1GiB＝1024MiB、1MiB＝1024KiB、1TiB＝1024GiB（1024進）
• 1バイト＝8ビット。1KB＝8,000ビット、1KiB＝8,192ビット
• 小文字の「kB」は1000バイトを表す書き方です。GNU coreutils のマニュアルは、kB を1000、k・K・KiB を1024と説明しています。

製品の容量でよく見る値を、1024進（Windows の表示）に直した表です。Python で計算しました。

1000進と1024進の差は桁が上がるほど広がる

この節では、KB では小さい差が、TB・PB ではなぜ1割近くになるのかが分かります。

1024は1000より2.4％大きいだけですが、単位が1つ上がるたびにこの差が掛け算で重なります。GB は1024を3回掛けるので約7.4％、TB は4回で約10％の差になります。Python で計算した値です。

「少なく見える割合」は、1000進の値を1024進で読んだとき何％減るか（1 − 1000ⁿ÷1024ⁿ）です。逆に、1024進の値を1000進で数えると何％増えるかは、GB で7.37％、TB で9.95％になります。どちらの向きの割合かで数字が変わるので、比べるときは向きをそろえます。

「500GBが465GB」「1TBが931GB」になる計算

この節では、買ったストレージの容量が少なく表示される理由を、計算と実物で確かめられます。

500GBのSSDは500,000,000,000バイトです。これを1024で3回割ると465.66になります。Windows はこの値に「GB」と付けて表示するので、「465GB」に見えます。中身のバイト数は同じです。

500,000,000,000 ÷ 1024 ÷ 1024 ÷ 1024 = 465.66 …（GiB）
1,000,000,000,000 ÷ 1024 ÷ 1024 ÷ 1024 = 931.32 …（GiB）
64,000,000,000 ÷ 1024 ÷ 1024 ÷ 1024 = 59.60 …（GiB）

手元で、中身を持たない（ディスクを使わない）500,000,000,000バイトのファイルを作り、同じファイルを2通りの単位で表示させました。

$ truncate -s 500000000000 ssd500.img
$ ls -l ssd500.img
-rw-r--r-- 1 root root 500000000000 Nov  6 16:35 ssd500.img
$ ls -lh ssd500.img
-rw-r--r-- 1 root root 466G Nov  6 16:35 ssd500.img
$ ls -l --si ssd500.img
-rw-r--r-- 1 root root 500G Nov  6 16:35 ssd500.img

同じ500,000,000,000バイトが、-h（1024進）では466G、--si（1000進）では500Gと表示されました。ls は465.66を切り上げて466Gと出しています（ファイルの日時は UTC の表示です）。製品表示とOSの表示の差は、この「割る数の違い」と「単位の付け方の違い」の2つで説明できます。

Windows・macOS での見え方

Microsoft Learn の Azure Files の説明では、Windows は2進（1024進）で計算し、その値を一貫して10進の単位（KB・MB・GB・TB）で表示していると整理されています。Apple の公式サポートは、Apple 製品は10進（1GB＝10億バイト）で容量を表示し、iOS 10 以前・OS X Leopard 以前は2進で表示していたと説明しています。このため、同じ500GBのSSDが、macOS では500GB、Windows では約465GBと表示されます。

自分で確かめる（Windows・Linux・Python）

• 1Windows：換算ツールに製品の容量を入れて画面の値と比べるツールの「1024進」の列（GiB）の値が、Windows の画面で「GB」と出ている値に当たる
• 2Linux：ls -l と ls -l --si を並べるls -l はバイト数そのまま、--si は1000進、-h は1024進。3つの差が単位の差
• 3Python：1行で割り算するpython3 -c "print(500*10**9/2**30)" で 465.66… が出る

Linux の df -h と df -H・ls -lh・du の違い

この節では、Linux のコマンドがどの単位で表示するのか、1000進と1024進を切り替える方法が分かります。

GNU coreutils の df・du・ls は、-h（--human-readable）で1024進、--si で1000進になります。df だけは -H が --si と同じ意味です。同じディスクを2通りで表示させました。

$ df -h /
Filesystem      Size  Used Avail Use% Mounted on
/dev/vda        252G   14G   29G  33% /
$ df -H /
Filesystem      Size  Used Avail Use% Mounted on
/dev/vda        271G   15G   31G  33% /
$ df -B1 / | tail -1
/dev/vda       270553174016 14582976512 30360637440  33% /

Size は 270,553,174,016バイトで、1024³で割ると251.97（252G）、1000³で割ると270.55（271G）です。どちらも切り上げで表示されています。同じディスクが「252G」と「271G」になり、約19G（7％）の差があります。

du とファイルの大きさでも同じことが起きます。中身の無いファイルは、実際に使っているディスクの量（du の既定）が0で、見かけの大きさ（--apparent-size）が500GBです。

$ du -h ssd500.img
0	ssd500.img
$ du -h --apparent-size ssd500.img
466G	ssd500.img
$ du --si --apparent-size ssd500.img
500G	ssd500.img

数を直接変換したいときは、coreutils の numfmt が使えます。--to=iec は1024進（単位の文字だけ）、--to=iec-i は1024進で「Gi」のように i を付け、--to=si は1000進です。

$ numfmt --to=si 500000000000; numfmt --to=iec 500000000000; numfmt --to=iec-i 500000000000
500G
466G
466Gi
$ numfmt --to=si 1000000000000; numfmt --to=iec-i 1000000000000
1.0T
932Gi
$ numfmt --from=iec-i 16Gi
17179869184
$ numfmt --from=auto 1Ki 1K
1024
1000

dd は、コピーした量を1000進と1024進の両方で表示します。1MiB（bs=1M）を100回書くと「105 MB, 100 MiB」、1,000,000バイト（bs=1000000）を100回書くと「100 MB, 95 MiB」でした。dd の bs=1M は1,048,576バイトで、1,000,000バイトではありません。

$ dd if=/dev/zero of=z bs=1M count=100
104857600 bytes (105 MB, 100 MiB) copied, 0.0717965 s, 1.5 GB/s
$ dd if=/dev/zero of=z bs=1000000 count=100
100000000 bytes (100 MB, 95 MiB) copied, 0.0377709 s, 2.6 GB/s

環境変数 BLOCK_SIZE に si や human-readable を入れると、df・du・ls の既定の表示をまとめて変えられます（GNU coreutils のマニュアル）。df・du の読み方と、容量を食っているフォルダーを探す方法は、関連記事「duコマンドの使い方｜容量を大きい順に表示・オプション一覧・dfとの差」で扱っています。ls の各列の意味は、関連記事「lsコマンドのオプション一覧とls -lの見方｜パーミッション図解」で扱っています。

フォーマット後に使える容量がさらに減る理由（ext4 で実測）

この節では、1000進と1024進の差のほかに、ファイルシステムの管理領域で容量が減る分が分かります。

単位の差だけでは、使える容量は説明しきれません。フォーマットすると、ファイルの場所を記録する表（inode）・ジャーナル・予約領域などに容量が使われます。1,000,000,000バイト（製品表示の1GB）のイメージを ext4 の既定の設定でフォーマットし、dumpe2fs で読みました。

$ truncate -s 1000000000 fs1g.img
$ mkfs.ext4 -q -F fs1g.img
$ dumpe2fs -h fs1g.img | grep -E "Block count|Reserved block count|Free blocks|Block size|Overhead"
Block count:              244140
Reserved block count:     12207
Overhead clusters:        8533
Free blocks:              235601
Block size:               4096

手元の仮想マシンでも、ディスク装置としての大きさ（lsblk -b）は274,877,906,944バイト＝ちょうど256GiB、その上のファイルシステムの Size は270,553,174,016バイト（251.97GiB）で、約1.6％が管理領域でした。パソコンやスマホでは、さらに OS・回復用の領域・アプリが最初から使っている分も引かれます。Apple の公式サポートも、製品の箱にある「実際のフォーマット後の容量はこれより少ない」という注記を紹介しています。

メモリは1024進（free と /proc/meminfo）

この節では、メモリ（RAM）の容量がなぜ1024進で数えられるのか、Linux でどう表示されるのかが分かります。

メモリは、アドレスの線の本数で番地の数が決まるため、2の累乗の大きさで作られます。アドレスが32ビットなら番地は2の32乗＝4,294,967,296個で、ちょうど4GiBです。32ビットの OS やプログラムで「4GB の壁」と言われるのはこの数です。このため、「16GBのメモリ」は正確には16GiB（17,179,869,184バイト）で、1000進で数えると17.18GBになります。Ubuntu の単位の方針（UnitsPolicy）も、RAM の大きさは2進（例：2 GiB RAM）、ディスクの大きさと通信速度は10進で書くと決めています。

$ free -h
               total        used        free      shared  buff/cache   available
Mem:           7.8Gi       836Mi       6.6Gi       237Mi       903Mi       7.0Gi
$ free -h --si
               total        used        free      shared  buff/cache   available
Mem:            8.4G        877M        7.1G        248M        947M        7.5G
$ head -1 /proc/meminfo
MemTotal:        8214984 kB

/proc/meminfo の「kB」は1024バイトの意味です。8,214,984 × 1024 ＝ 8,412,143,616バイトで、free --si の8.4G と一致します（1000倍なら8.2Gになるはず）。procps-ng 4.0.4 の free -h は、1024進の値に「Gi」「Mi」と i を付けて表示していました。

プログラミング言語・DBでの換算（Python・JavaScript・Java・Go・PHP・PostgreSQL）

この節では、プログラムでファイルの大きさを取得して GB・GiB に直す書き方と、言語ごとのつまずきが分かります。

どの言語も、ファイルの大きさはバイト数（整数）で返します。GB・GiB に直すのは自分の割り算で、標準の関数に「1024進の GB」を出すものはほとんどありません。500,000,000,000バイトのファイルを各言語で読みました。

Python

import os, shutil
SI  = ["B", "KB", "MB", "GB", "TB", "PB"]
IEC = ["B", "KiB", "MiB", "GiB", "TiB", "PiB"]

def human(n, binary=False):
    base, units = (1024, IEC) if binary else (1000, SI)
    i, v = 0, float(n)
    while v >= base and i < len(units) - 1:
        v /= base
        i += 1
    return f"{v:.2f} {units[i]}"

for n in (500 * 10**9, 10**12, 64 * 10**9, 16 * 2**30):
    print(f"{n:>16,} B  1000進={human(n):>10}  1024進={human(n, True):>11}")
print("getsize:", os.path.getsize("ssd500.img"))
u = shutil.disk_usage("/")
print("disk_usage total:", u.total, "=", human(u.total), "/", human(u.total, True))

 500,000,000,000 B  1000進= 500.00 GB  1024進= 465.66 GiB
1,000,000,000,000 B  1000進=   1.00 TB  1024進= 931.32 GiB
  64,000,000,000 B  1000進=  64.00 GB  1024進=  59.60 GiB
  17,179,869,184 B  1000進=  17.18 GB  1024進=  16.00 GiB
getsize: 500000000000
disk_usage total: 270553174016 = 270.55 GB / 251.97 GiB

JavaScript（Node.js）

const fs = require("fs");
const size = fs.statSync("ssd500.img").size;
console.log(size, "bytes");
console.log((size / 1e9).toFixed(2), "GB /", (size / 2 ** 30).toFixed(2), "GiB");
console.log(new Intl.NumberFormat("ja-JP",
  { style: "unit", unit: "gigabyte", maximumFractionDigits: 2 }).format(size / 2 ** 30));
console.log(2 ** 32, (2 ** 32) >>> 0, (2 ** 32) | 0);

500000000000 bytes
500.00 GB / 465.66 GiB
465.66 GB
4294967296 0 0

Intl.NumberFormat の unit には gigabyte はあっても gibibyte はありません。GiB の値を渡すと「465.66 GB」と表示され、Windows と同じ書き方になります。unit: "gibibyte" を指定すると次のエラーになりました。また、ビット演算（>>>・|）は32ビットで計算するため、4GiB（2の32乗）を通すと0になります。

RangeError: Invalid unit argument for Intl.NumberFormat() 'gibibyte'

Java

import java.nio.file.*;
public class Ds {
  public static void main(String[] a) throws Exception {
    long size = Files.size(Path.of("ssd500.img"));
    System.out.println(size + " bytes");
    System.out.printf("%.2f GB / %.2f GiB%n", size / 1e9, size / (double) (1L << 30));
    int i = (int) (4L * 1024 * 1024 * 1024);
    int j = 4 * 1024 * 1024 * 1024;
    System.out.println("(int)4GiB=" + i + "  int同士=" + j + "  long=" + (4L << 30));
  }
}

500000000000 bytes
500.00 GB / 465.66 GiB
(int)4GiB=0  int同士=0  long=4294967296

4 * 1024 * 1024 * 1024 は int どうしの掛け算なので、警告もなく0になりました。容量の計算では、最初の数を 4L のように long にします。

Go・PHP

package main

import ("fmt"; "os")

func main() {
	fi, _ := os.Stat("ssd500.img")
	s := fi.Size()
	fmt.Printf("%d bytes\n%.2f GB / %.2f GiB\n", s, float64(s)/1e9, float64(s)/(1<<30))
	var u uint32 = 1<<32 - 1
	u++
	fmt.Println("uint32 max+1 =", u)
}

500000000000 bytes
500.00 GB / 465.66 GiB
uint32 max+1 = 0

<?php
$s = filesize("ssd500.img");
printf("%d bytes\n%.2f GB / %.2f GiB\n", $s, $s / 1e9, $s / (1 << 30));
echo PHP_INT_SIZE, " ", PHP_INT_MAX, "\n";

500000000000 bytes
500.00 GB / 465.66 GiB
8 9223372036854775807

64ビットの PHP（PHP_INT_SIZE が8）では、500GBのファイルの大きさもそのまま整数で扱えました。Go の uint32 は最大値に1を足すと0に戻ります。4GiB を超えるファイルの大きさを32ビットの型に入れると、このように桁があふれます。

PostgreSQL の pg_size_pretty

SELECT pg_size_pretty(500000000000::bigint) AS a,
       pg_size_pretty(1073741824::bigint)   AS b,
       pg_size_pretty(1000000000::bigint)   AS c,
       pg_size_bytes('1 GB') AS d,
       pg_size_bytes('1 kB') AS e;

   a    |    b    |   c    |     d      |  e
--------+---------+--------+------------+------
 466 GB | 1024 MB | 954 MB | 1073741824 | 1024

PostgreSQL の kB・MB・GB は1024進です。500,000,000,000バイトが「466 GB」、1GiB が「1024 MB」と表示され、pg_size_bytes('1 GB') は1,073,741,824を返しました。公式ドキュメントも「単位は10の累乗ではなく2の累乗で、1kB は1024バイト」と明記しています。データベースの容量を報告するときは、この表示が1024進であることを添えると誤解を防げます。

設定ファイルの単位のつまずき（JVM の -Xmx・Kubernetes）

この節では、メモリの上限などを設定するときに、1000進と1024進の取り違えで何が起きるかが分かります。

設定ファイルの「g」「M」「Mi」は、ソフトごとに1000進か1024進かが決まっています。JVM の -Xmx を変えて、実際に設定された最大ヒープを見ました。

$ java -Xmx1g -XX:+PrintFlagsFinal -version | grep -w MaxHeapSize
   size_t MaxHeapSize                              = 1073741824
$ java -Xmx1000m -XX:+PrintFlagsFinal -version | grep -w MaxHeapSize
   size_t MaxHeapSize                              = 1048576000

JVM の 1g は1,073,741,824バイト（1GiB）、1000m は1,048,576,000バイトで、「1g」と「1000m」は同じではありません。

Kubernetes のリソースの量（Quantity）は、Ki・Mi・Gi・Ti・Pi・Ei が1024進、k・M・G・T・P・E が1000進です。公式の API リファレンスには「1024 = 1Ki だが 1000 = 1k」とあり、小文字の m は「ミリ（1000分の1）」です。メモリに 400m と書くと400MiB ではなく0.4バイトの意味になるため、メモリは 400Mi のように i 付きで書きます。

1. 1そのソフトの公式ドキュメントで単位の定義を見るPostgreSQL の kB・JVM の g は1024進
2. 2i 付き（Mi・Gi）が書けるなら i 付きで書くKubernetes・numfmt は i 付きで1024進と明示できる
3. 3設定したあと、実際の値をバイト数で確かめる-XX:+PrintFlagsFinal・df -B1・ls -l など
4. 4仕様書・報告にはバイト数か i 付きの単位を残す「16GiB（17,179,869,184バイト）」の形

よくあるつまずき（症状→原因→直し方）

この節では、容量の表示が合わないときに、症状から原因と直し方を引けます。

通信速度の単位（Mbps）と MB/秒の換算、速度テストの結果の読み方は、関連記事「スピードテスト（Google）の結果の見方｜下り・Pingの目安表と実測」で扱っています。通信速度は1000進（1Mbps＝1,000,000ビット毎秒）で数えます。

1000進と1024進、どちらを使うかの判断表

この節では、資料・プログラム・設定で容量を書くときに、どちらの単位を選ぶかが分かります。

ディスク容量の見積もり方（ログの増え方・バックアップの世代数から必要量を出す計算）は、関連記事「キャパシティ見積もりの計算方法｜同時接続数・スループット・ディスク容量」で扱っています。見積もりの段階で1000進か1024進かをそろえておくと、購入する製品の容量と OS の表示の差（GB で約7％）を見込めます。Linux でメモリ・ディスクの使用量を見るコマンドは、関連記事「Linuxメモリ・ディスク確認｜free・df・du・vmstat・iostat見方」にまとめています。

よくある質問

Q. 1GBは何MBですか？ A. 1000MBです。1GB＝1,000,000,000バイト、1MB＝1,000,000バイトです。1024進で数えるなら、1GiB＝1024MiB です。Windows の画面のように1024進の値に GB・MB と付けている場合は、1GB＝1024MB として読みます。

Q. 1MBは何KBですか？ A. 1000KBです（1MiB＝1024KiB）。メールの添付やアップロードの上限が「1MB」とあるときは、サービスによって1,000,000バイトか1,048,576バイトかが違うので、境目の大きさを送るときはバイト数で確かめます。

Q. 1000と1024はどちらが正しいのですか？ A. 国際規格では、KB・MB・GB は1000倍、KiB・MiB・GiB は1024倍です。ただし、1024進の値に KB・MB・GB と付けるソフト（Windows・PostgreSQL・/proc/meminfo など）もあるため、表示している側の決まりを確かめます。

Q. 1TBのHDDが931GBと表示されるのは故障ですか？ A. 故障ではありません。1,000,000,000,000バイトを1024で3回割ると931.32になり、Windows はこれを「931GB」と表示します。さらに、フォーマットで管理領域の分が少し減ります。

Q. KiB・MiB・GiB は何と読みますか？ A. キビバイト・メビバイト・ギビバイトです。TiB はテビバイト、PiB はペビバイトです。「キロ（kilo）＋バイナリ（binary）」から「キビ（kibi）」という名前になりました。

Q. Mac と Windows で同じUSBメモリの容量が違うのはなぜですか？ A. 計算のしかたが違うためです。現在の macOS は1000進（1GB＝10億バイト）で表示し、Windows は1024進で計算した値に GB と付けて表示します。64GBのUSBメモリは、Mac で約64GB、Windows で約59.6GBと表示されます。

Q. メモリ16GBは16,000,000,000バイトですか？ A. メモリの「16GB」は通常16GiB、つまり17,179,869,184バイトです。メモリは2の累乗の大きさで作られるため、1024進で数えるのが習慣です。

Q. 1バイトは何ビットですか？ A. 8ビットです。通信速度の Mbps はビット毎秒なので、100Mbpsは毎秒12.5MB（1000進）が上限の目安です。記号は小文字の b がビット、大文字の B がバイトです。

Q. Linux で1000進の表示にするには？ A. ls・du は --si、df は -H（--si）を付けます。-h は1024進です。numfmt なら --to=si が1000進、--to=iec-i が1024進（i 付き）です。

Q. プログラムでファイルの大きさを GB にするには？ A. 言語の関数（os.path.getsize・fs.statSync・Files.size・os.Stat・filesize）でバイト数を取り、1000進なら10の9乗、1024進なら2の30乗で割ります。Java では 1L << 30 のように long で計算し、32ビットの型に入れないようにします。

まとめ

• KB・MB・GB は1000ごと、KiB・MiB・GiB は1024ごとに単位が上がる。1GB＝1,000,000,000バイト、1GiB＝1,073,741,824バイト。
• 差は桁が上がるほど広がり、GB で約6.9％、TB で約9.1％。500GBのSSDが Windows で約465GB、1TBのHDDが約931GBと表示されるのは、Windows が1024進の値に GB と付けているため。
• 手元の Linux では、同じ500,000,000,000バイトが ls -lh で466G、ls -l --si で500G、PostgreSQL の pg_size_pretty で「466 GB」と表示された。
• フォーマットすると、ext4 の既定で1GBあたり約3.5％の管理領域と5％の予約領域が引かれ、一般ユーザーが使える容量は製品表示から約8.5％少なくなった。
• メモリは1024進、ストレージ製品と通信速度は1000進。設定や仕様書では i 付きの単位かバイト数で書くと取り違えない。

参考・出典

確認日：2026年11月7日

• NIST「Prefixes for binary multiples」：https://physics.nist.gov/cuu/Units/binary.html
• Microsoft Learn「Understand Azure Files billing」（Azure Files storage units）：https://learn.microsoft.com/en-us/azure/storage/files/understanding-billing
• Apple サポート「How storage capacity is measured on Apple devices」：https://support.apple.com/102119
• GNU Coreutils Manual「Block size」：https://www.gnu.org/software/coreutils/manual/coreutils.html
• Ubuntu Wiki「UnitsPolicy」：https://wiki.ubuntu.com/UnitsPolicy
• PostgreSQL 16 Documentation「System Administration Functions」（pg_size_pretty・pg_size_bytes）：https://www.postgresql.org/docs/16/functions-admin.html
• Kubernetes「Quantity」：https://kubernetes.io/docs/reference/kubernetes-api/common-definitions/quantity/

株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。