Qual é a diferença entre um kibibyte, um kilobit e um kilobyte?

Essa pergunta me fez pensar sobre as diferenças entre essas três maneiras de medir o tamanho: um kibibyte , um kilobit e o kilobyte convencional.

Entendo que essas medidas têm usos diferentes (a taxa de transferência de dados é medida em bits / s), mas não tenho muita certeza se posso dizer a diferença entre Mb e MB e MiB.

Aqui está um comentário, reproduzido abaixo, retirado desta resposta ( grifo meu ).

O C64 possui 65536 bytes de RAM. Por convenção, o tamanho da memória é especificado no kibibytes , taxas de transferência de dados em kilobits , e armazenamento em massa em qualquer-the-fabricantes-pensar-de-agora- Bytes . Os discos rígidos usam T, G, M ek no rótulo, o Windows relata o tamanho em Ti , Gi , Mi e ki . E aqueles disquetes de 1,44 MB? Esses não são 1.44MB nem 1.44MiB, são 1.44 kilokibibytes. Isso significa 1440kiB ou 1'474'560 bytes. - terceiro

1 KiB (Kibibyte) = 1,024 B (Bytes) (2^10 Bytes)
1 kb  (Kilobit)  =   125 B (Bytes) (10^3 Bits ÷ (8 bits / byte) = 125 B)
1 kB  (Kilobyte) = 1,000 B (Bytes) (10^3 Bytes)

É da mesma maneira com qualquer prefixo de SI; k(1x10 ³ ), M(1x10 ⁶ ), G(1x10 ⁹ ), portanto, por extensão:

1 MiB (Mebibyte) = 1,048,576 B (Bytes) (2^20 Bytes)
1 Mb  (Megabit)  =   125,000 B (Bytes) (10^6 Bits ÷ (8 bits / byte) = 125,000 B)
1 MB  (Megabyte) = 1,000,000 B (Bytes) (10^6 Bytes)

Os únicos que são um pouco diferentes são a IEC Binary prefixos (kibi / mebi / gibi etc.), porque eles estão na base 2, não base 10 (por exemplo, todos os números iguais 2 ^{alguma coisa} em vez de 10 ^algo ). Prefiro usar apenas os prefixos do SI, porque acho que é muito mais fácil. Além disso, o Canadá (meu país) usa o sistema métrico, por isso estou acostumado, por exemplo 1kg = 1000g(ou 1k anything = 1000 base things). Nada disso está errado ou certo; apenas saiba qual você está usando e o que realmente significa.

Para apaziguar os comentadores:

1 Byte (B) = 2 nibbles = 8 bits (b)

É por isso que, se você já deu uma olhada em um editor hexadecimal, tudo é dividido em dois caracteres hexadecimais; cada caractere hexadecimal é do tamanho de uma mordidela e há dois em um byte. Por exemplo:

198 (decimal) = C6 (hex) = 11000110 (bits)

Existem alguns termos básicos simples e fáceis de entender:

* A bit      (b)   is the smallest unit of data comprised of just {0,1}
* 1 nibble   (-)   = 4 bits (cutesy term with limited usage; mostly bitfields)
* 1 byte     (B)   = 8 bits (you could also say 2 nibbles, but that’s rare)

Para converter entre bits e bytes (com qualquer prefixo), apenas múltiplos ou divida por oito; agradável e simples.

Agora, as coisas ficam um pouco mais complicadas porque existem dois sistemas para medir grandes grupos de dados: decimal e binário . Durante anos, programadores e engenheiros de computador usaram os mesmos termos para ambos, mas a confusão acabou evocando algumas tentativas de padronizar um conjunto adequado de prefixos.

Cada sistema usa um conjunto semelhante de prefixos que podem ser aplicados a bits ou bytes. Cada prefixo começa da mesma forma em ambos os sistemas, mas os binários soam como conversa de bebê depois disso.

O sistema decimal é a base 10, com o qual a maioria das pessoas está acostumada e confortável, porque temos 10 dedos. O sistema binário é de base 2, com o qual a maioria dos computadores está acostumada e confortável, porque possui dois estados de tensão.

O sistema decimal é óbvio e fácil de usar para a maioria das pessoas (é simples o suficiente para se multiplicar em nossas cabeças). Cada prefixo aumenta em 1.000 (a razão disso é uma questão totalmente diferente).

O sistema binário é muito mais difícil de ser usado pela maioria das pessoas que não são computadores, e mesmo os programadores geralmente não conseguem múltiplos números arbitrariamente grandes em suas cabeças. No entanto, é uma simples questão de múltiplos de dois. Cada prefixo aumenta em 1.024. Um "K" é 1.024 porque essa é a potência mais próxima de dois do "k" decimal de 1.000 (isso pode ser verdade neste momento, mas a diferença aumenta rapidamente a cada prefixo sucessivo).

Os números são os mesmos para bits e bytes que têm o mesmo prefixo.

* Decimal:
* 1 kilobyte (kB)  = 1,000 B  = 1,000^1 B           1,000 B
* 1 megabyte (MB)  = 1,000 KB = 1,000^2 B =     1,000,000 B
* 1 gigabyte (GB)  = 1,000 MB = 1,000^3 B = 1,000,000,000 B

* 1 kilobit  (kb)  = 1,000 b  = 1,000^1 b           1,000 b
* 1 megabit  (Mb)  = 1,000 Kb = 1,000^2 b =     1,000,000 b
* 1 gigabit  (Gb)  = 1,000 Mb = 1,000^3 b = 1,000,000,000 b

* …and so on, just like with normal Metric units meters, liters, etc.
* each successive prefix is the previous one multiplied by 1,000



* Binary:
* 1 kibibyte (KiB) = 1,024 B  = 1,024^1 B           1,024 B
* 1 mebibyte (MiB) = 1,024 KB = 1,024^2 B =     1,048,576 B
* 1 gibibyte (GiB) = 1,024 MB = 1,024^3 B = 1,073,741,824 B

* 1 kibibit  (Kib) = 1,024 b  = 1,024^1 b =         1,024 b
* 1 mebibit  (Mib) = 1,024 Kb = 1,024^2 b =     1,048,576 b
* 1 gibibit  (Gib) = 1,024 Mb = 1,024^3 b = 1,073,741,824 b

* …and so on, using similar prefixes as Metric, but with funny, ebi’s and ibi’s
* each successive prefix is the previous one multiplied by 1,024

Observe que a diferença entre o sistema decimal e o binário começa pequeno (em 1K, eles têm apenas 24 bytes ou 2,4% de diferença), mas cresce a cada nível (em 1G, eles são> 70MiB ou 6,9% de diferença).

Como regra geral, os dispositivos de hardware usam unidades decimais (bits ou bytes), enquanto o software usa binário (geralmente bytes).

Esse é o motivo pelo qual alguns fabricantes, principalmente os mfgs, gostam de usar unidades decimais, porque isso aumenta o tamanho da unidade, mas os usuários ficam frustrados ao descobrir que têm menos do que esperavam ao ver o Windows et. al. relate o tamanho em binário. Por exemplo, 500 GB = 476GiB, portanto, enquanto a unidade é feita para conter 500 GB e rotulada como tal, Meu Computador exibe o 476GiB binário (mas como “476GB”), para que os usuários se perguntem para onde foram os outros 23 GB. (Os fabricantes de unidades geralmente adicionam uma nota de rodapé aos pacotes informando que o "tamanho formatado é menor", o que é enganoso, porque a sobrecarga do sistema de arquivos não é nada comparada à diferença entre unidades decimais e binárias.)

Os dispositivos de rede geralmente usam bits em vez de bytes por razões históricas, e os ISPs geralmente gostam de anunciar usando bits porque aumentam a velocidade das conexões que eles oferecem: 12Mibps em vez de apenas 1,5 Mbps. Eles geralmente combinam e combinam bits e bytes, decimal e binário. Por exemplo, você pode assinar o que o ISP chama de linha de "12MBps", pensando que você está recebendo 12MiBps, mas na verdade apenas recebe 1,43MiBps (12.000.000 / 8/1024/1024).

Algumas das respostas não são exatas.

Vamos primeiro fazer algumas anotações:

O prefixo "quilo" significa 1 000. Prefixar "quilo" para qualquer coisa significa 1 000 desse item. O mesmo vale para "mega" ou milhão, "giga" ou bilhão, "tera" ou trilhão e assim por diante.

A razão de 1 024 existir, em vez de simplesmente ter 1 000, deve-se ao modo como a aritmética binária funciona. Binário, como o próprio nome sugere, é um sistema de base 2 (possui 2 dígitos: 0, 1). Ele só pode executar aritmética com dois dígitos, em contraste com o sistema base 10 que usamos diariamente (0, 1, 2 ... 9), que possui dez dígitos.

Para chegar ao número 1 000 ( quilo ) usando aritmética binária, é necessário executar um cálculo de ponto flutuante. Isso significa que um dígito binário deve ser realizado a cada operação até que 1.000 sejam alcançados. No sistema base 10, 1 000 = 10 ³ (você sempre aumenta 10 para uma potência na base 10), um cálculo muito fácil e rápido para um computador executar sem "restos", mas no sistema base 2, é não é possível aumentar 2 (você sempre aumenta 2 para uma potência na base 2) para qualquer número inteiro positivo para obter 1 000. Uma operação de ponto flutuante ou adição longa deve ser usada, e isso leva mais tempo para ser executado do que o cálculo do número inteiro 2 ¹⁰ = 1024.

Você pode ter notado que 2 ¹⁰ = 1 024 é tentadoramente próximo de 1 000 e 1 024 a 1 número significativo é 1 000 (uma aproximação muito boa), e quando a velocidade da CPU era lenta como um cachorro velho e a memória era muito limitada , essa foi uma aproximação bastante decente e muito fácil de trabalhar, sem mencionar a execução rápida.

É por essa razão que termos com os prefixos "kilo", "mega", "giga" etc. etc. ficam com valores não exatos (1 024, 2 048, 4 096 e assim por diante). Eles nunca foram feitos para serem números exatos, eram aproximações binárias dos números da base 10. Eles simplesmente surgiram como palavras de jargão que as pessoas "tecnológicas" usavam.

Para tornar as coisas ainda mais complicadas, a JEDEC criou seus próprios padrões para unidades usadas em circuitos de memória semicondutores. Vamos comparar algumas das unidades JEDEC com as unidades SI (padrão internacional):

Kb = Kilobit (JEDEC, 1 024 bits. Observe a letra maiúscula 'K' e a letra minúscula 'b')
kB = kiloBit (SI, 1 000 bits. Observe a letra minúscula 'k' e a letra maiúscula 'B')

b = bit (JEDEC, observe a letra minúscula 'b')
b = ??? (SI não define a palavra 'bit', portanto, seu uso pode ser arbitrário)

B = byte (JEDEC, 8 bits. Observe a maiúscula 'B')
B = ???? (SI não define a palavra "byte" e "B" é usado para "Bel" [como no DeciBel])

KB = kilobyte (JEDEC, 1 024 bytes. Observe as letras maiúsculas 'K' e 'B')
kb = kilobyte (SI, 1 000 bytes. Observe o uso das letras minúsculas 'k' e 'B')

O ponto é que lugares diferentes usam prefixos diferentes com definições diferentes. Não existe uma regra rígida e rápida sobre qual deles você deve usar, mas seja consistente com o que você usa.

Devido à baixa votação, permita-me esclarecer por que você não pode fazer 1 000 em binário aumentando-o para qualquer número inteiro positivo.

Sistema Binário:

+----------------------------------------------------------------------------------+
| 1 024ths | 512ths | 256ths | 128ths | 64ths | 32nds | 16ths | 8ths | 4s | 2s | 0 |
+-----------------------------------------------------------------------------------

Observe que no sistema binário, as colunas duplicam toda vez. Isso contrasta com o sistema base 10, que aumenta em 10 a cada vez:

+--------------------------------------------------------------------------+
| 1 000 000ths | 100 000ths | 10 000ths | 1 000ths | 100ths | 10s | 1s | 0 |
+--------------------------------------------------------------------------+

Os 10 primeiros poderes em binário (base 2) são:

2 ⁰ = 1
2 ¹ = 2
2 ² = 4
2 ³ = 8
2 ⁴ = 16
2 ⁵ = 32
2 ⁶ = 64
2 ⁷ = 128
2 ⁸ = 256
2 ⁹ = 512
2 ¹⁰ = 1 024

Como você pode ver, não é possível aumentar o binário 2 para qualquer número inteiro positivo para atingir 1 000.