Catatan Tutorials

Bit, byte, dan tipe data

Semua isi memori hanyalah bit. Tipe data menentukan arti bit-bit itu, dan menjelaskan kenapa 0.1 + 0.2 bukan 0.3, int8 bisa berbalik jadi -128, dan satu emoji bisa sepanjang 4 byte.

6 menit bacaTersedia juga dalam bahasa Inggris →

Di bagian sebelumnya kita mengikuti perjalanan program dari file teks sampai ke memori. Bagian ini melihat apa yang sebenarnya ada di dalam memori itu. Jawaban singkatnya: bit. Jawaban panjangnya adalah alasan tipe data layak dipahami, karena sebagian besar bug aneh seputar angka dan teks muncul karena kita lupa bahwa di bawahnya semuanya hanyalah bit.

Bit dan byte

Bit adalah satuan data terkecil: 0 atau 1. Byte adalah 8 bit, yang memberi 2⁸ = 256 kemungkinan kombinasi, dari 00000000 sampai 11111111.

Sistem biner bekerja seperti desimal, hanya saja digitnya dua, bukan sepuluh. Tiap posisi bernilai dua kali posisi di kanannya:

biner    1   0   1
nilai    4   2   1   →  4 + 0 + 1 = 5

Bisa dicek di Python:

>>> bin(5)
'0b101'
>>> 0b101
5
>>> hex(255)
'0xff'

Heksadesimal (basis 16) muncul di mana-mana, dari warna seperti #ff8f4a sampai alamat memori, karena satu digit hex pas mewakili 4 bit, jadi dua digit hex tepat mewakili satu byte.

Bit yang sama, arti yang berbeda

Inilah gagasan inti catatan ini: bit tidak tahu dirinya apa. Byte 01000001 bisa berarti angka 65, huruf A, atau bagian dari warna sebuah piksel. Yang menentukan artinya adalah tipe yang dipakai program untuk membacanya.

>>> ord('A')
65
>>> chr(65)
'A'
>>> 'A'.encode()
b'A'

Tipe data adalah sebuah kesepakatan: “baca byte-byte ini sebagai bilangan bulat”, “baca byte-byte ini sebagai teks”. Kebanyakan bug di area ini terjadi karena kesepakatannya berbeda dari yang kita kira.

Integer: bilangan bulat punya batas (kadang-kadang)

Banyak bahasa menyimpan integer dalam jumlah bit yang tetap. int8 di Go punya 8 bit dan bisa menampung -128 sampai 127. Apa yang terjadi kalau melewati batas atasnya?

var small int8 = 127
small++
fmt.Println(small) // -128

var b uint8 = 255
b++
fmt.Println(b) // 0

Nilainya berputar balik (wrap around), seperti odometer yang kembali ke nol. Tidak ada error, tidak ada peringatan, hanya angka yang salah. Sistem nyata memakai integer 32 atau 64 bit, jadi batasnya jauh lebih besar, tapi batas itu tetap ada.

Python mengambil pendekatan lain. Dokumentasinya menyebut “Integers have unlimited precision”: integer di Python tidak punya batas presisi, jadi ini aman:

>>> 2 ** 100
1267650600228229401496703205376

JavaScript berbeda lagi: angka biasa di JavaScript adalah floating point (lihat di bawah), dan bilangan bulat hanya akurat sampai Number.MAX_SAFE_INTEGER, yaitu 9007199254740991 (2⁵³ − 1). MDN menjelaskan bahwa “safe” di sini “refers to the ability to represent integers exactly and to compare them correctly”, yaitu kemampuan menyimpan dan membandingkan bilangan bulat dengan tepat. Lewat dari situ, hasilnya diam-diam salah:

> Number.MAX_SAFE_INTEGER
9007199254740991
> 9007199254740993
9007199254740992
> 9007199254740993n   // BigInt
9007199254740993n

Ini bukan sekadar teori. ID angka yang besar dari database, saat lewat JSON lalu dibaca JavaScript, bisa kehilangan digit terakhirnya dengan cara ini. Karena itulah banyak API mengirim ID besar sebagai string.

PHP mengambil jalan lain lagi. Manualnya menyebut: “If PHP encounters a number beyond the bounds of the int type, it will be interpreted as a float instead.” Angka yang melewati batas int berubah jadi float. Jadi angkanya tetap membesar, tapi diam-diam menjadi float dan mulai kehilangan ketelitian:

var_dump(PHP_INT_MAX);      // int(9223372036854775807)
var_dump(PHP_INT_MAX + 1);  // float(9.223372036854776E+18)

Floating point: kenapa 0.1 + 0.2 bukan 0.3

Angka berkoma biasanya disimpan sebagai floating point, format biner yang mirip notasi ilmiah. Masalahnya, seperti ditulis tutorial Python: “most decimal fractions cannot be represented exactly as binary fractions”. Sebagian besar pecahan desimal tidak bisa disimpan persis sebagai pecahan biner. Khususnya, “the decimal value 0.1 cannot be represented exactly as a base 2 fraction.”

Jadi komputer menyimpan nilai biner yang paling dekat, dan selisih kecilnya menumpuk:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1 + 0.2 == 0.3
False

JavaScript memberi hasil yang persis sama, karena memakai jenis floating point yang sama. Ini bukan bug di bahasanya; memang begitulah pecahan biner bekerja.

PHP memakai float yang sama, dengan satu jebakan tambahan: echo membulatkan tampilannya, jadi masalahnya tersembunyi sampai kita membandingkan.

echo 0.1 + 0.2;               // 0.3
var_dump(0.1 + 0.2);          // float(0.30000000000000004)
var_dump(0.1 + 0.2 == 0.3);   // bool(false)

Manual PHP menyatakannya terang-terangan: “never trust floating-point number results to the last digit, and do not compare floating-point numbers directly for equality.” Jangan percaya digit terakhir hasil float, dan jangan bandingkan float langsung dengan ==.

Yang perlu dilakukan:

  • Jangan membandingkan float dengan == untuk hasil perhitungan. Bandingkan dengan toleransi kecil, atau bulatkan dulu.
  • Jangan menyimpan uang sebagai float. Pakai integer dalam satuan terkecil (sen, atau rupiah utuh), atau tipe desimal:
>>> from decimal import Decimal
>>> Decimal('0.1') + Decimal('0.2')
Decimal('0.3')

Teks: karakter juga angka

Teks juga disimpan sebagai angka, lewat encoding yang memetakan karakter ke byte.

ASCII, standar lama, mencakup “a total of 128 code points”: huruf Inggris, angka, tanda baca, dan karakter kontrol. ASCII “encodes each code-point as a value from 0 to 127 – storable as a seven-bit integer”, jadi cukup 7 bit per karakter. Itu cukup untuk bahasa Inggris, tapi tidak untuk é, aksara Arab, atau emoji.

Unicode memberi setiap karakter dari setiap sistem tulisan nomornya sendiri (code point). UTF-8 adalah cara paling umum mengubah nomor-nomor itu menjadi byte. Menurut RFC 3629, karakter “are encoded using sequences of 1 to 4 octets” (1 sampai 4 byte), dan “US-ASCII characters are encoded in one octet having the normal US-ASCII value”, jadi teks bahasa Inggris biasa sama persis di ASCII dan UTF-8.

Panjang yang berubah-ubah itulah kenapa pertanyaan “berapa panjang string ini?” punya lebih dari satu jawaban:

>>> len('a'), len('a'.encode())
(1, 1)
>>> len('é'), len('é'.encode())
(1, 2)
>>> len('😀'), len('😀'.encode())
(1, 4)

Di Python, len pada string menghitung karakter; pada hasil encode menghitung byte. Bahasa lain menghitung dengan cara berbeda:

fmt.Println(len("é"), len([]rune("é"))) // 2 1  (byte, karakter)
> 'é'.length
1
> '😀'.length
2
> [...'😀'].length
1

Di Go, len pada string menghitung byte. Di JavaScript, length menghitung “UTF-16 code units”, jadi satu emoji dihitung 2. Tidak ada yang salah; masing-masing menjawab pertanyaan yang berbeda.

strlen di PHP berperilaku seperti len di Go. Kata manualnya, “strlen() returns the number of bytes rather than the number of characters in a string”: yang dihitung byte, bukan karakter. Untuk menghitung karakter, pakai versi multibyte:

var_dump(strlen("é"), mb_strlen("é"));    // int(2) int(1)
var_dump(strlen("😀"), mb_strlen("😀"));  // int(4) int(1)

Boolean

Tipe paling sederhana: true atau false. Di memori, boolean biasanya memakai satu byte penuh, karena byte adalah potongan memori terkecil yang bisa dialamatkan sendiri oleh kebanyakan komputer. Boolean akan dapat bagian sendiri nanti di seri ini, saat membahas percabangan dan logika.

Kenapa ini penting sehari-hari

  • Uang. Kesalahan pembulatan float pada harga dan total adalah bug production klasik. Simpan nominal sebagai integer dalam satuan terkecil, atau pakai tipe desimal.
  • ID dan JSON. ID integer besar bisa berubah diam-diam saat dibaca sebagai number di JavaScript. Kirim sebagai string kalau nilainya bisa melewati 2⁵³ − 1.
  • Batas panjang teks. “Maksimal 255 karakter” dan “maksimal 255 byte” bukan batas yang sama begitu pengguna mengetik nama beraksen atau emoji. Cek mana yang sebenarnya dimaksud kolom database atau API Anda (dan di PHP, apakah kodenya memakai strlen atau mb_strlen).
  • Overflow. Counter dan ID di integer berukuran tetap bisa berputar balik tanpa error. Pilih ukuran yang ruangnya lega.

Coba sendiri

  1. Di Python, coba 0.1 + 0.1 + 0.1 == 0.3, lalu round(0.1 + 0.1 + 0.1, 2) == 0.3.
  2. Bandingkan len(s) dan len(s.encode()) untuk nama Anda, kata beraksen, dan sebuah emoji.
  3. Di console browser, ketik 9007199254740993 dan lihat hasilnya. Lalu tambahkan n di belakangnya.
  4. Kalau Go sudah terpasang, buat int8 yang overflow, lalu ganti jadi int16 dan lihat bedanya.

Ringkasan

  • Bit bernilai 0 atau 1; byte adalah 8 bit (256 kemungkinan nilai).
  • Bit tidak punya arti dengan sendirinya. Tipe menentukan cara membacanya.
  • Integer berukuran tetap bisa berputar balik; integer Python tidak; PHP mengubahnya jadi float; angka JavaScript hanya akurat sampai 2⁵³ − 1.
  • Floating point tidak bisa menyimpan sebagian besar pecahan desimal dengan tepat, jadi 0.1 + 0.2 bukan 0.3. Jangan pakai float untuk uang.
  • Teks disimpan lewat encoding. UTF-8 memakai 1 sampai 4 byte per karakter, jadi “panjang” tergantung apa yang dihitung.

Referensi