Belajar Pengaturcaraan Rust · Pelajaran

Enum dengan Data

Lampirkan nilai pada varian.

Pelajaran 3 daripada 413 langkah

Enum dengan Data ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Belajar Pengaturcaraan Rust, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 4 pelajaran.

Varian Boleh Menyimpan Data

Setakat ini, varian kita hanyalah nama. Dalam Rust, varian juga boleh membawa data di dalam kurungan.

Ini membolehkan satu enum menerangkan kedua-dua jenis nilai dan nilai itu sendiri.

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

Varian dengan Satu Nilai

Letakkan jenis di dalam kurungan untuk melampirkan satu bahagian data pada varian.

Di sini, Celsius(f64) bermaksud varian Celsius menyimpan nombor f64. Anda membekalkan nombor itu semasa membina nilai tersebut.

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

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

Varian dengan Beberapa Nilai

Varian boleh menyimpan beberapa nilai yang dipisahkan dengan koma.

Move(i32, i32) menyimpan dua integer, mungkin koordinat x dan y. Anda menghantar kedua-duanya semasa menciptanya.

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, namakannya dalam corak. Nama tersebut menjadi pemboleh ubah yang boleh anda gunakan dalam lengan itu.

Di sini, Shape::Circle(r) mengikat jejari yang disimpan kepada 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 kepada nama, anda boleh menggunakannya dalam pengiraan seperti mana-mana pemboleh ubah.

Atur cara ini memadankan bentuk dan mengira luasnya, lalu mengembalikan hasil daripada 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 Berbeza bagi Setiap Varian

Setiap varian boleh menyimpan bentuk data yang berbeza, dan sesetengahnya tidak menyimpan apa-apa data.

Fleksibiliti inilah yang menjadikan enum begitu ekspresif: satu jenis boleh memodelkan banyak kes yang berbeza.

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

Varian Seperti Struct

Sesuatu varian boleh menggunakan medan bernama dengan pendakap keriting, sama seperti struct. Ini menjadikan maksud setiap medan jelas.

Anda membinanya dengan menamakan setiap medan, kemudian memadankannya 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),
    }
}

Rentetan dalam Varian

Varian boleh menyimpan data milikan seperti String. Pemadanan memberi anda akses kepada teks tersebut.

Nota: pemadanan mengikut nilai akan memindahkan data keluar, dan ini tidak menjadi masalah di sini kerana kita menggunakannya serta-merta.

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 Standard

Option<T> terbina dalam Rust ialah enum yang mengandungi data: Some(T) menyimpan nilai, manakala None tidak menyimpan apa-apa.

Beginilah Rust mewakili "mungkin ada nilai" tanpa menggunakan null. Anda memadankannya sama seperti enum 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, kemudian menukar bacaan Celsius kepada Fahrenheit dalam match.

Cuba ubah varian atau nilainya, kemudian jalankan semula.

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);
}

Bila Hendak Menggunakan Varian Data

Gunakan varian pembawa data apabila setiap kes sememangnya disertai maklumat tambahan.

Circle memerlukan jejari.
Mesej Write memerlukan teksnya.
Move memerlukan koordinat.

Menggabungkan data dengan varian memastikan maklumat yang berkaitan kekal bersama dan selamat mengikut jenis.

Semakan Pantas

Semak pemahaman anda tentang enum yang membawa data.

Jawab dalam pelajaran interaktif

Ulang Kaji

Anda telah mempelajari bahawa varian enum boleh membawa data: satu nilai, beberapa nilai, medan bernama seperti struct, atau tiada nilai langsung.

Anda membaca data itu dengan menamakannya dalam corak match, seperti Circle(r). Jenis Option standard berfungsi dengan cara yang sama. Seterusnya, anda akan memperhalus pemadanan dengan pengawal dan pengikatan.

Percuma untuk bermula

Pelajari Rust dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 39
Pelajaran: 144

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Enum dengan Data” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Enum dengan Data”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Enum dengan Data”?

Lampirkan nilai pada varian. Anda berlatih Belajar Pengaturcaraan Rust menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Belajar Pengaturcaraan Rust?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Belajar Pengaturcaraan Rust di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Enum dengan Data” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Belajar Pengaturcaraan Rust ini?

Ya. Setiap pelajaran Belajar Pengaturcaraan Rust menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Belajar Pengaturcaraan Rust