Belajar Rust dari Nol: Panduan Lengkap untuk Pemula

Rust adalah bahasa pemrograman modern yang dirancang untuk keamanan, performa, dan konkurensi. Dikembangkan oleh Mozilla, Rust menjadi salah satu bahasa yang paling dicintai oleh developer. Artikel ini akan membawa kamu belajar Rust dari nol.

Mengapa Belajar Rust?

Rust menawarkan kombinasi langka antara performa tinggi seperti C/C++ dan keamanan memori tanpa garbage collector. Rust mencegah bug umum seperti null pointer dereference, buffer overflow, dan data race saat compile time, bukan runtime.

Rust cocok untuk system programming, web backend, CLI tools, embedded systems, dan WebAssembly. Perusahaan besar seperti Dropbox, Cloudflare, dan Discord menggunakan Rust di production.

Instalasi

Cara termudah menginstal Rust adalah melalui rustup:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Verifikasi instalasi:

rustc --version

Cargo, package manager bawaan Rust, sudah termasuk dalam rustup.

Program Pertama

Buat project baru:

cargo new hello_rust
cd hello_rust

Buka file src/main.rs, isinya:

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

Jalankan dengan cargo run. Fungsi main adalah entry point, dan println! adalah macro untuk mencetak teks.

Variabel dan Tipe Data

Variabel bersifat immutable secara default. Gunakan mut jika perlu diubah:

fn main() {
let nama = "Erlkim";
let umur = 25;
let mut skor = 100;
println!("Skor awal: {}", skor);
skor = 150;
println!("Skor baru: {}", skor);
println!("Nama: {}, Umur: {}", nama, umur);
}

Tipe data dasar: integer (i32, u32), float (f64), bool, dan char:

fn main() {
let angka: i32 = 42;
let desimal: f64 = 3.14;
let aktif: bool = true;
let huruf: char = 'R';
println!("{}, {}, {}, {}", angka, desimal, aktif, huruf);
}

Fungsi

Fungsi didefinisikan dengan fn. Tipe return ditulis setelah tanda panah:

fn tambah(a: i32, b: i32) -> i32 {
a + b
}


fn sapa(nama: &str) {
println!("Halo, {}!", nama);
}


fn main() {
let hasil = tambah(10, 20);
println!("10 + 20 = {}", hasil);
sapa("Erlkim");
}

Ekspresi terakhir tanpa titik koma menjadi nilai return. Ini ciri khas Rust.

Control Flow

if di Rust adalah expression yang bisa mengembalikan nilai:

fn main() {
let angka = 42;
if angka > 100 {
println!("Angka besar");
} else if angka > 10 {
println!("Angka sedang");
} else {
println!("Angka kecil");
}
let status = if angka > 0 { "positif" } else { "negatif" };
println!("Status: {}", status);
}

Loop ada tiga jenis: loop, while, dan for:

fn main() {
for i in 1..=5 {
println!("Iterasi ke-{}", i);
}
let mut x = 0;
while x < 3 {
println!("x = {}", x);
x += 1;
}
}

Struct dan Method

Struct digunakan untuk mengelompokkan data. Method didefinisikan di dalam blok impl:

struct Mahasiswa {
        nama: String,
        umur: u32,
        ipk: f64,
    }

    impl Mahasiswa {
        fn baru(nama: &str, umur: u32, ipk: f64) -> Self {
            Mahasiswa { nama: nama.to_string(), umur, ipk }
        }

        fn info(&self) {
            println!("{} ({}), IPK: {:.2}", self.nama, self.umur, self.ipk);
        }

        fn lulus(&self) -> bool {
            self.ipk >= 2.5
        }
    }

    fn main() {
        let mhs = Mahasiswa::baru("Erlkim", 21, 3.75);
        mhs.info();
        if mhs.lulus() {
            println!("Selamat, kamu lulus!");
        }
    }

Enum dan Pattern Matching

Enum di Rust sangat powerful karena setiap variant bisa membawa data:

enum Pesan {
        Teks(String),
        Gerak { x: f64, y: f64 },
        Keluar,
    }

    fn proses_pesan(pesan: Pesan) {
        match pesan {
            Pesan::Teks(teks) => println!("Pesan: {}", teks),
            Pesan::Gerak { x, y } => println!("Pindah ke ({}, {})", x, y),
            Pesan::Keluar => println!("Keluar dari aplikasi"),
        }
    }

    fn main() {
        proses_pesan(Pesan::Teks(String::from("Halo Rust!")));
        proses_pesan(Pesan::Gerak { x: 10.0, y: 20.0 });
        proses_pesan(Pesan::Keluar);
    }

Ownership dan Borrowing

Ini fitur paling unik dari Rust. Setiap nilai punya satu owner, dan ketika owner keluar scope, nilai tersebut di-drop:

fn main() {
        let s1 = String::from("Hello");
        let s2 = s1;
        println!("{}", s2);
    }

Gunakan tanda & untuk borrowing agar nilai asli tetap bisa digunakan:

fn hitung_panjang(s: &String) -> usize {
        s.len()
    }

    fn main() {
        let teks = String::from("Rust adalah bahasa yang hebat");
        let panjang = hitung_panjang(&teks);
        println!("{} karakter", panjang);
    }

Error Handling

Rust tidak punya exception. Sebagai gantinya menggunakan Result:

use std::fs;

    fn baca_file(path: &str) -> Result<String, std::io::Error> {
        fs::read_to_string(path)
    }

    fn main() {
        match baca_file("data.txt") {
            Ok(isi) => println!("{}", isi),
            Err(e) => println!("Error: {}", e),
        }
    }

Langkah Selanjutnya

Setelah menguasai dasar Rust, coba bangun project nyata. Beberapa ide: CLI tool dengan library clap, web API dengan framework Axum, atau game sederhana dengan macroquad.

Sumber belajar terbaik: The Rust Book di doc.rust-lang.org, Rustlings untuk latihan interaktif, dan Exercism untuk tantangan coding. Selamat belajar Rust!