Lewati ke konten
Ferris the Rust crabTutorial Rust

Error Rust E0027: pattern does not mention field X (field belum disebut)

E0027 artinya: kamu sedang membongkar sebuah struct atau varian enum dengan pattern (pola), seperti let Order { item, quantity } = order;, dan kamu tidak menyebut semua field-nya. Di Rust, sebuah pattern struct harus memperhitungkan semua field, entah dengan menyebut namanya atau dengan bilang “dan sisanya” memakai ... Ini salah satu error yang paling ramah: rustc mencetak perbaikannya persis, dan hampir selalu cuma dua titik. (Halaman ini bagian dari Penjelasan error compiler Rust.)

Pesan error-nya

Section titled “Pesan error-nya”
error[E0027]: pattern does not mention fields `id`, `paid`
  --> src/main.rs:10:9
   |
10 |     let Order { item, quantity } = order; // ❌ `id` dan `paid` tidak disebut
   |         ^^^^^^^^^^^^^^^^^^^^^^^^ missing fields `id`, `paid`
   |
help: include the missing fields in the pattern
   |
10 |     let Order { item, quantity, id, paid } = order; // ❌ `id` dan `paid` tidak disebut
   |                               ++++++++++
help: if you don't care about these missing fields, you can explicitly ignore them
   |
10 |     let Order { item, quantity, id: _, paid: _ } = order; // ❌ `id` dan `paid` tidak disebut
   |                               ++++++++++++++++
help: or always ignore missing fields here
   |
10 |     let Order { item, quantity, .. } = order; // ❌ `id` dan `paid` tidak disebut
   |                               ++++

Artinya: pattern-nya tidak menyebut field id dan paid. rustc lalu memberi tiga saran perbaikan, yang dijelaskan di bawah.

Ini program yang menghasilkan error tersebut:

struct Order {
    id: u32,
    item: String,
    quantity: u32,
    paid: bool,
}


fn main() {
    let order = Order { id: 1, item: String::from("keyboard"), quantity: 2, paid: true };
    let Order { item, quantity } = order; // ❌ `id` dan `paid` tidak disebut
    println!("{} x {}", quantity, item);
}

Apa artinya

Section titled “Apa artinya”

Judul error-nya mendaftar field yang terlewat dari pattern-mu (id dan paid). Tanda ^^^ menggarisbawahi seluruh pattern, karena masalahnya bukan satu kata yang salah, tapi ada sesuatu yang kurang.

Lalu rustc memberi tiga saran help:. Semuanya benar, tapi artinya berbeda-beda:

  • include the missing fields (sertakan field yang kurang): sebut namanya, jadi kamu juga mendapat variabel id dan paid.
  • explicitly ignore them (abaikan secara eksplisit): tulis id: _, paid: _. Kamu tidak mendapat variabel, tapi kamu sudah mendaftar setiap field berdasarkan namanya.
  • always ignore missing fields here (selalu abaikan field yang kurang di sini): tulis ... Artinya “dan field lainnya, aku tidak peduli”.

Ibaratnya daftar periksa di pintu masuk yang bilang “centang semua kotak, atau centang Lainnya: lewati”. Kamu tidak boleh membiarkan kotaknya kosong begitu saja.

Kenapa Rust melakukan ini

Section titled “Kenapa Rust melakukan ini”

Pattern struct di Rust dimaksudkan untuk lengkap, kecuali kamu bilang sebaliknya. Ini membuat niatmu jelas bagi pembaca berikutnya. Order { item, quantity, .. } bilang “aku cuma butuh dua ini”. Order { id, item, quantity, paid } bilang “aku sudah memikirkan setiap field”. Lihat Mengabaikan bagian dengan _ dan ...

Manfaat sebenarnya terasa saat struct-nya berubah. Kalau seseorang menambahkan field discount ke Order, pattern yang mendaftar setiap field berdasarkan nama akan rusak dengan E0027, yang menunjukkan kode mana yang mungkin perlu menangani field baru itu. Pattern dengan .. tetap bisa dikompilasi. Rust membiarkanmu memilih perilaku mana yang kamu mau, tapi tidak akan menebaknya untukmu.

Cara memperbaikinya

Section titled “Cara memperbaikinya”

Perbaikan 1: Tambahkan .. untuk mengabaikan sisanya

Section titled “Perbaikan 1: Tambahkan .. untuk mengabaikan sisanya”

Pilih ini hampir setiap saat. Kalau kamu hanya butuh beberapa field, akhiri pattern-nya dengan ... Ini bisa dipakai di let, match, if let, dan parameter fungsi, dan harus diletakkan paling akhir.

struct Order {
    id: u32,
    item: String,
    quantity: u32,
    paid: bool,
}


fn main() {
    let order = Order { id: 1, item: String::from("keyboard"), quantity: 2, paid: true };
    let Order { item, quantity, .. } = order; // ✅ `..` melewati `id` dan `paid`
    println!("{} x {}", quantity, item);


    let orders = [
        Order { id: 2, item: String::from("mouse"), quantity: 1, paid: false },
        Order { id: 3, item: String::from("monitor"), quantity: 1, paid: true },
    ];
    for order in &orders {
        match order {
            Order { paid: true, item, .. } => println!("kirim {}", item),
            Order { id, .. } => println!("pesanan #{} menunggu pembayaran", id),
        }
    }
}

Output:

2 x keyboard
pesanan #2 menunggu pembayaran
kirim monitor
▶ Coba sendiri

Perhatikan paid: true di arm pertama: sebuah field di dalam pattern juga bisa dicocokkan dengan sebuah nilai, dan .. tetap mengurus field lainnya.

Perbaikan 2: Sebut field yang kurang, atau abaikan berdasarkan nama dengan _

Section titled “Perbaikan 2: Sebut field yang kurang, atau abaikan berdasarkan nama dengan _”

Pilih ini kalau kamu memang butuh field itu, atau kalau kamu ingin pattern-nya rusak saat ada field baru yang ditambahkan nanti. Error yang sama muncul di match pada varian enum yang punya field bernama:

error[E0027]: pattern does not mention field `y`
 --> src/main.rs:9:9
  |
9 |         Message::Move { x } => println!("pindah ke x = {}", x), // ❌ `y` tidak disebut
  |         ^^^^^^^^^^^^^^^^^^^ missing field `y`

Artinya: pattern-nya tidak menyebut field y.

Program di baliknya:

enum Message {
    Move { x: i32, y: i32 },
    Quit,
}


fn main() {
    let m = Message::Move { x: 1, y: 2 };
    match m {
        Message::Move { x } => println!("pindah ke x = {}", x), // ❌ `y` tidak disebut
        Message::Quit => println!("keluar"),
    }
}

Sebuah perpindahan punya dua koordinat, dan kodenya memang seharusnya memakai keduanya. Jadi sebutkan y. Kalau sebuah field benar-benar tidak penting, y: _ mengatakannya dengan jelas, dan tetap mendaftarnya berdasarkan nama:

enum Message {
    Move { x: i32, y: i32 },
    Quit,
}


fn main() {
    let messages = [Message::Move { x: 1, y: 2 }, Message::Move { x: 5, y: 0 }, Message::Quit];
    for m in &messages {
        match m {
            Message::Move { x, y: 0 } => println!("meluncur di lantai ke x = {}", x),
            Message::Move { x, y } => println!("pindah ke ({}, {})", x, y), // ✅ kedua field
            Message::Quit => println!("keluar"),
        }
    }


    // setiap field disebut namanya: menambah field ke `Move` akan sengaja merusak baris ini
    if let Message::Move { x, y: _ } = &messages[0] {
        println!("x pertama = {}", x);
    }
}

Output:

pindah ke (1, 2)
meluncur di lantai ke x = 5
keluar
x pertama = 1
▶ Coba sendiri

Kalau kamu menyebut sebuah field hanya untuk mengabaikannya, tulis y: _, bukan y saja. Variabel y yang tidak pernah kamu pakai akan memberi warning “unused variable” (variabel tidak dipakai).

Perbaikan 3: Betulkan nama field yang salah ketik

Section titled “Perbaikan 3: Betulkan nama field yang salah ketik”

Pilih ini kalau E0027 muncul bersama E0026 di baris yang sama. Misalnya, Shape::Circle { r } untuk varian yang field-nya bernama radius memberi keduanya: E0026 untuk r (field itu tidak ada) dan E0027 untuk radius (tidak disebut). Saran help: dari E0027 akan menyuruhmu menambahkan radius di sebelah r, tapi bukan itu yang kamu mau. Perbaikan yang benar adalah mengganti nama yang salah: Shape::Circle { radius }, atau Shape::Circle { radius: r } supaya nama variabelnya tetap pendek. Setelah itu kedua error hilang sekaligus. Lihat halaman E0026 untuk contohnya.

Di mana biasanya kamu melihatnya

Section titled “Di mana biasanya kamu melihatnya”

Setelah menambahkan field ke sebuah struct. Kamu menambahkan created_at ke Order, dan sekarang setiap pattern yang mendaftar semua field memberi E0027. Itu tandanya pemeriksaannya bekerja. Putuskan untuk masing-masing: apakah kode ini butuh created_at? Kalau ya, sebut namanya; kalau tidak, tambahkan ...

Parameter fungsi. fn print_order(&Order { item, quantity }: &Order) juga memberi E0027. Perbaikannya: &Order { item, quantity, .. }. Lihat Pola di let dan parameter fungsi.

Tuple struct dan varian tuple. Untuk struct Color(u8, u8, u8);, pattern Color(r) juga tidak lengkap, tapi rustc melaporkannya sebagai E0023, “this pattern has 1 field, but the corresponding tuple struct has 3 fields” (pattern ini punya 1 field, tapi tuple struct-nya punya 3 field). Idenya sama: Color(r, ..) atau Color(r, _, _).

Error terkait

Section titled “Error terkait”

Kuis singkat

Section titled “Kuis singkat”

Kuis singkat

1. struct Point { x: i32, y: i32, z: i32 }. Pattern mana yang bisa dikompilasi dan hanya memberimu x?

2. Apa bedanya Order { item, .. } dengan Order { item, id: _, quantity: _, paid: _ }?

3. Kamu mendapat E0026 untuk r dan E0027 untuk radius di baris yang sama. Apa perbaikan terbaiknya?

Skor: 0 / 3

Bacaan lebih lanjut

Section titled “Bacaan lebih lanjut”