Konversi Basis Bilangan: Biner, Heksadesimal, Oktal & Desimal untuk Developer

Suatu siang, kamu menatap 0x7FFF5FBFF8C0 di debugger, lalu beralih ke file CSS untuk menyesuaikan #FF5733, kemudian mengetik chmod 755 di terminal. Tiga representasi angka berbeda, aritmetika yang sama di baliknya. Kalau kamu pernah berhenti sejenak saat mengonversi antara hex dan biner, atau bertanya-tanya mengapa Unix memakai oktal untuk permission — artikel ini akan menghubungkan titik-titik tersebut.

Kita akan membahas empat sistem bilangan yang muncul sehari-hari dalam pemrograman, tiga metode konversi yang layak diingat, dan kode nyata dalam JavaScript, Python, Go, dan C. Kalau mau langsung mengonversi angka tanpa baca teori, buka konverter basis bilangan kami — mendukung basis apa pun dari 2 sampai 36 dengan presisi tak terbatas.

Empat Sistem Bilangan yang Dipakai Setiap Developer

Setiap basis ada dalam pemrograman karena alasan praktis.

Biner (Basis 2) — Bahasa Mesin

Dua digit: 0 dan 1. Transistor entah menyala atau mati — batasan fisik ini melahirkan biner. Kamu akan menemuinya saat bekerja dengan bitmask, flag, operasi bitwise, dan perhitungan subnet IP.

Biner cepat jadi panjang. Angka 255 dalam desimal adalah 11111111 dalam biner — delapan digit untuk nilai tiga digit. Makanya programmer jarang menulis biner mentah kecuali posisi setiap bit memang penting.

Oktal (Basis 8) — Singkatan Unix

Delapan digit: 0 sampai 7. Setiap digit oktal memetakan tepat ke tiga bit biner, itulah sebabnya permission file Unix menggunakan oktal — chmod 755 memampatkan tiga kelompok tiga bit menjadi tiga digit yang mudah dibaca.

Oktal punya peran lebih besar di era PDP-11, ketika word mesin bisa dibagi bersih ke kelompok 3-bit. Sekarang ia hampir eksklusif untuk permission Unix, ditambah sesekali literal C berprefix 0 (sumber bug ketika seseorang menulis 0177 mengira itu desimal 177).

Desimal (Basis 10) — Default Manusia

Sepuluh digit: 0 sampai 9. Ini sistem yang otakmu pakai secara default — nomor port, indeks array, kode HTTP, dimensi piksel. Komputer tidak beroperasi dalam desimal, tapi manusia iya, jadi setiap angka yang ditampilkan ke pengguna keluar dalam basis 10.

Heksadesimal (Basis 16) — Pisau Swiss Army Developer

Enam belas simbol: 0-9 dan A-F. Setiap digit hex merepresentasikan tepat empat bit (satu nibble). Dua digit hex = satu byte. Selalu.

Kamu akan menemukan hex di alamat memori (0x7FFF5FBFF8C0), warna CSS (#FF5733), alamat MAC (00:1A:2B:3C:4D:5E), format UUID, dan hash digest. Hex adalah lingua franca pemrograman level byte.

Coba konversi antar keempat sistem di konverter basis bilangan kami — masukkan nilai di basis mana pun dan lihat yang lain langsung terupdate.

Cara Kerja Konversi Basis: Tiga Metode Inti

Tidak perlu tool untuk konversi antar basis, walau tool mempercepat prosesnya. Tiga metode mencakup semua kasus.

Metode 1 — Ekspansi Posisional (Basis Apa Pun → Desimal)

Setiap sistem posisional bekerja sama: setiap digit dikalikan basis dipangkatkan posisinya, dihitung dari kanan mulai nol.

Biner 1011:

1×2³ + 0×2² + 1×2¹ + 1×2⁰
= 8   + 0    + 2    + 1
= 11

Hex FF:

15×16¹ + 15×16⁰
= 240   + 15
= 255

Di kode, kebanyakan bahasa punya fungsi parse:

parseInt('1011', 2)   // 11
parseInt('FF', 16)    // 255
parseInt('755', 8)    // 493

Metode 2 — Pembagian Berulang (Desimal → Basis Apa Pun)

Untuk arah sebaliknya, bagi angka desimal dengan basis target berulang kali dan kumpulkan sisanya. Baca dari bawah ke atas.

Desimal 255 → heksadesimal:

255 ÷ 16 = 15  sisa 15 (F)
 15 ÷ 16 =  0  sisa 15 (F)
→ Baca dari bawah: FF

Desimal 42 → biner:

42 ÷ 2 = 21  sisa 0
21 ÷ 2 = 10  sisa 1
10 ÷ 2 =  5  sisa 0
 5 ÷ 2 =  2  sisa 1
 2 ÷ 2 =  1  sisa 0
 1 ÷ 2 =  0  sisa 1
→ Baca dari bawah: 101010

bin(42)    # '0b101010'
hex(255)   # '0xff'
oct(493)   # '0o755'

Metode 3 — Pengelompokan Bit (Biner ↔ Hex/Oktal Langsung)

Ini metode yang paling sering dipakai developer berpengalaman. Karena 16 = 2⁴ dan 8 = 2³, konversi antara biner dan hex (atau oktal) bisa dilakukan dengan mengelompokkan bit langsung — tanpa perhitungan.

Biner → Hex: Kelompokkan per nibble (4 bit) dari kanan. Tambahkan nol di kiri kalau perlu.

Biner:        1010 1111
Heksadesimal:  A    F
→ AF

Biner → Oktal: Kelompokkan per triplet (3 bit) dari kanan.

Biner: 111 101 101
Oktal:  7   5   5
→ 755

Tabel korespondensi nibble layak dihafalkan:

Biner	Hex	Biner	Hex
`0000`	0	`1000`	8
`0001`	1	`1001`	9
`0010`	2	`1010`	A
`0011`	3	`1011`	B
`0100`	4	`1100`	C
`0101`	5	`1101`	D
`0110`	6	`1110`	E
`0111`	7	`1111`	F

Setelah tabel ini masuk ingatan, konversi biner ke hex tinggal baca langsung.

Konversi Basis di Setiap Bahasa

Kode praktis di empat bahasa di mana operasi ini paling sering muncul.

JavaScript / TypeScript

// Parsing: string di basis apa pun → angka
parseInt('FF', 16)          // 255
parseInt('101010', 2)       // 42
parseInt('755', 8)          // 493

// Format: angka → string di basis apa pun
(255).toString(16)          // 'ff'
(42).toString(2)            // '101010'
(493).toString(8)           // '755'

// Literal
const bin = 0b11111111;     // 255
const oct = 0o377;          // 255
const hex = 0xff;           // 255

// BigInt untuk nilai di atas 2⁵³
const big = BigInt('0xFFFFFFFFFFFFFFFF');
big.toString(2)             // 64 angka satu
big.toString(10)            // '18446744073709551615'

Python

# Desimal → basis lain (string berprefix)
bin(255)          # '0b11111111'
oct(493)          # '0o755'
hex(255)          # '0xff'

# Basis lain → desimal
int('11111111', 2)    # 255
int('FF', 16)         # 255
int('755', 8)         # 493

# Output terformat dengan padding
f'{255:08b}'      # '11111111'  (biner 8 digit)
f'{255:02x}'      # 'ff'       (hex huruf kecil)
f'{255:02X}'      # 'FF'       (hex huruf besar)

# Presisi arbitrer bawaan di Python
big = int('F' * 64, 16)   # angka 256-bit, tanpa overflow

Go

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Format: int → string di basis apa pun
    fmt.Println(strconv.FormatInt(255, 16))  // "ff"
    fmt.Println(strconv.FormatInt(255, 2))   // "11111111"
    fmt.Println(strconv.FormatInt(493, 8))   // "755"

    // Parsing: string di basis apa pun → int
    n, _ := strconv.ParseInt("FF", 16, 64)  // 255
    fmt.Println(n)

    // Verb Printf
    fmt.Printf("%b %o %x %d\n", 255, 255, 255, 255)
    // 11111111 377 ff 255
}

C

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

int main() {
    // Output desimal, oktal, heksadesimal
    printf("%d %o %x\n", 255, 255, 255);
    // 255 377 ff

    // Parsing dari basis apa pun
    long val = strtol("FF", NULL, 16);   // 255
    long bin = strtol("101010", NULL, 2); // 42

    // C tidak punya printf biner bawaan — ekstraksi bit manual:
    uint8_t byte = 0xAF;
    for (int i = 7; i >= 0; i--)
        putchar(((byte >> i) & 1) ? '1' : '0');
    // 10101111

    return 0;
}

Skenario Nyata Konversi Basis

Lima situasi di mana konversi basis bukan lagi teori akademis tapi bagian dari pekerjaan.

1. Debugging Alamat Memori

Debugger menunjukkan pointer di 0x7FFF5FBFF8C0. Mengonversi dua byte terakhir ke biner — 1000 1100 0000 — mengungkap alignment 64-byte (enam nol di akhir). Alignment memengaruhi performa cache, operasi SIMD, dan memory-mapped I/O.

Aritmetika pointer juga lebih jelas dalam hex. Offset 0x100 dari alamat dasar berarti tepat 256 byte — satu page di banyak sistem embedded.

2. Warna CSS Hex ↔ RGB

Warna #FF5733 adalah tiga byte dalam pasangan hex:

Pasangan	Hex	Desimal	Channel
`FF`	FF	255	Merah (maks)
`57`	57	87	Hijau
`33`	33	51	Biru

Notasi singkat #F00 meluas jadi #FF0000 — merah murni. Varian 8 digit #FF573380 menambahkan channel alpha di mana 80 (desimal 128) berarti sekitar 50% opacity.

3. Permission File Unix (Oktal)

chmod 755 diuraikan:

7 → 111 → rwx  (pemilik: baca + tulis + eksekusi)
5 → 101 → r-x  (grup: baca + eksekusi)
5 → 101 → r-x  (lainnya: baca + eksekusi)

Setiap digit oktal mengkodekan satu kelompok permission karena tiga bit permission (baca=4, tulis=2, eksekusi=1) memetakan ke satu digit oktal (0-7). Kombinasi umum:

Oktal	Biner	Permission	Kegunaan
`755`	`111 101 101`	`rwxr-xr-x`	Executable, direktori
`644`	`110 100 100`	`rw-r--r--`	File biasa
`700`	`111 000 000`	`rwx------`	Script privat
`600`	`110 000 000`	`rw-------`	Kunci SSH, rahasia

4. Perhitungan Subnet

Mask /24 berarti 24 angka satu di awal dalam biner:

11111111.11111111.11111111.00000000
→ 255.255.255.0

Untuk menemukan alamat jaringan, AND-kan IP dan mask secara bitwise:

192.168.1.37   → 11000000.10101000.00000001.00100101
255.255.255.0  → 11111111.11111111.11111111.00000000
Hasil AND      → 11000000.10101000.00000001.00000000
               → 192.168.1.0 (alamat jaringan)

Network engineer rutin berpindah antara desimal (notasi IP), biner (perhitungan mask), dan hex (packet capture). Konverter basis bilangan kami memungkinkan verifikasi setiap oktet secara individual.

5. Membaca Hash Digest dan UUID

Hash MD5 seperti d41d8cd98f00b204e9800998ecf8427e berisi 32 karakter hex, merepresentasikan 16 byte (128 bit). Setiap pasangan hex adalah satu byte.

UUID mengikuti pola 8-4-4-4-12 dalam hex:

550e8400-e29b-41d4-a716-446655440000

32 digit hex dipisahkan tanda hubung — 128 bit yang sama, format berbeda. Nibble versi ada di posisi 13 (angka 4 di 41d4 menandakan UUID v4).

Buat hash dengan generator hash MD5 & SHA kami atau buat UUID dengan generator UUID kami — keduanya menghasilkan output heksadesimal.

Melampaui Basis 16: Basis 36, Basis 64, dan Basis Kustom

Empat basis standar mencakup sebagian besar pekerjaan, tapi beberapa basis lain muncul di konteks khusus.

Basis 36 — Encoding Alfanumerik Kompak

Basis 36 menggunakan 10 digit plus 26 huruf (A-Z), memberikan representasi alfanumerik case-insensitive paling kompak. Layanan pemendek URL menyukainya — ID video YouTube, short link, dan database key sering memakai basis 36.

(1000000).toString(36)    // 'lfls'
parseInt('lfls', 36)      // 1000000

Satu juta dikompresi jadi empat karakter. Untuk identifier pendek yang URL-friendly, sulit dikalahkan.

Basis 64 — Encoding Data (Bukan Sistem Bilangan)

Base64 tampak seperti basis lain, tapi tujuannya berbeda. Alih-alih merepresentasikan nilai numerik dalam sistem posisional, Base64 mengkodekan data biner arbitrer (gambar, file, token JWT) sebagai teks ASCII. Menggunakan A-Z, a-z, 0-9, +, dan / — 64 simbol total.

Ini skema encoding, bukan sistem bilangan. Untuk encode dan decode Base64, gunakan encoder-decoder Base64 kami.

Basis Arbitrer (2-36) dan Di Mana Mereka Muncul

Beberapa basis lain sesekali muncul:

Basis 12 (duodesimal): Waktu (12 jam), kuantitas (lusin). Beberapa matematikawan berargumen basis 12 lebih baik dari basis 10 karena 12 punya lebih banyak faktor.
Basis 60 (seksagesimal): Waktu (60 detik, 60 menit) dan sudut (360°). Diwarisi dari matematika Babilonia.
Basis 32: Encoding Crockford Base32 untuk identifier yang mudah dibaca manusia (menghilangkan karakter ambigu seperti I, L, O). Juga dipakai dalam geohashing.

Konverter basis bilangan kami mendukung basis bilangan bulat apa pun dari 2 sampai 36.

Operasi Bitwise dan Konversi Basis

Memahami biner bukan cuma soal konversi angka — ini fondasi operasi bitwise yang ada di mana-mana dalam system programming, game development, dan sistem permission.

const READ  = 0b100;  // 4
const WRITE = 0b010;  // 2
const EXEC  = 0b001;  // 1

// Gabungkan permission dengan OR
const perms = READ | WRITE;  // 0b110 = 6

// Cek permission dengan AND
(perms & READ)  !== 0   // true  — punya akses baca
(perms & EXEC)  !== 0   // false — tanpa akses eksekusi

// Toggle permission dengan XOR
perms ^ WRITE   // 0b100 = 4 — akses tulis dihapus

// Operasi shift
1 << 3    // 0b1000 = 8  (1 digeser 3 ke kiri)
0xFF >> 4  // 0b00001111 = 15  (geser kanan 4 = bagi 16)

Feature flag, hardware register, protokol jaringan, graphics programming — semuanya bergantung pada operasi bitwise. Ketika kamu bisa membaca biner dengan lancar, manipulasi bit berhenti terasa seperti sihir.

FAQ

Apa empat sistem bilangan utama dalam pemrograman?

Biner (basis 2), oktal (basis 8), desimal (basis 10), dan heksadesimal (basis 16). Biner adalah bentuk fisik data di hardware. Oktal untuk permission Unix. Desimal adalah default manusia. Heksadesimal memampatkan biner jadi format terbaca — setiap digit hex setara tepat 4 bit.

Bagaimana cara mengonversi biner ke heksadesimal?

Kelompokkan bit per 4 dari kanan, isi nol di kiri kalau kurang. Petakan setiap kelompok: 0000=0, 0001=1, …, 1010=A, …, 1111=F. Contoh: biner 10101111 → kelompok 1010 1111 → hex AF. Ini bekerja karena 16 = 2⁴.

Bagaimana cara mengonversi heksadesimal ke desimal?

Kalikan setiap digit hex dengan 16 pangkat posisinya (paling kanan = 0), lalu jumlahkan. Ingat: A=10, B=11, C=12, D=13, E=14, F=15. Contoh: hex FF = 15×16¹ + 15×16⁰ = 240 + 15 = 255. Di kode: JavaScript parseInt('FF', 16), Python int('FF', 16).

Mengapa developer memakai heksadesimal, bukan biner?

Hex itu kompak. Setiap digit hex memetakan tepat 4 bit, jadi 11111111 00001010 dalam biner jadi FF0A dalam hex — jauh lebih pendek dan mudah dibaca. Hex adalah standar untuk alamat memori, warna CSS (#FF5733), alamat MAC, output hash, dan format UUID.

Apa itu nibble dan apa hubungannya dengan konversi hex?

Nibble adalah 4 bit — setengah byte. Satu nibble memetakan tepat ke satu digit hex, membuat konversi biner-hex menjadi pencarian nibble demi nibble. Satu byte = dua nibble = dua digit hex. Korespondensi 4-bit yang rapi inilah alasan hex menjadi standar untuk data level byte.

Mengapa permission Unix ditulis dalam oktal?

Setiap kelompok permission punya tiga bit: baca (4), tulis (2), eksekusi (1). Ada tiga kelompok (pemilik, grup, lainnya). Karena 2³ = 8, tiga bit permission cocok dengan satu digit oktal. 755 berarti pemilik=7 (rwx), grup=5 (r-x), lainnya=5 (r-x). Oktal adalah basis natural untuk pengelompokan 3-bit.

Bagaimana menangani angka lebih besar dari 2⁵³ di JavaScript?

Gunakan BigInt. Tambahkan n ke literal atau pakai constructor BigInt(): BigInt('0xFFFFFFFFFFFFFFFF').toString(2) menghasilkan string biner lengkap 64-bit. Tipe Number standar kehilangan presisi di atas 9.007.199.254.740.991 (2⁵³ - 1). Konverter basis bilangan kami menggunakan BigInt secara internal, memproses angka berukuran apa pun tanpa kehilangan presisi.

Bagaimana cara mengonversi heksadesimal ke biner?

Ganti setiap digit hex dengan padanan 4-bit-nya lewat tabel nibble secara terbalik: 0=0000, 1=0001, …, A=1010, …, F=1111. Contoh: hex AF → A (1010) + F (1111) → biner 10101111. Di kode: JavaScript parseInt('AF', 16).toString(2) atau Python bin(int('AF', 16))[2:].

Kenapa `chmod 777` dianggap berbahaya?

chmod 777 (biner 111 111 111) memberi izin penuh baca+tulis+eksekusi kepada pemilik, grup, dan semua user lain di sistem. Di server shared hosting atau VPS yang menjalankan banyak proses, siapa pun yang punya akses shell bisa memodifikasi atau menimpa file kamu — termasuk skrip PHP, file konfigurasi database, atau kunci API. Pola yang lebih aman: 755 untuk direktori dan executable, 644 untuk file biasa, 600 untuk file sensitif (kunci SSH, .env). Kalau benar-benar perlu berbagi akses, buat group khusus dengan chgrp lalu pakai 775 atau 664 — jangan pernah 777 di production.