Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Mendefinisikan dan Menginstansiasi Struct

Struct mirip dengan tuple, yang dibahas di bagian “Tipe Tuple”, karena keduanya menyimpan beberapa nilai yang saling terkait. Seperti tuple, bagian-bagian sebuah struct boleh bertipe berbeda. Bedanya dengan tuple, dalam struct kamu memberi nama pada setiap bagian data sehingga jelas apa arti nilai-nilai itu. Berkat nama inilah, struct lebih fleksibel daripada tuple: kamu tidak perlu bergantung pada urutan data untuk menentukan atau mengakses nilai sebuah instance.

Untuk mendefinisikan struct, kita menulis keyword struct dan memberi nama pada keseluruhan struct itu. Nama struct sebaiknya menggambarkan arti dari bagian-bagian data yang dikelompokkan. Kemudian, di dalam kurung kurawal, kita mendefinisikan nama dan tipe dari bagian-bagian data tersebut, yang kita sebut field. Sebagai contoh, Listing 5-1 menunjukkan struct yang menyimpan informasi tentang akun pengguna.

Filename: src/main.rs
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {}
Listing 5-1: Definisi struct User

Setelah sebuah struct didefinisikan, kita bisa memakainya dengan membuat instance dari struct tersebut. Caranya, tentukan nilai konkret untuk setiap field. Kita membuat instance dengan menyebut nama struct, lalu menambahkan kurung kurawal yang berisi pasangan key: value, di mana key adalah nama field dan value adalah data yang ingin kita simpan di field tersebut. Urutan field tidak harus sama dengan urutan deklarasinya di dalam struct. Singkatnya, definisi struct ibarat template umum bagi sebuah tipe, dan instance mengisi template itu dengan data tertentu untuk menghasilkan nilai bertipe demikian. Sebagai contoh, kita bisa mendeklarasikan sebuah pengguna tertentu seperti Listing 5-2.

Filename: src/main.rs
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    let user1 = User {
        active: true,
        username: String::from("someusername123"),
        email: String::from("someone@example.com"),
        sign_in_count: 1,
    };
}
Listing 5-2: Membuat instance struct User

Untuk mengambil nilai tertentu dari sebuah struct, kita memakai notasi titik. Sebagai contoh, untuk mengakses alamat email pengguna ini, kita menulis user1.email. Jika instance-nya mutable, kita bisa mengubah sebuah nilai dengan notasi titik yang menempatkan nilai baru ke field tersebut. Listing 5-3 menunjukkan cara mengubah nilai pada field email sebuah instance User yang mutable.

Filename: src/main.rs
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    let mut user1 = User {
        active: true,
        username: String::from("someusername123"),
        email: String::from("someone@example.com"),
        sign_in_count: 1,
    };

    user1.email = String::from("anotheremail@example.com");
}
Listing 5-3: Mengubah nilai pada field email sebuah instance User

Perhatikan bahwa seluruh instance harus mutable; Rust tidak mengizinkan kita menandai hanya sebagian field sebagai mutable. Sama seperti ekspresi lain, kita bisa membentuk instance baru dari struct sebagai ekspresi terakhir di dalam badan fungsi untuk mengembalikan instance baru itu secara implisit.

Listing 5-4 menunjukkan fungsi build_user yang mengembalikan sebuah instance User dengan email dan username yang diberikan. Field active mendapat nilai true, dan sign_in_count mendapat nilai 1.

Filename: src/main.rs
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn build_user(email: String, username: String) -> User {
    User {
        active: true,
        username: username,
        email: email,
        sign_in_count: 1,
    }
}

fn main() {
    let user1 = build_user(
        String::from("someone@example.com"),
        String::from("someusername123"),
    );
}
Listing 5-4: Fungsi build_user yang menerima email dan username lalu mengembalikan sebuah instance User

Wajar jika nama parameter fungsi sama dengan nama field struct, tapi harus mengulang nama dan variabel email dan username terasa sedikit menyebalkan. Kalau struct punya lebih banyak field, mengulang setiap nama akan semakin merepotkan. Untungnya, ada shorthand yang praktis!

Memakai Field Init Shorthand

Karena nama parameter dan nama field struct persis sama di Listing 5-4, kita bisa memakai sintaks field init shorthand untuk menulis ulang build_user agar perilakunya tetap sama persis, tapi tanpa mengulang username dan email, seperti yang ditunjukkan Listing 5-5.

Filename: src/main.rs
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn build_user(email: String, username: String) -> User {
    User {
        active: true,
        username,
        email,
        sign_in_count: 1,
    }
}

fn main() {
    let user1 = build_user(
        String::from("someone@example.com"),
        String::from("someusername123"),
    );
}
Listing 5-5: Fungsi build_user yang memakai field init shorthand karena parameter username dan email bernama sama dengan field struct

Di sini kita membuat instance baru dari struct User yang punya field bernama email. Kita ingin mengisi nilai field email dengan nilai dari parameter email fungsi build_user. Karena field email dan parameter email bernama sama, kita cukup menulis email saja, bukan email: email.

Membuat Instance dengan Struct Update Syntax

Sering kali kita ingin membuat instance struct baru yang memuat sebagian besar nilai dari instance lain bertipe sama, tetapi dengan beberapa nilai yang diubah. Kamu bisa melakukannya memakai struct update syntax.

Pertama, Listing 5-6 menunjukkan cara membuat instance User baru di user2 dengan cara biasa, tanpa update syntax. Kita menetapkan nilai baru untuk email, tapi selain itu memakai nilai-nilai dari user1 yang kita buat di Listing 5-2.

Filename: src/main.rs
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    // --snip--

    let user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

    let user2 = User {
        active: user1.active,
        username: user1.username,
        email: String::from("another@example.com"),
        sign_in_count: user1.sign_in_count,
    };
}
Listing 5-6: Membuat instance User baru dengan memakai semua nilai dari user1 kecuali satu

Dengan struct update syntax, kita bisa mencapai efek yang sama dengan kode yang lebih sedikit, seperti yang ditunjukkan Listing 5-7. Sintaks .. menentukan bahwa field-field yang tidak diisi secara eksplisit akan mendapat nilai yang sama dengan field pada instance yang diberikan.

Filename: src/main.rs
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

fn main() {
    // --snip--

    let user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

    let user2 = User {
        email: String::from("another@example.com"),
        ..user1
    };
}
Listing 5-7: Memakai struct update syntax untuk menetapkan nilai email baru pada sebuah instance User, sambil memakai sisa nilai dari user1

Kode pada Listing 5-7 juga membuat instance di user2 dengan nilai email yang berbeda, tetapi nilai field username, active, dan sign_in_count sama dengan milik user1. ..user1 harus diletakkan terakhir untuk menandakan bahwa sisa field akan mengambil nilainya dari field yang sepadan di user1, tapi kita boleh menentukan nilai untuk sebanyak mungkin field yang kita mau, dalam urutan apa pun, tanpa peduli urutan field dalam definisi struct.

Perhatikan bahwa struct update syntax memakai = seperti halnya assignment; ini karena sintaks tersebut memindahkan data, seperti yang kita lihat di bagian “Variabel dan Data Berinteraksi dengan Move”. Pada contoh ini, kita tidak bisa lagi memakai user1 setelah membuat user2 karena String pada field username milik user1 sudah dipindahkan ke user2. Jika kita memberi user2 nilai String baru untuk email dan username, sehingga hanya nilai active dan sign_in_count yang diambil dari user1, maka user1 akan tetap valid setelah user2 dibuat. Baik active maupun sign_in_count bertipe yang mengimplementasikan trait Copy, jadi perilaku yang kita bahas di bagian “Data Khusus Stack: Copy” akan berlaku. Kita juga masih bisa memakai user1.email pada contoh ini, karena nilainya tidak dipindahkan keluar dari user1.

Membuat Tipe Berbeda dengan Tuple Struct

Rust juga mendukung struct yang mirip tuple, yang disebut tuple struct. Tuple struct punya tambahan makna dari nama struct-nya, tetapi field-fieldnya tidak punya nama; yang ada hanya tipe tiap field. Tuple struct berguna ketika kamu ingin memberi nama pada keseluruhan tuple sehingga tuple itu menjadi tipe yang berbeda dari tuple lain, dan ketika menamai setiap field seperti pada struct biasa akan terlalu panjang atau berlebihan.

Untuk mendefinisikan tuple struct, mulailah dengan keyword struct dan nama struct, lalu ikuti dengan tipe-tipe di dalam tuple. Sebagai contoh, di sini kita mendefinisikan dan memakai dua tuple struct bernama Color dan Point:

Filename: src/main.rs
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
}

Perhatikan bahwa nilai black dan origin bertipe berbeda karena keduanya adalah instance dari tuple struct yang berbeda. Setiap struct yang kamu definisikan adalah tipe-nya sendiri, meski field-field di dalamnya boleh saja bertipe sama. Sebagai contoh, fungsi yang menerima parameter bertipe Color tidak bisa menerima Point sebagai argumen, meski kedua tipe tersusun atas tiga nilai i32. Selain itu, instance tuple struct mirip tuple: kamu bisa mendestruksinya menjadi bagian-bagian penyusunnya, dan kamu bisa memakai . diikuti indeks untuk mengakses nilai tertentu. Bedanya dengan tuple, tuple struct mengharuskan kamu menyebut nama struct-nya saat mendestruksi. Sebagai contoh, kita akan menulis let Point(x, y, z) = origin; untuk mendestruksi nilai di titik origin menjadi variabel bernama x, y, dan z.

Mendefinisikan Unit-Like Struct

Kamu juga bisa mendefinisikan struct yang tidak punya field sama sekali! Struct ini disebut unit-like structs karena perilakunya mirip (), tipe unit yang kita sebut di bagian “Tipe Tuple”. Unit-like struct bisa berguna ketika kamu perlu mengimplementasikan sebuah trait pada suatu tipe, tetapi tidak punya data yang ingin disimpan di tipe itu sendiri. Kita akan membahas trait di Bab 10. Berikut contoh pendeklarasian dan penginstansian sebuah unit struct bernama AlwaysEqual:

Filename: src/main.rs
struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual;
}

Untuk mendefinisikan AlwaysEqual, kita memakai keyword struct, nama yang kita inginkan, lalu titik koma. Tidak perlu kurung kurawal maupun kurung biasa! Setelah itu, kita bisa membuat instance AlwaysEqual di variabel subject dengan cara serupa: memakai nama yang kita definisikan, tanpa kurung kurawal maupun kurung biasa. Bayangkan kelak kita mengimplementasikan perilaku untuk tipe ini sehingga setiap instance AlwaysEqual selalu sama dengan setiap instance tipe lain mana pun, misalnya untuk mendapatkan hasil yang diketahui saat testing. Kita tidak butuh data apa pun untuk mengimplementasikan perilaku itu! Di Bab 10 kamu akan melihat cara mendefinisikan trait dan mengimplementasikannya pada tipe mana pun, termasuk unit-like structs.

Ownership Data Struct

Pada definisi struct User di Listing 5-1, kita memakai tipe String yang dimiliki (owned) alih-alih tipe string slice &str. Ini pilihan yang disengaja, karena kita ingin setiap instance struct memiliki seluruh datanya sendiri dan data itu valid selama struct-nya sendiri masih valid.

Struct juga bisa menyimpan reference ke data yang dimiliki pihak lain, tetapi untuk melakukannya kita perlu memakai lifetime, fitur Rust yang akan kita bahas di Bab 10. Lifetime memastikan bahwa data yang direferensikan sebuah struct selalu valid selama struct itu sendiri valid. Misalnya kamu mencoba menyimpan sebuah reference di dalam struct tanpa menentukan lifetime, seperti berikut di src/main.rs; ini tidak akan berhasil:

Filename: src/main.rs
struct User {
    active: bool,
    username: &str,
    email: &str,
    sign_in_count: u64,
}

fn main() {
    let user1 = User {
        active: true,
        username: "someusername123",
        email: "someone@example.com",
        sign_in_count: 1,
    };
}

Compiler akan mengeluh bahwa ia membutuhkan spesifier lifetime:

$ cargo run
   Compiling structs v0.1.0 (file:///projects/structs)
error[E0106]: missing lifetime specifier
 --> src/main.rs:3:15
  |
3 |     username: &str,
  |               ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct User<'a> {
2 |     active: bool,
3 ~     username: &'a str,
  |

error[E0106]: missing lifetime specifier
 --> src/main.rs:4:12
  |
4 |     email: &str,
  |            ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct User<'a> {
2 |     active: bool,
3 |     username: &str,
4 ~     email: &'a str,
  |

For more information about this error, try `rustc --explain E0106`.
error: could not compile `structs` (bin "structs") due to 2 previous errors

Di Bab 10, kita akan membahas cara memperbaiki error tersebut agar kamu bisa menyimpan reference di dalam struct, tapi untuk sekarang, kita akan mengatasi error semacam ini dengan memakai tipe owned seperti String alih-alih reference seperti &str.