Tipe Data & Variabel di Berbagai Bahasa Pemrograman

Semua program yang pernah kamu lihat — dari kalkulator sederhana sampai aplikasi AI raksasa — dasarnya cuma ngurusin data. Angka, teks, nilai benar/salah, kumpulan data… semuanya perlu disimpan, diubah, dan diproses. Di sinilah variabel dan tipe data berperan.

Kalau di artikel sebelumnya kita udah bahas apa itu programming secara general, sekarang saatnya masuk ke fondasi paling dasar: gimana cara komputer nyimpen data.

Variabel: Kotak Penyimpanan digital

Bayangin variabel itu kayak kotak penyimpanan yang kamu kasih label. Di dalam kotak itu kamu taruh sesuatu — angka, teks, atau data lain. Labelnya kamu yang tentuin, isinya bisa kamu ganti kapan aja.

usia = 17            # kotak "usia" berisi angka 17
nama = "Budi"        # kotak "nama" berisi teks "Budi"

Analogi: lemari arsip. Setiap laci punya label (nama variabel), isinya bisa kamu ganti-ganti. Tapi kamu harus tahu kira-kira barang apa yang bakal kamu simpan di laci itu.

Tipe Data: Aturan main di setiap kotak

Setiap data punya tipe yang beda. Angka beda sifatnya dengan teks. Kamu bisa bagi angka, tapi kamu nggak bisa bagi teks.

Tipe data dasar yang ada di hampir semua bahasa:

Tipe Data	Fungsi	Contoh Nilai
Integer (int)	Bilangan bulat	42, -7, 0
Float (float)	Bilangan desimal	3.14, -0.5
String (str)	Teks / karakter	"Halo", 'A'
Boolean (bool)	Benar atau salah	true, false
Array / List	Kumpulan data berurutan	[1, 2, 3]
Null / None	Tidak ada nilai	null, None

Kenapa kita peduli tipe data?

Karena komputer perlu tahu berapa banyak memori yang harus disediakan, dan operasi apa yang boleh dilakukan.

Misalnya:

let a = "10";
let b = 10;

console.log(a + b);  // "1010" — string + number = digandengin
console.log(b + b);  // 20 — number + number = dijumlah

Dua kode yang mirip, hasilnya beda gara-gara tipe datanya berbeda. Ini yang bikin paham tipe data itu krusial — apalagi kalau kamu udah belajar algoritma & logika dasar.

Static vs Dynamic Typing: Dua kubu programmer

Ini perbedaan paling fundamental yang membagi bahasa pemrograman jadi dua kubu.

Aspek	Static Typing	Dynamic Typing
Kapan tipe dicek?	Saat kompilasi (sebelum jalan)	Saat runtime (pas jalan)
Deklarasi tipe?	Wajib ditulis	Nggak perlu (dideteksi otomatis)
Ganti tipe?	Nggak bisa — udah tetap	Bisa — bebas ganti
Error tipe?	Ketahuan pas nulis kode	Bisa baru ketahuan pas jalan
Contoh bahasa	Rust, Go, Java, C++, TypeScript	Python, JavaScript, Ruby, PHP
Kecepatan eksekusi	Lebih cepat (kompiler optimasi)	Agak lebih lambat

Contoh static typing (Rust):

let umur: i32 = 25;      // tipe i32 (integer 32-bit) — eksplisit
let nama: &str = "Budi";  // tipe &str (string slice)
// umur = "dua puluh";    // ERROR! beda tipe

Contoh dynamic typing (Python):

umur = 25                # Python nebak ini int
nama = "Budi"            # Python nebak ini string
umur = "dua puluh lima"  # BEDA! Aman aja — tipe berubah

Contoh dynamic typing (JavaScript):

let umur = 25;
umur = "dua puluh lima"; // Aman — JavaScript juga dinamis

Contoh static typing (Go):

var umur int = 25
nama := "Budi"           // Go bisa infer tipe kalau pake :=
// nama = 42             // ERROR! nama udah string

Strong vs Weak Typing: Seberapa ketat aturannya?

Ini dimensi lain yang sering bikin bingung. Strong typing artinya bahasa nggak suka ngelakuin konversi tipe secara diam-diam. Weak typing sebaliknya — dia akan coba konversi otomatis.

Aspek	Strong Typing	Weak Typing
”10” + 5	Error	"105" atau 15 (dikonversi)
Keamanan	Lebih aman — error ketahuan	Bisa hasil tak terduga
Fleksibilitas	Ribet — harus konversi manual	Praktis — otomatis
Contoh	Python, Rust, Java, Go	JavaScript, PHP, C

Contoh nyata:

# Python — strong typing
print("10" + 5)  # TypeError! Nggak mau nambahin string dan number
print(int("10") + 5)  # 15 — harus konversi manual dulu

// JavaScript — weak typing
console.log("10" + 5);   // "105" — number 5 diubah jadi string
console.log("10" - 5);   // 5 — string "10" diubah jadi number
console.log(true + 1);   // 2 — true diubah jadi 1
console.log("abc" * 3);  // NaN — ini mah hasilnya error diam-diam

Tipe data di berbagai bahasa: Perbandingan langsung

Setiap bahasa punya cara sendiri ngelola tipe data. Biar lebih jelas, ini perbandingan deklarasi variabel di 5 bahasa populer:

Integer & Float

# Python — dynamic, strong
usia = 25
berat = 70.5

// JavaScript — dynamic, weak
let usia = 25;
let berat = 70.5;

// Rust — static, strong
let usia: u32 = 25;      // unsigned 32-bit
let berat: f64 = 70.5;    // float 64-bit

// Go — static, strong
var usia int = 25
berat := 70.5              // tipe otomatis float64

// Java — static, strong
int usia = 25;
float berat = 70.5f;

String

Bahasa	Deklarasi	String interpolation?
Python	nama = "Budi"	f"Halo {nama}" ✅
JavaScript	let nama = "Budi"	`Halo ${nama}` ✅
Rust	let nama = "Budi"	format!("Halo {}", nama) ✅
Go	nama := "Budi"	fmt.Sprintf("Halo %s", nama) ✅
Java	String nama = "Budi"	"Halo " + nama (manual) ❌

Boolean

# Python
menikah = False
aktif = True

// JavaScript
let menikah = false;    // huruf kecil
let aktif = true;

// Rust — beneran binary, nggak bisa diubah ke integer
let menikah: bool = false;
// println!("{}", menikah as i32);  // Rust nggak suka konversi implisit

var menikah bool = false

Null: “Tidak ada nilai”

Ini topik yang surprisingly rumit di programming. Null (atau None, nil, null) artinya “variabel ini ada, tapi isinya nggak ada.”

# Python
data = None
if data is None:
    print("Belum ada data")

// JavaScript — punya null DAN undefined
let a = null;        // sengaja dikosongin
let b;               // undefined — belum diisi sama sekali

// Rust — nggak punya null! Pake Option
let data: Option<i32> = None;
match data {
    Some(nilai) => println!("Ada isinya: {}", nilai),
    None => println!("Kosong"),
}

Kenapa Rust (dan beberapa bahasa modern kayak TypeScript) ngehindarin null? Karena null jadi sumber error paling terkenal: NullPointerException. Tony Hoare — penemu null — bahkan nyebut ini “billion-dollar mistake”.

Bahasa modern makin pilih Option / Maybe / Optional — pola yang memaksa programmer buat nge-handle kasus “mungkin kosong” secara eksplisit. Lebih ribet nulisnya, tapi lebih aman.

Tipe data di level memori

Biar lebih greget, ini gimana tipe data yang sama beda ukuran di memori:

Tipe	Ukuran (64-bit)	Range nilai
int8 (Rust) / byte (Java)	1 byte	-128 s.d. 127
int32 / int (Java)	4 byte	~ -2.1M s.d. 2.1M
int64 / long (Java)	8 byte	~ ±9.2 quintillion
float32 (Rust) / float (Java)	4 byte	~ 7 digit presisi
float64 / double (Java)	8 byte	~ 15 digit presisi
bool	1 byte	true / false
char (Rust)	4 byte (Unicode)	Satu karakter apapun

Kenapa penting? Karena kalau kamu bikin aplikasi yang pegang jutaan data, milih int8 daripada int64 bisa hemat 6 MB per juta data. Di embedded device atau game dengan jutaan entitas, ini beda banget. Makanya Rust dan Zig kasih kontrol penuh soal ukuran integer.

Kesimpulan

Aspek	Intinya
Variabel	Kotak penyimpanan berlabel — tempat nyimpen data sementara
Tipe data	Aturan yang nentuin operasi apa yang valid buat suatu data
Static typing	Tipe ditentukan di awal, nggak bisa berubah — lebih aman, lebih cepat
Dynamic typing	Tipe fleksibel, ganti kapan aja — lebih cepat nulis, lebih riskan
Strong typing	Tolak konversi otomatis — lebih ketat, lebih aman
Weak typing	Konversi otomatis — praktis, tapi jebakan batman
Null handling	Zaman dulu: null → error 💥. Zaman now: Option / Optional → aman ✅

Tipe data dan variabel adalah fondasi dari semua kode yang kamu tulis. Paham konsep ini — plus gimana bahasa yang berbeda menanganinya — bakal ngasih kamu perspektif yang jauh lebih dalam soal gimana kode dieksekusi dari awal.

Next: Kalau udah paham tipe data, waktunya belajar Control Flow — if, for, while, dan switch — yang bakal kita bahas di artikel berikutnya. Stay tuned! 🚀