Vectors | Faisal Affan

Versi Bahasa Indonesia. Baca dalam Bahasa Inggris

Vector adalah tipe koleksi serupa yang disediakan oleh standard library yang dapat bertambah atau berkurang ukurannya.
Vector diimplementasikan menggunakan generics.
Lebih sering, kamu akan membuat Vec<T> dengan nilai awal dan Rust akan menyimpulkan tipe nilai yang ingin kamu simpan, sehingga kamu jarang perlu melakukan anotasi tipe.
Referensi:

vecs1.rs

fn array_and_vec() -> ([i32; 4], Vec<i32>) {
    let a = [10, 20, 30, 40]; // Array

    // Create a vector called `v` which contains the exact same elements as in the array `a`.
    // Use the vector macro.
    // let v = ???;
    let v = vec![10, 20, 30, 40];
    (a, v)
}

fn main() {
    // You can optionally experiment here.
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_array_and_vec_similarity() {
        let (a, v) = array_and_vec();
        assert_eq!(a, *v);
    }
}

Rust menyediakan macro vec! dengan mudah, yang akan membuat vector baru yang berisi nilai-nilai yang kamu berikan.
Kamu dapat menentukan tipe vector dengan tipe di dalam angle brackets seperti Vec<i32>.
Lebih sering, kamu akan membuat vector dengan nilai awal dan Rust akan menyimpulkan tipe nilai yang ingin kamu simpan, sehingga kamu jarang perlu melakukan anotasi tipe ini.
Di latihan ini kita hanya perlu menginisialisasi vector baru menggunakan macro vec!.
```
let v = vec![10, 20, 30, 40];
```

vecs2.rs

fn vec_loop(input: &[i32]) -> Vec<i32> {
    let mut output = Vec::new();

    for element in input {
        // Multiply each element in the `input` slice by 2 and push it to
        // the `output` vector.
        output.push(element * 2);
    }

    output
}

fn vec_map_example(input: &[i32]) -> Vec<i32> {
    // An example of collecting a vector after mapping.
    // We map each element of the `input` slice to its value plus 1.
    // If the input is `[1, 2, 3]`, the output is `[2, 3, 4]`.
    input.iter().map(|element| element + 1).collect()
}

fn vec_map(input: &[i32]) -> Vec<i32> {
    // Here, we also want to multiply each element in the `input` slice
    // by 2, but with iterator mapping instead of manually pushing into an empty
    // vector.
    // See the example in the function `vec_map_example` above.
    input.iter().map(|element| element * 2).collect()
}

fn main() {
    // You can optionally experiment here.
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_vec_loop() {
        let input = [2, 4, 6, 8, 10];
        let ans = vec_loop(&input);
        assert_eq!(ans, [4, 8, 12, 16, 20]);
    }

    #[test]
    fn test_vec_map_example() {
        let input = [1, 2, 3];
        let ans = vec_map_example(&input);
        assert_eq!(ans, [2, 3, 4]);
    }

    #[test]
    fn test_vec_map() {
        let input = [2, 4, 6, 8, 10];
        let ans = vec_map(&input);
        assert_eq!(ans, [4, 8, 12, 16, 20]);
    }
}

Di latihan ini kita memiliki 2 tugas:
Pertama adalah melakukan iterasi melalui koleksi secara manual menggunakan for dan mengalikan setiap elemen dengan 2.
```
for element in input {
  output.push(element * 2);
}
```
- Kalikan element dengan 2.
- Kemudian push ke dalam variabel output.
- Kamu dapat membaca lebih lanjut tentang ini di Looping Through a Collection with for.
Kedua adalah melakukan iterasi melalui koleksi menggunakan iterator dan mengalikan setiap elemen dengan 2.
```
input.iter().map(|element| element * 2).collect()
```
- Memanggil iter() pada sebuah koleksi akan mengembalikan tipe Iter.
- Kemudian memanggil map() akan menghasilkan iterator baru yang memanggil closure yang diberikan pada setiap elemen dari iterator asli. Ref: trait.iterator method.map.
- collect() dapat mengambil apa pun yang iterable, dan mengubahnya menjadi koleksi yang relevan.
- Kamu dapat membaca lebih lanjut tentang iterator di sini: Iteration dan trait-nya di sini: Iterator Trait.