Learn Rust Coding · Pelajaran

Enum dengan Data

Tambahkan nilai pada varian.

Enum dengan Data adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Varian Dapat Menyimpan Data

Sejauh ini, varian kita hanya berupa nama. Di Rust, varian juga dapat membawa data di dalam tanda kurung.

Dengan demikian, satu enum dapat menjelaskan jenis nilai sekaligus nilainya.

enum Message {
    Quit,
    Move(i32, i32),
    Write(String),
}

Varian dengan Satu Nilai

Letakkan sebuah tipe di dalam tanda kurung untuk menambahkan satu bagian data ke varian.

Di sini Celsius(f64) berarti varian Celsius menyimpan angka f64. Anda memberikan angka tersebut saat membuat nilainya.

enum Temperature {
    Celsius(f64),
    Fahrenheit(f64),
}

fn main() {
    let t = Temperature::Celsius(21.5);
    println!("Created a temperature");
}

Varian dengan Beberapa Nilai

Sebuah varian dapat menyimpan beberapa nilai yang dipisahkan dengan koma.

Move(i32, i32) menyimpan dua bilangan bulat, mungkin koordinat x dan y. Anda memberikan keduanya saat membuat varian tersebut.

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
}

fn main() {
    let r = Shape::Rectangle(3.0, 4.0);
    println!("Made a rectangle");
}

Mengekstrak Data dengan match

Untuk membaca data di dalam varian, beri nama data tersebut dalam pola. Nama-nama itu menjadi variabel yang dapat Anda gunakan di dalam lengan tersebut.

Di sini Shape::Circle(r) mengikat radius yang disimpan ke r.

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
}

fn main() {
    let s = Shape::Circle(2.0);
    match s {
        Shape::Circle(r) => println!("radius {}", r),
        Shape::Rectangle(w, h) => println!("{} x {}", w, h),
    }
}

Menggunakan Nilai yang Diikat

Setelah data diikat ke sebuah nama, Anda dapat menggunakannya dalam perhitungan seperti variabel apa pun.

Program ini mencocokkan sebuah bentuk dan menghitung luasnya, lalu mengembalikan hasilnya dari match.

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
}

fn main() {
    let s = Shape::Rectangle(3.0, 4.0);
    let area = match s {
        Shape::Circle(r) => 3.14 * r * r,
        Shape::Rectangle(w, h) => w * h,
    };
    println!("area = {}", area);
}

Data yang Berbeda untuk Setiap Varian

Setiap varian dapat menyimpan bentuk data yang berbeda, dan beberapa varian dapat tidak menyimpan data sama sekali.

Fleksibilitas inilah yang membuat enum begitu ekspresif: satu tipe dapat memodelkan banyak kasus yang berbeda.

enum Message {
    Quit,
    Move(i32, i32),
    Write(String),
}

Varian Bergaya Struct

Sebuah varian dapat menggunakan bidang bernama dengan kurung kurawal, sama seperti struct. Dengan begitu, arti setiap bidang menjadi jelas.

Anda membuatnya dengan menamai setiap bidang, lalu mencocokkannya dengan cara yang sama.

enum Event {
    Click { x: i32, y: i32 },
    KeyPress(char),
}

fn main() {
    let e = Event::Click { x: 10, y: 20 };
    match e {
        Event::Click { x, y } => println!("click at {},{}", x, y),
        Event::KeyPress(c) => println!("key {}", c),
    }
}

String dalam Varian

Varian dapat menyimpan data yang dimiliki seperti String. Pencocokan memberi Anda akses ke teks tersebut.

Catatan: pencocokan berdasarkan nilai memindahkan data keluar, dan itu tidak masalah di sini karena kita langsung menggunakannya.

enum Message {
    Write(String),
    Quit,
}

fn main() {
    let m = Message::Write(String::from("hello"));
    match m {
        Message::Write(text) => println!("text: {}", text),
        Message::Quit => println!("bye"),
    }
}

Enum Option Standar

Option<T> bawaan Rust adalah enum yang membawa data: Some(T) menyimpan sebuah nilai, sedangkan None tidak menyimpan apa pun.

Inilah cara Rust merepresentasikan "mungkin ada nilai" tanpa menggunakan null. Anda mencocokkannya sama seperti enum buatan Anda sendiri.

fn main() {
    let maybe: Option<i32> = Some(5);
    match maybe {
        Some(n) => println!("got {}", n),
        None => println!("nothing"),
    }
}

Menggabungkan Semuanya

Program lengkap ini memodelkan suhu, lalu mengonversi pembacaan Celsius ke Fahrenheit di dalam match.

Cobalah mengubah varian atau nilainya, lalu jalankan kembali.

enum Temperature {
    Celsius(f64),
    Fahrenheit(f64),
}

fn main() {
    let t = Temperature::Celsius(25.0);
    let f = match t {
        Temperature::Celsius(c) => c * 9.0 / 5.0 + 32.0,
        Temperature::Fahrenheit(f) => f,
    };
    println!("{} F", f);
}

Kapan Menggunakan Varian Data

Gunakan varian yang membawa data ketika setiap kasus secara alami disertai informasi tambahan.

Circle memerlukan radius.
Pesan Write memerlukan teksnya.
Move memerlukan koordinat.

Menggabungkan data dengan varian menjaga informasi yang berkaitan tetap bersama dan aman secara tipe.

Pemeriksaan Singkat

Periksa pemahaman Anda tentang enum yang membawa data.

Ringkasan

Anda telah mempelajari bahwa varian enum dapat membawa data: satu nilai, beberapa nilai, bidang bernama seperti struct, atau tidak sama sekali.

Anda membaca data tersebut dengan menamainya dalam pola match, seperti Circle(r). Tipe standar Option bekerja dengan cara yang sama. Selanjutnya Anda akan menyempurnakan pencocokan dengan penjaga dan pengikatan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Enum dengan Data” gratis?

Ya — teks lengkap “Enum dengan Data” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Enum dengan Data”?

Tambahkan nilai pada varian. Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Enum dengan Data” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Learn Rust Coding