Sintaks Dasar, Variabel, dan Tipe Data

2.1. Tujuan pembelajaran

Setelah menyelesaikan modul ini, peserta mampu:

1. Memahami struktur dasar program Rust.
2. Membuat variabel immutable dan mutable.
3. Mengenali konstanta dan aturan penamaan identifier.
4. Memilih tipe data sesuai kebutuhan.
5. Memahami type inference dan type annotation.
6. Menggunakan string, tuple, array, dan tipe data numerik.
7. Membaca kesalahan compiler sederhana dan memperbaikinya.

2.2. Struktur dasar program Rust

Program executable Rust umumnya memiliki fungsi main() sebagai titik masuk.

fn main() { println!("Hello, Rust!");}

Penjelasan kode:

SintaksArtifnKata kunci untuk mendefinisikan fungsimainFungsi utama program executable()Tempat parameter fungsi{}Blok kodeprintln!Macro untuk mencetak teks dan mengakhiri output dengan baris baru;Mengakhiri statement

Rust membedakan statement dan expression. Perbedaan ini akan menjadi sangat penting ketika mempelajari fungsi dan percabangan.

Contoh statement:

let price = 10000;

Contoh expression:

let total = 10000 + 5000;

Expression menghasilkan nilai yang dapat digunakan oleh kode lain.

2.3. Variabel immutable dan mutable

Secara default, variabel yang dideklarasikan menggunakan let bersifat immutable, artinya nilainya tidak dapat diubah setelah binding dibuat.

fn main() { let name = "Dedi"; println!("Name: {name}");}

Jika mencoba mengubah nilai variabel tersebut:

fn main() { let age = 30; age = 31;
println!("Age: {age}");}

Compiler akan menolak kode tersebut karena age tidak dideklarasikan sebagai mutable.

Untuk mengizinkan perubahan nilai, gunakan mut.

fn main() { let mut age = 30;
age = 31;
println!("Age: {age}");}

Output:

31

Prinsip penting: gunakan variabel immutable jika nilainya tidak perlu berubah. Tambahkan mut hanya ketika perubahan nilai memang dibutuhkan.

Pendekatan ini membantu membuat perilaku program lebih mudah dipahami dan mengurangi perubahan keadaan yang tidak disengaja.

2.4. Konstanta dengan const

Konstanta digunakan untuk menyimpan nilai yang ditentukan secara konstan dan harus memiliki anotasi tipe eksplisit.

const TAX_RATE: f64 = 0.11;
fn main() { let price: f64 = 100_000.0; let tax = price * TAX_RATE;
println!("Tax: {tax}");}

Output:

Tax: 11000

Perbedaan let dan const:

AspekletconstTipe wajib ditulisTidakYaNilai dapat diubah melalui mutBisaTidakLingkupSesuai tempat deklarasiDapat digunakan sesuai cakupan deklarasiNilaiDapat berupa hasil perhitungan runtimeHarus berupa nilai yang memenuhi aturan constant evaluationKonvensi namasnake_caseSCREAMING_SNAKE_CASE

Konstanta tidak sama dengan variabel immutable biasa. Konstanta harus dapat dievaluasi pada waktu kompilasi.

2.5. Shadowing

Rust mendukung shadowing, yaitu mendeklarasikan binding baru dengan nama yang sama.

fn main() { let value = "100"; let value: i32 = value.parse().expect("Invalid number");
println!("{value}");}

Output:

100

Pada contoh tersebut, value pertama adalah string, sedangkan value kedua adalah bilangan bulat.

Shadowing berbeda dari mutability. Shadowing membuat binding baru, sementara mut memungkinkan nilai pada binding mutable diubah sesuai aturan tipe datanya.

2.6. Aturan penamaan

Konvensi umum Rust adalah:

1. Variabel dan fungsi: snake_case
2. Konstanta: SCREAMING_SNAKE_CASE
3. Struct, enum, dan trait: UpperCamelCase

Contoh:

const MAX_RETRY: u32 = 3;
fn calculate_total(unit_price: u64, quantity: u32) -> u64 { unit_price * u64::from(quantity)}
fn main() { let product_price: u64 = 25_000; let quantity: u32 = 4;
let total = calculate_total(product_price, quantity);
println!("Total: {total}");}

Output:

Total: 100000

Contoh ini juga menunjukkan bahwa konversi tipe numerik perlu dilakukan secara eksplisit ketika tipe parameter berbeda.

2.7. Tipe data dasar Rust

Rust memiliki tipe data scalar dan compound.

A. Integer

Integer digunakan untuk menyimpan bilangan bulat.

TipeRentangi8−128 hingga 127i16−32.768 hingga 32.767i32Bilangan bulat bertanda 32-biti64Bilangan bulat bertanda 64-biti128Bilangan bulat bertanda 128-bitu80 hingga 255u16Bilangan bulat tidak bertanda 16-bitu32Bilangan bulat tidak bertanda 32-bitu64Bilangan bulat tidak bertanda 64-bitu128Bilangan bulat tidak bertanda 128-bitisizeUkuran mengikuti target platformusizeUkuran mengikuti target platform

Contoh:

fn main() { let age: u8 = 30; let quantity: u32 = 150; let population: u64 = 280_000_000;
println!("Age: {age}"); println!("Quantity: {quantity}"); println!("Population: {population}");}

Pilih tipe berdasarkan domain data dan rentang nilainya. Jangan menggunakan tipe integer kecil untuk data yang mungkin melampaui kapasitasnya.

B. Floating-point

Rust menyediakan dua tipe floating-point:

1. f32: floating-point 32-bit.
2. f64: floating-point 64-bit dan tipe default untuk literal desimal yang tidak diberi anotasi lain.

fn main() { let temperature: f32 = 36.5; let product_price: f64 = 125_000.50;
println!("Temperature: {temperature}"); println!("Price: {product_price}");}

Untuk perhitungan uang, floating-point dapat menimbulkan persoalan presisi. Sistem keuangan umumnya lebih aman menggunakan representasi integer dalam satuan terkecil atau tipe desimal yang sesuai dengan kebutuhan domain.

C. Boolean

Boolean hanya memiliki dua nilai, true dan false.

fn main() { let is_active: bool = true; let is_paid: bool = false;
println!("Active: {is_active}"); println!("Paid: {is_paid}");}

Boolean sering digunakan dalam kondisi, validasi, status, dan hasil perbandingan.

D. Character

Tipe char menyimpan satu Unicode scalar value dan menggunakan tanda petik tunggal.

fn main() { let grade: char = 'A'; let symbol: char = '✓'; let emoji: char = '🚀';
println!("{grade}"); println!("{symbol}"); println!("{emoji}");}

Satu char bukan berarti satu byte. Karakter Unicode dapat memiliki representasi UTF-8 dengan panjang beberapa byte.

E. String dan &str

Rust memiliki dua tipe yang penting untuk teks.

&str adalah string slice, biasanya digunakan untuk merepresentasikan referensi ke teks.

String adalah tipe string yang dimiliki program dan dapat tumbuh atau berubah.

fn main() { let language: &str = "Rust"; let mut framework = String::from("Axum");
framework.push_str(" Web");
println!("Language: {language}"); println!("Technology: {framework}");}

Output:

Language: RustTechnology: Axum Web

Gunakan String ketika aplikasi perlu memiliki dan memodifikasi teks. Gunakan &str untuk menerima atau membaca teks tanpa harus mengambil kepemilikan string baru.

Konsep kepemilikan akan dipelajari lebih mendalam pada modul ownership dan borrowing.

2.8. Compound data types

Tuple

Tuple menggabungkan beberapa nilai yang dapat memiliki tipe berbeda.

fn main() { let employee: (&str, u32, bool) = ("Dedi", 30, true);
println!("Name: {}", employee.0); println!("Age: {}", employee.1); println!("Active: {}", employee.2);}

Tuple cocok untuk mengelompokkan sejumlah nilai dengan struktur tetap. Untuk domain yang lebih kompleks, struct biasanya lebih mudah dibaca.

Array

Array menyimpan sejumlah elemen dengan tipe yang sama dan panjang tetap.

fn main() { let scores: [u32; 4] = [80, 90, 85, 95];
println!("First score: {}", scores[0]); println!("Total elements: {}", scores.len());}

Indeks array dimulai dari nol. Akses indeks yang berada di luar batas dapat menyebabkan panic ketika program dijalankan.

Untuk koleksi yang panjangnya dapat berubah, Rust menyediakan Vec<T>, yang akan dibahas pada materi lanjutan.

2.9. Type inference dan type annotation

Rust dapat menyimpulkan tipe berdasarkan nilai dan konteks.

fn main() { let quantity = 10; let price = 25000.0; let is_available = true;
println!("{quantity} {price} {is_available}");}

Compiler dapat menyimpulkan tipe variabel tersebut tanpa deklarasi tipe eksplisit.

Namun, anotasi tipe diperlukan jika konteks tidak cukup untuk menentukan tipe atau ketika kita ingin membuat maksud program lebih jelas.

fn main() { let quantity: u32 = 10; let price: f64 = 25_000.0;
let total = price * f64::from(quantity);
println!("Total: {total}");}

Anotasi tipe sangat berguna pada batas API, model domain, dan kode yang memerlukan kontrak tipe yang eksplisit.

2.10. Kesalahan umum pemula

KesalahanPenyebabPerbaikanMengubah variabel immutableTidak menggunakan mutTambahkan mut bila perubahan dibutuhkanTipe tidak cocokOperasi menggunakan tipe berbedaLakukan konversi tipe yang tepatOverflow integerNilai melampaui kapasitas tipePilih tipe yang sesuai dan tangani batas nilaiSalah membedakan String dan &strKepemilikan serta borrowing belum dipahamiPelajari karakteristik masing-masing tipeAkses indeks di luar batasIndeks tidak validValidasi indeks atau gunakan akses aman seperti .get()

2.11. Praktik mandiri

Buat program bernama employee_profile dengan persyaratan berikut:

1. Menyimpan nama sebagai String.
2. Menyimpan umur sebagai integer.
3. Menyimpan status aktif sebagai bool.
4. Menyimpan gaji sebagai integer dalam satuan rupiah.
5. Menghitung gaji tahunan dengan asumsi gaji bulanan tetap.
6. Menampilkan semua informasi.

Contoh kerangka:

fn main() { let name = String::from("Dedi"); let age: u8 = 30; let is_active: bool = true; let monthly_salary: u64 = 8_000_000;
let annual_salary = monthly_salary * 12;
println!("Employee: {name}"); println!("Age: {age}"); println!("Active: {is_active}"); println!("Annual salary: {annual_salary}");}

Catatan: program ini merupakan latihan tipe data, bukan perhitungan payroll lengkap.

Kuis RUST-02

1. Apa sifat default variabel yang dibuat dengan let?

Mutable

Immutable

Selalu konstan pada waktu kompilasi

2. Kata kunci untuk membuat variabel mutable adalah...

change

var

mut

3. Tipe mana yang lazim digunakan untuk menyimpan true atau false?

bool

char

u32

4. Apa perbedaan utama String dengan &str?

String memiliki data string, sedangkan &str adalah string slice

Keduanya selalu dapat diubah

&str selalu berada di heap

5. Berapa indeks elemen pertama pada array Rust?

1

0

-1