Common Collections

Collections

Rust punya tipe data collections, yang merupakan kumpulan atau koleksi data dalam berbagai tipe dan nilai. Ada beberapa tipe data collections yang cukup populer di Rust. Berikut adalah beberapa daftarnya.

Vector mirip seperti array tetapi berbeda.
Strings digunakan untuk menyimpan tipe data character.
Hash Map memungkinkan kita untuk menyimpan nilai yang terasosiasi dengan key tertentu.

Vector

Vec<T> yang dikenal sebagai vector, sebuah tipe data yang dapat menyimpan lebih dari satu nilai kedalam single data struktur yang nilainya dapat ditambahkan atau dirubah.

Untuk menginisiasi vector baru, cukup dituliskan seperti ini Vec::new().

fn main() {
   let numbers: Vec<i32> = Vec::new();
}

Vector juga dapat diinisiasi dengan standar nilai default caranya dengan menggunakan syntax seperti ini vec![] berikut adalah contohnya.

fn main() {
   let numbers: Vec<i32> = vec![1, 2, 3];
}

Untuk meng-update dan menambahkan nilai baru, vector punya method bawaan yaitu push.

fn main() {
   let mut numbers: Vec<i32> = Vec::new();
   numbers.push(1);
}

Untuk bisa menggunakan push tambahkan keyword mut setelah keyword let tujuannya untuk membuatnya menjadi mutable.

Cara membaca elemen nilai yang berada didalam sebuah vector, bisa dengan menggunakan method get seperti ini numbers.get(index) berikut adalah contoh detailnya.

fn main() {
   let mut numbers: Vec<i32> = Vec::new();
   numbers.push(1);
   match numbers.get(0) {
       Some(v) => println!("{}", v),
       None => println!("index not found!"),
   } // 1
}

Atau bisa juga dengan cara yang seperti ini, dengan menggunakan references.

fn main() {
   let mut numbers: Vec<i32> = Vec::new();
   numbers.push(1);
   println!("{}", &numbers[0]); // 1
}

Jika ingin digunakan dengan cara di loop bisa juga jadinya seperti ini.

fn main() {
   let mut numbers: Vec<i32> = Vec::new();
   numbers.push(1);
   for number in numbers {
       println!("{}", number);
   } // 1
}

Selain itu bisa juga dengan menggunakan mutable references.

fn main() {
   let mut numbers: Vec<i32> = Vec::new();
   numbers.push(1);
   for number in &mut numbers {
       *number += 10;
       println!("{}", number); // output -> 11
   }
}

String

Kita dapat menyimpan text UTF-8 encoded ke dalam tipe data String. Rust hanya punya satu tipe string yang tersedia di inti bahasanya, yakni str yang dikenal dengan string slice yang biasanya terlihat seperti ini &str istilahnya borrowed string.

Rust juga memiliki tipe data String untuk kemudahan pengolahan data mutable dengan menggunakan string. Sehingga bisa menyimpan encode yang berbeda-beda dengan mudah.

Untuk penggunaanya sedikit mirip dengan apa yang bisa dilakukan oleh vector. Untuk inisiasi cukup dengan cara seperti ini String::new() dan untuk konversi tipe data string literal menjadi String bisa dengan menggunakan method to_string(), seperti contoh dibawah ini.

fn main() {
   let text = "Hello World";
   let convert_text_to_string = text.to_string();
   println!("{}", convert_text_to_string); // "Hello World"
}

Selain itu bisa juga membuat string dengan nilai yang bawaan atau istilahnya initial content contohnya seperti ini.

fn main() {
   let hello = String::from("Hello");   
   println!("{}", hello);
}

Untuk merubah data atau memperbaharui bisa dengan menambahkan keyword mut setelah let seperti contoh berikut.

fn main() {
   let mut hello = String::from("Hello");
   hello.push_str(" World");
   println!("{}", hello); // "Hello World"
}

Kemudian juga bisa menggabungkan data dengan menggunakan function format! seperti ini.

fn main() {
   let hello = String::from("Hello");
   let world = String::from("World");
   let hello_world = format!("{} {}", hello, world);
   println!("{}", hello_world); "Hello World"
}

HashMap

Untuk menyimpan koleksi data dengan key yang terasosiasi bisa menggunakan HashMap. Syntaxnya seperti ini HashMap<K, V> yaitu K mewakili key dan V adalah value.

Untuk menggunakan HashMap kita butuh untuk mengambilnya dari standard library, bisa dengan menggunakan use seperti contoh dibawah.

use std::collections::HashMap;
fn main() {
   let mut scores = HashMap::new();
   scores.insert(String::from("Team A"), 10);
   scores.insert(String::from("Team B"), 11);
   println!("{:?}", scores); // {"Team B": 11, "Team A": 10}
}

Cara mengakses value pada HashMap bisa menggunakan method get dan key dimasukan sebagai parameter, lengkapnya seperti dibawah ini.

use std::collections::HashMap;
fn main() {
   let mut scores = HashMap::new();
   scores.insert(String::from("Team_A"), 10);
   scores.insert(String::from("Team_B"), 11);
   println!("{:?}", scores.get(&String::from("Team_A"))); // Some(10)
}

Kemudian tahapan selanjutnya dari HashMap adalah cara untuk memperbaharui nilai jika key tersebut tidak memiliki nilai.

use std::collections::HashMap;
fn main() {
   let mut scores = HashMap::new();
   scores.insert(String::from("Team_A"), 10);
   scores.entry(String::from("Team_A")).or_insert(11);
   scores.entry(String::from("Team_B")).or_insert(12);
   println!("{:?}", scores);
}

Berikut adalah keluarannya.

{"Team_A": 10, "Team_B": 12}

Terlihat key Team_A tetap menggunakan nilai yang sebelumnya, dan key Team_B ditambahkan nilai baru.

Selanjutnya kita akan coba membuat sebuah text yang kemudian akan dipecah berdasarkan white space lalu setiap kata yang sama akan disimpan di dalam HashMap dan dihitung jumlahnya.

use std::collections::HashMap;
fn main() {
   let text = "hari ini saya ngantuk saya pengen tidur karena ngantuk";
   // please find a couple text and count it.
   let mut result = HashMap::new();
   for t in text.split_whitespace() {
       let count = result.entry(t).or_insert(0);
       *count += 1;
   }
   println!("{:?}", result);
}

Berikut adalah keluarannya.

{"karena": 1, "hari": 1, "saya": 2, "tidur": 1, "ini": 1, "pengen": 1, "ngantuk": 2}

Sebelumnya terdapat sebuah variable text yang diisi dengan tipe data string. Nah, kemudian ada mutable variable dengan nama result yang tujuannya sih untuk menampung data string nya, di tahap selanjutnya kita akan memotong text berdasarkan white space dengan menggunakan function split_whitespace() yaitu fungsi bawaan di Rust untuk memotong berdasarkan whitespace dan kemudian di dalam perulangan tersebut kita define lagi variable count yang isinya untuk mengupdate HashMap key berdasarkan text elemen, kemudian ada function or_insert() tujuannya untuk mengambil value berdasarkan index, yang default nilainya adalah 0, kemudian kita menggunakan tanda bintang (*) agar bisa mengakses nilai dari count secara langsung, nah hal ini disebut dengan dereferences.

Lifetime

Error Handling