Strings | Faisal Affan

Versi Bahasa Indonesia. Baca dalam Bahasa Inggris

String dapat dimutasi.
&str adalah string slice yang dipinjam (borrowed), immutable.
Referensi:
- Strings

strings1.rs

// TODO: Fix the compiler error without changing the function signature.
fn current_favorite_color() -> String {
    String::from("blue")
}

fn main() {
    let answer = current_favorite_color();
    println!("My current favorite color is {answer}");
}

Di latihan ini fungsi mengharapkan String sebagai tipe kembalian tetapi mendapatkan &str.
"hello" adalah &str dan kita hanya perlu mengonversinya menjadi String.
Kita dapat menggunakan salah satu dari ekspresi di bawah ini:
```
String::from("blue")
"blue".to_string()
```

strings2.rs

// TODO: Fix the compiler error in the `main` function without changing this function.
fn is_a_color_word(attempt: &str) -> bool {
    attempt == "green" || attempt == "blue" || attempt == "red"
}

fn main() {
    let word = String::from("green"); // Don't change this line.

    if is_a_color_word(&word) {
        println!("That is a color word I know!");
    } else {
        println!("That is not a color word I know.");
    }
}

Masalah serupa dengan latihan sebelumnya.
Fungsi mengharapkan &str tetapi mendapatkan String.
Jadi kita dapat mengonversinya menggunakan salah satu kode di bawah ini:
```
is_a_color_word(&word)
is_a_color_word(word.as_str())
```

strings3.rs

fn trim_me(input: &str) -> &str {
    // TODO: Remove whitespace from both ends of a string.
    input.trim()
}

fn compose_me(input: &str) -> String {
    // TODO: Add " world!" to the string! There are multiple ways to do this.
    format!("{input} world!")
}

fn replace_me(input: &str) -> String {
    // TODO: Replace "cars" in the string with "balloons".
    input.replace("cars", "balloons")
}

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

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

    #[test]
    fn trim_a_string() {
        assert_eq!(trim_me("Hello!     "), "Hello!");
        assert_eq!(trim_me("  What's up!"), "What's up!");
        assert_eq!(trim_me("   Hola!  "), "Hola!");
    }

    #[test]
    fn compose_a_string() {
        assert_eq!(compose_me("Hello"), "Hello world!");
        assert_eq!(compose_me("Goodbye"), "Goodbye world!");
    }

    #[test]
    fn replace_a_string() {
        assert_eq!(
            replace_me("I think cars are cool"),
            "I think balloons are cool",
        );
        assert_eq!(
            replace_me("I love to look at cars"),
            "I love to look at balloons",
        );
    }
}

Di latihan ini kita memiliki 3 tugas.
Pertama adalah memotong (trim) &str yang diberikan di fungsi trim_me dan mengembalikan &str.
- Kita dapat menggunakan method trim untuk melakukan ini.
Kedua adalah menambahkan " world!" ke &str yang diberikan di fungsi compose_me.
- Kita memiliki beberapa opsi untuk melakukan ini.
- Tetapi karena &str bersifat immutable, kita tidak bisa begitu saja menggunakan +.
- Kita dapat mengonversinya menjadi String terlebih dahulu atau menggunakan macro format seperti di bawah ini.
```
format!("{input} world!")
input.to_string() + " world!"
```
Terakhir adalah mengganti kemunculan cars menjadi balloons di fungsi replace_me.
- Kita dapat melakukannya dengan menggunakan method replace.

strings4.rs

// Calls of this function should be replaced with calls of `string_slice` or `string`.
fn placeholder() {}

fn string_slice(arg: &str) {
    println!("{arg}");
}

fn string(arg: String) {
    println!("{arg}");
}

// TODO: Here are a bunch of values - some are `String`, some are `&str`.
// Your task is to replace `placeholder(…)` with either `string_slice(…)`
// or `string(…)` depending on what you think each value is.
fn main() {
    string_slice("blue");

    string("red".to_string());

    string(String::from("hi"));

    string("rust is fun!".to_owned());

    string("nice weather".into());

    string(format!("Interpolation {}", "Station"));

    // WARNING: This is byte indexing, not character indexing.
    // Character indexing can be done using `s.chars().nth(INDEX)`.
    string_slice(&String::from("abc")[0..1]);

    string_slice("  hello there ".trim());

    string("Happy Monday!".replace("Mon", "Tues"));

    string("mY sHiFt KeY iS sTiCkY".to_lowercase());
}

Di latihan ini kita perlu mengganti placeholder dengan string atau string_slice untuk parameter yang diberikan.

Saya jelaskan setiap baris di bawah ini:

// "blue" adalah &str
string_slice("blue");
// to_string() mengembalikan String
string("red".to_string());
// String
string(String::from("hi"));
// to_owned() mengembalikan String
string("rust is fun!".to_owned());
// Di sini, kedua jawaban berfungsi.
// `.into()` mengonversi tipe ke tipe yang diharapkan.
// Jika dipanggil di mana `String` diharapkan, ia akan mengonversi `&str` menjadi `String`.
string("nice weather".into());
// format mengembalikan String
string(format!("Interpolation {}", "Station"));
// &str karena berupa slice
string_slice(&String::from("abc")[0..1]);
// trim mengembalikan &str
string_slice("  hello there ".trim());
// replace mengembalikan String
string("Happy Monday!".replace("Mon", "Tues"));
// to_lowercase() mengembalikan String
string("mY sHiFt KeY iS sTiCkY".to_lowercase());

Pada dasarnya apa pun yang memerlukan manipulasi string biasanya mengembalikan String dan jika tanpa manipulasi string biasanya mengembalikan &str.