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:
fn main() {
let s = "café";
println!("isi: {s}");
}
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:
fn main() {
let s = "café";
println!("len() = {} byte, chars().count() = {} karakter", s.len(), s.chars().count());
let jawa = "ꦄ";
println!("jawa len() = {} byte", jawa.len());
}
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.
| Teks | len() | chars().count() |
|---|---|---|
"café" | 5 | 4 |
"ꦄ" | 3 | 1 |
"🦀" | 4 | 1 |
"abc" | 3 | 3 |
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:
fn main() {
let j = "ꦄ";
println!("{}", &j[0..1]);
}
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():
fn main() {
let j = "ꦄab";
let dua_karakter: String = j.chars().take(2).collect();
println!("{dua_karakter}");
}
ꦄ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:
| Escape | Arti |
|---|---|
\n | baris baru |
\t | tab |
\" | tanda kutip ganda |
\\ | garis miring terbalik |
fn main() {
let escape = "baris satu\nbaris dua\ttab";
println!("{escape}");
}
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 #":
fn main() {
let mentah = r#"teks "mentah" tanpa escape \n"#;
println!("{mentah}");
}
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:
fn main() {
let banyak = "baris pertama
baris kedua";
println!("{banyak}");
}
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:
fn main() {
let s = "abc\
def";
println!("[{}] panjang {}", s, s.len());
}
[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:
fn main() {
let a = "rust";
let b = "rust";
println!("{}", a == b);
println!("{}", a == "Rust");
}
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:
fn main() {
let depan = "Rust";
let belakang = "Dasar";
let gabung = format!("{} {}", depan, belakang);
println!("{gabung}");
}
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:
fn main() {
for (i, c) in "abc".chars().enumerate() {
println!("{i}: {c}");
}
}
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:
fn main() {
let s = "belajar rust dari dasar";
println!("{} {} {}", s.contains("rust"), s.starts_with("belajar"), s.ends_with("dasar"));
}
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:
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);
}
[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
- Cetak
len()danchars().count()untuk namamu, lalu untuk 1 emoji. Jelaskan selisihnya. - Potong string
"ꦄab"memakai rentang&s[0..3], lalu bandingkan hasilnya denganchars().take(1). - Tulis path
C:\data\berkas.txtmemakai 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
- The Rust Programming Language. Data Types, bagian string.
- The Rust Reference. Literal expressions.
- Standard library. Primitive str.