Tutorial Belajar Rust Dari Dasar, Borrow Checker, Hingga WebAssembly (Wasm)

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

rustc --version

cargo new app_laundry_cli
cd app_laundry_cli

use std::io; // Kita pinjem alat bawaan Rust buat nerima input dari keyboard

fn main() {
    println!("=====================================");
    println!("🔥 Selamat Datang di Kasir Rust 🔥");
    println!("=====================================");

    println!("Bro, masukin nama pelanggan hari ini:");

    // Bikin variabel 'String' kosong buat nampung nama
    // 'mut' artinya mutable (nilainya boleh diubah-ubah nanti)
    let mut nama_pelanggan = String::new();

    // Disini kita baca ketikan keyboard lu, terus dimasukin ke variabel tadi
    io::stdin()
        .read_line(&mut nama_pelanggan)
        .expect("Waduh, gagal baca input nih Bro!");

    // Nah, .trim() fungsinya buat ngebuang spasi kosong atau enter di akhir kata
    let nama = nama_pelanggan.trim();

    println!("-------------------------------------");
    // Di Rust, kalau mau masukin variabel ke teks, tinggal pake kurung kurawal {}
    println!("Halo, Bos {}! Cucian udah siap diproses.", nama);
    println!("Sistem aman, memori nggak bocor, gass terus!");
}

cargo run

fn main() {
    println!("===================================================");
    println!("🧪 Kalkulator Resep Sabun Cuci Piring 🧪");
    println!("===================================================");

    // 1. ARRAY (Ngelist Bahan)
    // Ingat, array di Rust ukurannya tetap. Kita masukin 3 bahan utama.
    let bahan_baku = ["MES", "Texapon", "LABS"]; 

    println!("Bahan utama yang kita pakai hari ini:");
    println!("1. {}", bahan_baku[0]);
    println!("2. {}", bahan_baku[1]);
    println!("3. {}", bahan_baku[2]);
    println!("---------------------------------------------------");

    // 2. VARIABEL IMMUTABLE (Nilai Tetap)
    // Tipe data 'f64' itu buat angka desimal (pecahan).
    let target_produksi_liter: f64 = 50.0; 

    // 3. VARIABEL MUTABLE (Nilai Bisa Berubah)
    // Pakai kata 'mut' karena stok awal nol, terus nanti mau kita isi nilainya.
    let mut stok_texapon_kg: f64 = 0.0;

    // Kita ubah nilai variabel mutable-nya (misal butuh 5% dari target produksi)
    stok_texapon_kg = target_produksi_liter * 0.05; 

    println!("Target Produksi: {} Liter", target_produksi_liter);
    println!("Kebutuhan {} yang harus disiapin: {} Kg", bahan_baku[1], stok_texapon_kg);
    
    println!("===================================================");
    println!("Sistem kalkulasi sukses. Nggak ada memori yang bocor!");
}

fn main() {
    println!("=======================================");
    println!("🕵️‍♂️ Latihan Borrow Checker Rust 🕵️‍♂️");
    println!("=======================================\n");

    // 1. CONTOH OWNERSHIP (Kepemilikan)
    let pelanggan_a = String::from("Raja Digital"); 
    
    // Data dipindah (di-Move) ke pelanggan_b. 
    // Sekarang pelanggan_a udah 'kosong' dan nggak valid lagi!
    let pelanggan_b = pelanggan_a; 

    // Kalau lu iseng nulis: println!("{}", pelanggan_a); 
    // Compiler Rust bakal ngamuk dan kode lu GAGAL jalan.
    println!("Data sekarang dipegang oleh: {}", pelanggan_b);
    println!("---------------------------------------");

    // 2. CONTOH BORROWING (Peminjaman dengan tanda &)
    let nota_cucian = String::from("Cuci Kilat 5 Kg");

    // Kita pakai tanda & (Ampersand) buat 'minjem' data tanpa ngambil hak miliknya.
    let karyawan_1 = &nota_cucian;
    let karyawan_2 = &nota_cucian;

    // Karena cuma minjem buat DIBACA, dua karyawan bisa akses barengan. Aman!
    println!("Karyawan 1 baca: {}", karyawan_1);
    println!("Karyawan 2 baca: {}", karyawan_2);
    
    // Pemilik asli (nota_cucian) juga masih bisa dipakai karena hak miliknya nggak hilang.
    println!("Pemilik asli datanya tetap: {}", nota_cucian);
    
    println!("=======================================");
    println!("Lulus ujian satpam memori! Gass lanjut!");
}

// 1. KITA BIKIN BLUEPRINT-NYA DULU (Struct)
struct PesananLaundry {
    id_order: u32,
    nama_pelanggan: String,
    berat_kg: f64,
    layanan_kilat: bool, // true kalau kilat, false kalau reguler
}

// 2. KITA BIKIN FUNGSI KHUSUS BUAT STRUCT INI (Impl)
impl PesananLaundry {
    fn cetak_struk(&self) {
        println!("----------------------------------");
        println!("🧾 STRUK LAUNDRY - ORDER #{}", self.id_order);
        println!("----------------------------------");
        println!("Pelanggan : {}", self.nama_pelanggan);
        println!("Berat     : {} Kg", self.berat_kg);
        
        if self.layanan_kilat {
            println!("Layanan   : EXPRESS ⚡ (Besok Jadi)");
        } else {
            println!("Layanan   : REGULER 🐢 (Santai Aja)");
        }
        println!("----------------------------------\n");
    }
}

fn main() {
    println!("==================================");
    println!("Sistem Manajemen Raja Digital ID");
    println!("==================================\n");

    // 3. KITA ISI FORMULIRNYA (Bikin Instance dari Struct)
    let orderan_pertama = PesananLaundry {
        id_order: 101,
        nama_pelanggan: "Si Bos Kopi".to_string(), 
        berat_kg: 3.5,
        layanan_kilat: true,
    };

    let orderan_kedua = PesananLaundry {
        id_order: 102,
        nama_pelanggan: "Anak Kosan".to_string(),
        berat_kg: 5.0,
        layanan_kilat: false,
    };

    // 4. JALANIN FUNGSINYA
    orderan_pertama.cetak_struk();
    orderan_kedua.cetak_struk();
}

use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

fn main() {
    println!("=============================================");
    println!("🚀 Simulasi Multithreading Raja Digital ID 🚀");
    println!("=============================================\n");

    // 1. SIAPIN DATA DAN MUTEX
    let total_pengunjung = Arc::new(Mutex::new(0));
    let mut kumpulan_thread = vec![];

    println!("Mulai ngebuka 10 pintu masuk buat pengunjung...");
    
    for i in 1..=10 {
        let tiket_masuk = Arc::clone(&total_pengunjung);

        let tugas = thread::spawn(move || {
            thread::sleep(Duration::from_millis(10));
            let mut data_dikunci = tiket_masuk.lock().unwrap();
            
            *data_dikunci += 1;
            println!("Thread {} berhasil masuk! Total pengunjung sekarang: {}", i, *data_dikunci);
        });

        kumpulan_thread.push(tugas);
    }

    for tugas in kumpulan_thread {
        tugas.join().unwrap();
    }

    println!("\n=============================================");
    println!("Semua tugas selesai!");
    println!("Total Pengunjung Final: {}", *total_pengunjung.lock().unwrap());
}

fn main() {
    let nama_dicari = "Anak Kosan";
    
    println!("🔍 Mencari data '{}'...", nama_dicari);
    match cari_pelanggan(nama_dicari) {
        Some(nama) => println!("✅ Ketemu nih: Bos {}", nama),
        None => println!("❌ Waduh, data pelanggan '{}' nggak ada di sistem!", nama_dicari),
    }

    let saldo_dompet = 50000;
    let tagihan_laundry = 75000;

    println!("💸 Coba bayar tagihan Rp{} dengan saldo Rp{}...", tagihan_laundry, saldo_dompet);
    match proses_pembayaran(saldo_dompet, tagihan_laundry) {
        Ok(kembalian) => println!("✅ Pembayaran sukses! Kembalian lu: Rp{}", kembalian),
        Err(pesan_error) => println!("❌ Transaksi Ditolak: {}", pesan_error),
    }
}

fn cari_pelanggan<'a>(nama_target: &'a str) -> Option<&'a str> {
    let database = ["Si Bos Kopi", "Raja Digital", "Juragan Laundry"];
    for &pelanggan in database.iter() {
        if pelanggan == nama_target {
            return Some(pelanggan); 
        }
    }
    None 
}

fn proses_pembayaran(saldo: i32, tagihan: i32) -> Result<i32, String> {
    if saldo >= tagihan {
        Ok(saldo - tagihan) 
    } else {
        Err(String::from("Saldo lu kurang Bro, ngutang dulu gih!")) 
    }
}

use std::collections::HashMap;

fn main() {
    // 1. VECTOR (Daftar Belanjaan yang bisa nambah terus)
    let mut keranjang_belanja: Vec<String> = Vec::new();
    keranjang_belanja.push(String::from("Sabun Cuci Piring Jeruk Nipis 1L"));
    keranjang_belanja.push(String::from("Bahan MES 1Kg"));

    // 2. HASHMAP (Daftar Harga pakai sistem Key-Value)
    let mut daftar_harga = HashMap::new();
    daftar_harga.insert("Sabun Cuci Piring Jeruk Nipis 1L", 15000);
    daftar_harga.insert("Bahan MES 1Kg", 25000);

    // 3. MENGGABUNGKAN KEDUANYA
    let mut total_bayar = 0;
    for barang in &keranjang_belanja {
        match daftar_harga.get(barang.as_str()) {
            Some(harga) => {
                println!("- {} : Rp{}", barang, harga);
                total_bayar += harga;
            },
            None => println!("- {} : Harga belum diatur!", barang),
        }
    }
}

enum StatusPesanan {
    MenungguPembayaran,
    SedangDikemas,
    SedangDikirim(String), // Enum bawa data resi!
    Selesai,
}

struct Orderan {
    id_order: u32,
    nama_pembeli: String,
    status: StatusPesanan,
}

fn cek_posisi_paket(order: &Orderan) {
    match &order.status {
        StatusPesanan::MenungguPembayaran => println!("Status: ⏳ Woi Bro, buruan transfer!"),
        StatusPesanan::SedangDikirim(resi) => println!("Status: 🚚 Udah jalan. Resi: {}", resi),
        _ => println!("Status Lainnya..."),
    }
}

[dependencies]
actix-web = "4.0"

use actix_web::{get, App, HttpResponse, HttpServer, Responder};

#[get("/")]
async fn halaman_utama() -> impl Responder {
    HttpResponse::Ok()
        .content_type("text/html; charset=utf-8")
        .body("<h1>🚀 Halo Bro! Server Rust Udah Nyala!</h1>")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new().service(halaman_utama)
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

[dependencies]
actix-web = "4.0"
serde = { version = "1.0", features = ["derive"] }

use actix_web::{get, web, App, HttpResponse, HttpServer, Responder};
use serde::{Deserialize, Serialize};
use std::sync::Mutex;

#[derive(Serialize, Deserialize, Clone)]
struct Produk { id: u32, nama: String, harga: u32, stok: u32 }

struct AppState { db_produk: Mutex<Vec<Produk>> }

#[get("/api/produk")]
async fn get_produk(data: web::Data<AppState>) -> impl Responder {
    let database = data.db_produk.lock().unwrap();
    HttpResponse::Ok().json(&*database) // Langsung jadi JSON!
}

<!DOCTYPE html>
<html lang="id">
<head>
    <title>Sistem Kasir Frontend</title>
</head>
<body>
    <h1>📦 Data Stok Gudang</h1>
    <button onclick="tarikDataAPI()">🔄 Segarkan Data JSON</button>
    <div id="etalase-produk"></div>

    <script>
        async function tarikDataAPI() {
            let response = await fetch("http://127.0.0.1:8080/api/produk");
            let dataJSON = await response.json();
            console.log(dataJSON);
        }
    </script>
</body>
</html>

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn hitung_diskon_grosir(jumlah_botol: i32, harga_satuan: i32) -> String {
    let total_awal = jumlah_botol * harga_satuan;
    let mut diskon = 0;

    if jumlah_botol >= 100 {
        diskon = total_awal * 20 / 100; // Diskon 20%
    }

    format!("Total Bayar: Rp{}", total_awal - diskon)
}

wasm-pack build --target web

use image::imageops::FilterType;
use std::time::Instant;

fn main() {
    let waktu_mulai = Instant::now();

    let gambar_mentah = image::open("sabun_raw.jpg").expect("File ilang!");
    let (lebar_asli, tinggi_asli) = gambar_mentah.dimensions();
    
    let target_lebar = 800;
    let target_tinggi = (tinggi_asli * target_lebar) / lebar_asli; 

    let gambar_kecil = gambar_mentah.resize(target_lebar, target_tinggi, FilterType::Lanczos3);
    gambar_kecil.save("sabun_optimized.jpg").expect("Gagal simpan!");

    println!("✅ Beres Bro! Dieksekusi dalam waktu {:?}", waktu_mulai.elapsed());
}