Foundation

BAB 6: Tipe Data: String Literal (&str)

String literal &str di Rust: penyimpanan UTF-8, perbedaan len byte dan jumlah karakter, escape sequence, raw string, serta panic saat memotong di tengah karakter.

String "café" di Rust berisi 5 byte, tetapi hanya 4 karakter. Angka pertama adalah len(), angka kedua adalah chars().count(), dan selisih itu berasal dari huruf é yang memakai 2 byte dalam UTF-8. Selama perbedaan ini tidak disadari, pemotongan string akan menghasilkan panic yang sulit dijelaskan.

Bab ini membahas string literal bertipe &str: penyimpanan UTF-8, cara mengukur panjang, escape sequence, raw string, dan kesalahan yang muncul saat memotong string di tengah karakter. Semua contoh dikompilasi dan dijalankan dengan rustc 1.100.0.

String literal dan tipe &str

String literal ditulis di antara tanda kutip ganda, dan tipenya adalah &str, yaitu potongan teks yang dipinjam dari tempat lain:

RSRUST
fn main() {
    let s = "café";
    println!("isi: {s}");
}
CodeTEXT
isi: café

&str tidak bisa diubah. Menambah atau mengganti 1 huruf di dalamnya bukan operasi yang disediakan, dan itu disengaja: literal disimpan di dalam biner program dan dipakai bersama oleh semua bagian program yang merujuknya.

Tipe String yang bisa diubah dibahas di bab 55, bersama perbandingannya dengan &str.

Panjang byte dan jumlah karakter

len() mengembalikan jumlah byte, sedangkan chars().count() mengembalikan jumlah karakter:

RSRUST
fn main() {
    let s = "café";
    println!("len() = {} byte, chars().count() = {} karakter", s.len(), s.chars().count());

    let jawa = "ꦄ";
    println!("jawa len() = {} byte", jawa.len());
}
CodeTEXT
len() = 5 byte, chars().count() = 4 karakter
jawa len() = 3 byte

Huruf é memakai 2 byte, dan aksara Jawa ꦄ memakai 3 byte. Karena setiap karakter bisa memakai 1 sampai 4 byte, jumlah byte tidak sama dengan jumlah karakter, dan perbedaan itu bertambah besar pada teks berisi aksara non-Latin atau emoji.

Tekslen()chars().count()
"café"54
"ꦄ"31
"🦀"41
"abc"33

Memotong string dan panic di tengah karakter

String bisa dipotong memakai rentang byte, misalnya &s[0..3]. Rentang itu dihitung dalam byte, bukan karakter, sehingga batasnya harus jatuh tepat di awal karakter:

RSRUST
fn main() {
    let j = "ꦄ";
    println!("{}", &j[0..1]);
}
CodeTEXT
thread 'main' panicked at slice_panic.rs:4:22:
end byte index 1 is not a char boundary; it is inside 'ꦄ' (bytes 0..3 of string)

Panic itu terjadi karena byte ke-1 bukan batas karakter: aksara Jawa tersebut menempati byte 0 sampai 2. Rust menolak memotong di tengah karakter, karena hasilnya bukan teks UTF-8 yang sah.

Untuk memotong berdasarkan karakter, pakai iterator chars():

RSRUST
fn main() {
    let j = "ꦄab";
    let dua_karakter: String = j.chars().take(2).collect();
    println!("{dua_karakter}");
}
CodeTEXT
ꦄa

Bentuk ini aman untuk teks apa pun, karena pemotongan terjadi setelah karakter dibaca satu per satu.

Escape sequence

Beberapa karakter tidak bisa ditulis langsung di dalam string, sehingga ditulis dengan garis miring terbalik:

EscapeArti
\nbaris baru
\ttab
\"tanda kutip ganda
\\garis miring terbalik
RSRUST
fn main() {
    let escape = "baris satu\nbaris dua\ttab";
    println!("{escape}");
}
CodeTEXT
baris satu
baris dua	tab

Raw string

Kalau string memuat banyak garis miring terbalik, misalnya pola regex atau path Windows, escape membuat teks sulit dibaca. Raw string menonaktifkan escape dengan awalan r# dan akhiran #":

RSRUST
fn main() {
    let mentah = r#"teks "mentah" tanpa escape \n"#;
    println!("{mentah}");
}
CodeTEXT
teks "mentah" tanpa escape \n

Tanda kutip di dalam raw string boleh ditulis langsung, dan urutan \n tetap tercetak sebagai 2 karakter, bukan baris baru.

String beberapa baris

String literal boleh memuat baris baru langsung di dalamnya. Spasi di awal baris juga ikut tersimpan, sehingga penulisan yang menjorok ke dalam akan membawa spasi itu ke hasil:

RSRUST
fn main() {
    let banyak = "baris pertama
baris kedua";
    println!("{banyak}");
}
CodeTEXT
baris pertama
baris kedua

Untuk teks panjang yang butuh perataan di kode, garis miring terbalik di akhir baris menghapus baris baru dan spasi di awal baris berikutnya:

RSRUST
fn main() {
    let s = "abc\
def";
    println!("[{}] panjang {}", s, s.len());
}
CodeTEXT
[abcdef] panjang 6

Tanpa garis miring itu, hasilnya memuat baris baru dan spasi yang tidak diinginkan.

Membandingkan string

Perbandingan == pada &str membandingkan isinya, bukan alamatnya:

RSRUST
fn main() {
    let a = "rust";
    let b = "rust";
    println!("{}", a == b);
    println!("{}", a == "Rust");
}
CodeTEXT
true
false

Perbandingan ini peka huruf besar dan kecil. Untuk perbandingan yang tidak peka, kedua sisi disamakan lebih dulu, misalnya dengan to_lowercase().

Menggabungkan string

Untuk menggabungkan beberapa &str, makro format! menghasilkan teks baru tanpa mengubah sumbernya:

RSRUST
fn main() {
    let depan = "Rust";
    let belakang = "Dasar";
    let gabung = format!("{} {}", depan, belakang);
    println!("{gabung}");
}
CodeTEXT
Rust Dasar

Makro ini berguna karena tidak menuntut tipe tertentu pada bagian yang digabung: angka, char, dan &str bisa masuk ke dalam penanda {} yang sama.

Mengiterasi karakter

chars() bisa dipakai untuk membaca teks karakter demi karakter, dan enumerate() menambahkan nomor urutnya:

RSRUST
fn main() {
    for (i, c) in "abc".chars().enumerate() {
        println!("{i}: {c}");
    }
}
CodeTEXT
0: a
1: b
2: c

Nomor urut di sini menghitung karakter, bukan byte, sehingga aman dipakai pada teks non-ASCII. Ini cara yang tepat untuk memproses teks per karakter, bukan dengan rentang byte.

Mencari bagian string

3 metode yang sering dipakai untuk memeriksa isi string, dan semuanya mengembalikan bool:

RSRUST
fn main() {
    let s = "belajar rust dari dasar";
    println!("{} {} {}", s.contains("rust"), s.starts_with("belajar"), s.ends_with("dasar"));
}
CodeTEXT
true true true

Ketiganya peka huruf besar dan kecil, sama seperti perbandingan ==. Untuk pencarian yang tidak peka huruf, teks disamakan dulu dengan to_lowercase().

Memotong spasi dan memecah teks

3 metode lain yang sering dipakai saat mengolah masukan pengguna:

RSRUST
fn main() {
    let s = "  Rust  ";
    println!("[{}]", s.trim());
    println!("{}", "rust".to_uppercase());
    println!("{}", "rust dasar".replace("dasar", "lanjut"));

    let bagian: Vec<&str> = "a,b,c".split(',').collect();
    println!("{:?}", bagian);
}
CodeTEXT
[Rust]
RUST
rust lanjut
["a", "b", "c"]

trim() membuang spasi di awal dan akhir, replace() menghasilkan teks baru dengan bagian yang diganti, dan split() memecah teks menjadi kumpulan potongan. Ketiganya mengembalikan nilai baru, bukan mengubah string asal, karena &str tidak bisa diubah.

Latihan

  1. Cetak len() dan chars().count() untuk namamu, lalu untuk 1 emoji. Jelaskan selisihnya.
  2. Potong string "ꦄab" memakai rentang &s[0..3], lalu bandingkan hasilnya dengan chars().take(1).
  3. Tulis path C:\data\berkas.txt memakai string biasa dan raw string, lalu cetak keduanya.

Ringkasan

String literal bertipe &str dan tidak bisa diubah. Panjangnya diukur 2 cara: len() menghitung byte, chars().count() menghitung karakter, dan keduanya berbeda pada teks non-ASCII seperti café, aksara Jawa, atau emoji.

Pemotongan string memakai rentang byte, sehingga batas yang jatuh di tengah karakter menyebabkan panic. Escape seperti \n dan \t dipakai untuk karakter khusus, r#"..."# mematikan escape untuk teks yang memuat banyak garis miring, dan perbandingan == membandingkan isi string secara peka huruf.

Referensi

  1. The Rust Programming Language. Data Types, bagian string.
  2. The Rust Reference. Literal expressions.
  3. Standard library. Primitive str.