Learn Rust Coding · Pelajaran

Pencocokan Pola yang Ampuh

Kuasai ekspresi `match` dan konstruksi pencocokan pola lainnya untuk menangani varian data secara ringkas dan menyeluruh.

Pencocokan Pola yang Ampuh adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 3 dari 3. 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 3 pelajaran total.

Membuka Kekuatan Pencocokan Pola

Selamat datang di dunia pencocokan pola dalam Rust! Fitur yang kuat ini memungkinkan Anda mengendalikan alur program berdasarkan struktur data.

Alih-alih hanya memeriksa kesamaan, Anda dapat menguraikan nilai, mengekstrak komponennya, dan menjalankan kode tertentu untuk berbagai bentuk data.

Ini seperti pernyataan if/else atau switch dengan kemampuan super.
Memastikan kelengkapan: Anda harus menangani semua pola yang mungkin.
Membuat kode lebih mudah dibaca dan lebih tangguh.

Dasar-Dasar Ekspresi `match`

Inti dari pencocokan pola adalah ekspresi match. Ekspresi ini menerima sebuah nilai dan membandingkannya dengan serangkaian pola. Pola pertama yang cocok akan digunakan!

Setiap «lengan» ekspresi match terdiri dari sebuah pola dan kode yang dijalankan jika pola tersebut cocok.

enum Direction {
  North,
  East,
  South,
  West,
}

fn main() {
  let my_direction = Direction::North;

  match my_direction {
    Direction::North => println!("Going up!"),
    Direction::East => println!("Going right!"),
    Direction::South => println!("Going down!"),
    Direction::West => println!("Going left!"),
  }
}

Mencocokkan Literal dan Rentang

Anda dapat mencocokkan nilai literal tertentu (angka, karakter, boolean) atau menentukan rentang menggunakan ..=. Operator | memungkinkan pencocokan beberapa pola dalam satu lengan.

Ingat, pola diperiksa secara berurutan, dan kecocokan pertama yang ditemukan akan digunakan.

fn main() {
  let x = 7;

  match x {
    1 => println!("It's one!"),
    2 | 3 => println!("It's two or three!"),
    4..=8 => println!("It's between four and eight!"),
    _ => println!("It's something else!"), // Catch-all
  }

  let character = 'b';
  match character {
    'a'..='e' => println!("Early letter"),
    _ => println!("Other letter"),
  }
}

Menguraikan Struct

Pencocokan pola benar-benar sangat berguna saat menguraikan tipe data kompleks seperti struct. Anda dapat mengekstrak setiap bidang langsung ke dalam variabel di dalam lengan match.

Hal ini membuat pengaksesan data struct menjadi rapi dan ringkas, terutama saat mencocokkan nilai bidang tertentu.

struct Point {
  x: i32,
  y: i32,
}

fn main() {
  let p = Point { x: 0, y: 7 };

  match p {
    Point { x, y: 0 } => println!("On the X axis at {}", x),
    Point { x: 0, y } => println!("On the Y axis at {}", y),
    Point { x, y } => println!("Not on an axis: ({}, {})", x, y),
  }
}

Menguraikan Enum dengan Data

Enum dalam Rust dapat menyimpan data terkait. Pencocokan pola adalah cara utama untuk mengekstrak data ini dari sebuah varian enum.

Anda dapat menguraikan data langsung ke dalam variabel baru, sehingga isi setiap varian mudah digunakan.

enum Message {
  Quit,
  Move { x: i32, y: i32 },
  Write(String),
  ChangeColor(i32, i32, i32),
}

fn process_message(msg: Message) {
  match msg {
    Message::Quit => println!("Quit message."),
    Message::Move { x, y } => {
      println!("Move to x: {}, y: {}", x, y);
    }
    Message::Write(text) => println!("Text message: {}", text),
    Message::ChangeColor(r, g, b) => {
      println!("Color: R:{}, G:{}, B:{}", r, g, b);
    }
  }
}

fn main() {
  process_message(Message::Move { x: 10, y: 20 });
  process_message(Message::Write(String::from("Hello!")));
}

Pola Wildcard `_`

Pola khusus _ (garis bawah) berfungsi sebagai penangkap semua. Pola ini cocok dengan nilai apa pun dan tidak mengikat nilai tersebut ke variabel.

Pola ini berguna saat Anda perlu mencakup semua kemungkinan demi kelengkapan, tetapi tidak memedulikan nilai tertentu yang cocok dengan suatu lengan.

fn main() {
  let some_value = Some(5);
  let absent_value: Option<i32> = None;

  match some_value {
    Some(x) => println!("Got a value: {}", x),
    _ => println!("Something else!"), // Matches None too
  }

  match absent_value {
    Some(x) => println!("Got a value: {}", x),
    _ => println!("No value here!"),
  }
}

`if let` untuk Pola Tunggal

Terkadang, Anda hanya ingin mencocokkan satu pola tertentu dan mengabaikan pola lainnya. Untuk situasi ini, if let merupakan alternatif yang lebih ringkas daripada ekspresi match lengkap.

Pada dasarnya, pernyataan ini berarti: "jika pola ini cocok, lakukan ini; jika tidak, jangan lakukan apa pun (atau jalankan blok else opsional).".

fn main() {
  let config_max = Some(3u8);
  let none_value: Option<u8> = None;

  if let Some(max) = config_max {
    println!("Max configured to be: {}", max);
  }

  if let Some(val) = none_value {
    println!("This won't print: {}", val);
  } else {
    println!("No value found!");
  }
}

`while let` untuk Perulangan Bersyarat

Mirip dengan if let, while let memungkinkan Anda mengulang selama suatu pola masih cocok.

Ini sangat berguna untuk memproses item dari koleksi seperti Vecs ketika Anda ingin melanjutkan sampai tidak ada lagi elemen yang cocok (misalnya, sampai pop() mengembalikan None).

fn main() {
  let mut stack = vec![1, 2, 3];

  while let Some(top) = stack.pop() {
    println!("Popped: {}", top);
  }

  println!("Stack is empty now.");
}

Penjaga Pencocokan: Menambahkan Kondisi

Anda dapat menambahkan kondisi if tambahan, yang disebut penjaga pencocokan, ke lengan match. Polanya harus cocok DAN kondisi penjaga harus bernilai benar agar lengan tersebut dijalankan.

Hal ini memungkinkan pengendalian yang lebih terperinci di dalam pola tanpa perlu membuat lebih banyak varian enum.

fn main() {
  let num = Some(4);

  match num {
    Some(x) if x % 2 == 0 => println!("Even number: {}", x),
    Some(x) if x < 5 => println!("Small odd number: {}", x),
    Some(x) => println!("Any other number: {}", x),
    None => println!("No number"),
  }
}

Tantangan Pencocokan Pola

Perhatikan potongan kode Rust berikut. Pernyataan manakah yang benar tentang ekspresi match dan hasilnya?

enum Status {
  Loading,
  Success(u32),
  Error(String),
}

fn process_status(s: Status) {
  match s {
    Status::Success(code) if code > 200 => println!("Success with high code: {}", code),
    Status::Success(code) => println!("Success with code: {}", code),
    Status::Error(msg) => println!("Failed: {}", msg),
    _ => println!("Status unknown or loading..."),
  }
}

fn main() {
  process_status(Status::Success(201));
  process_status(Status::Error(String::from("Network issue")));
  process_status(Status::Loading);
  process_status(Status::Success(200));
}

Rangkuman: Menguasai Pola

Anda telah menjelajahi kekuatan luar biasa pencocokan pola dalam Rust! Ini adalah konsep dasar untuk menulis kode yang jelas, ringkas, dan aman.

Ekspresi match menyediakan pengendalian alur yang lengkap berdasarkan struktur data.
Anda dapat mencocokkan literal, rentang, dan menggunakan wildcard (_).
Penguraian memungkinkan Anda mengekstrak nilai langsung dari struct dan enum.
if let dan while let menyediakan cara ringkas untuk mencocokkan pola tunggal.
Penjaga pencocokan menambahkan logika bersyarat ke lengan match.

Teruslah berlatih menggunakan pola-pola ini; semuanya penting untuk menulis Rust secara idiomatis!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pencocokan Pola yang Ampuh” gratis?

Ya — teks lengkap “Pencocokan Pola yang Ampuh” 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 3 pelajaran total.

Apa yang akan aku pelajari di “Pencocokan Pola yang Ampuh”?

Kuasai ekspresi `match` dan konstruksi pencocokan pola lainnya untuk menangani varian data secara ringkas dan menyeluruh. 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 3.

Berapa lama pelajaran “Pencocokan Pola yang Ampuh” 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