Pendahuluan: Mengapa String Penting di Rust

Rust punya dua cara utama untuk mewakili teks: String, tipe heap yang bisa dimodifikasi, dan &str, referensi ke data string yang sudah ada. Bagi pemula, kebingungan sering muncul ketika harus memilih salah satu. Artikel ini membahas perbedaan fundamental, praktik harian yang sering ditemui, dan bagaimana memutuskan tipe mana yang tepat untuk situasi tertentu.

Fokusnya adalah penggunaan sehari-hari: membuat string literal untuk konstanta, membangun teks dinamis, memperpanjang isi string, serta mengirim data ke fungsi. Kita tidak mendalami encoding, tetapi cukup memahami kapan data berada dalam stack atau heap, dan konsekuensinya dalam penulisan program Rust yang aman dan efisien.

Mengenal Tipe String di Rust

Dalam Rust, string literal ditulis sebagai &str—referensi ke urutan byte yang diasumsikan UTF-8 dan ditempatkan dalam data program. Karena berada di memori baca-saja, &str tidak bisa diubah. Contohnya:

let salam: &str = "Halo, dunia!";

salam berada di segment baca-saja aplikasi. Keuntungan utama &str adalah efisiensi: tidak ada alokasi heap tambahan. Namun jika kita butuh menggabungkan teks, menambahkan kata, atau menyimpannya di luar block yang terbatas, kita butuh String.

String adalah koleksi UTF-8 yang disimpan di heap dan bisa dimodifikasi. Constructor laten seperti String::from atau to_string() memindahkan data dari literal menjadi struktur yang bisa direalisasikan. Contoh:

let mut kalimat = String::from("Halo");
kalimat.push_str(", dunia!");

Dengan mut, kalimat berubah seiring waktu. Ini menjadi pilihan tepat ketika aplikasi perlu menggabungkan input pengguna, membangun URL, atau memanipulasi data sebelum dikirim keluar.

Kapan Memakai String Literal (&str)

Gunakan &str ketika teksnya tetap, tidak perlu diubah, atau hanya dipinjam dari sumber lain. Kasus umum termasuk:

  • Pesan debug/hardcoded seperti "Error terjadi".
  • Sumber daya CLI atau dokumentasi embedded.
  • Parameter fungsi yang hanya membaca teks.

Contoh fungsi sederhana: 

fn cetak_kelas(nama: &str) {
    println!("Selamat datang, {}!", nama);
}

Argument berupa &str memberi tahu pemanggil fungsi bahwa data hanya dibaca, tanpa perlu kepemilikan baru. Ini juga menghindari alokasi heap berulang jika data sudah dalam bentuk literal, menjadikan eksekusi lebih ringan.

Kapan Memakai String yang Bisa Diubah

Kalau butuh membangun string secara dinamis—misalnya menerima input pengguna, menyusun pesan log, atau memformat respon API—pilih String. Tipe ini memiliki metode seperti push, push_str, dan insert. Contoh:

let mut identitas = String::from("Nama: ");
identitas.push_str(&nama_pengguna);
identitas.push('\n');
identitas.push_str("Status: aktif");

Selain modifikasi, String juga digunakan ketika data perlu disimpan melebihi scope lokal. Tipe ini memiliki kepemilikan yang jelas dan bisa dikembalikan dari fungsi, dipindahkan ke thread lain, atau disimpan dalam struktur data.

Operasi Dasar: Membuat, Menambah, dan Mengirim

Membuat String

Ada beberapa cara umum membangun String:

  • String::from("teks") untuk literal.
  • "teks".to_string() (cukup idiomatik).
  • Menggabungkan dengan format!() yang mengembalikan String.

Pertimbangkan contoh penggabungan:

let bagian_pertama = "Halo";
let bagian_kedua = "Rust";
let kalimat = format!("{} {}", bagian_pertama, bagian_kedua);
println!("{}", kalimat);

format! menghasilkan String tanpa memodifikasi literal, karena literal tetap dipinjam.

Menambah Isi String

Metode push_str menerima &str dan menambahkannya ke akhir String, sementara push menambahkan satu karakter. Ide dasar:

let mut laporan = String::new();
laporan.push_str("Status: ");
laporan.push_str(status);
laporan.push('\n');

Gunakan String::with_capacity jika tahu ukuran perkiraan untuk menghindari alokasi ulang berkali-kali. Misalnya:

let mut pesan = String::with_capacity(64);
pesan.push_str("Halo");
pesan.push_str(" dan selamat datang!");

Dengan menyediadakan kapasitas, kita mengurangi kerja allocator meskipun logika tetap sederhana.

Mengirim ke Fungsi

Biasanya fungsi menerima &str kecuali memang membutuhkan kepemilikan. Parameter dengan referensi membuat fungsi fleksibel:

fn kirim_email(subjek: &str, badan: &str) {
    println!("Subjek: {}", subjek);
    println!("Badan: {}", badan);
}

let subjek = "Laporan Monthly";
let mut tubuh = String::from("Detail: ");
tubuh.push_str(&detail);
kirim_email(subjek, &tubuh);

Di sini, subjek tetap literal, tubuh dibangun secara dinamis lalu dipinjam sebagai &str dengan &. Fungsi menerima referensi, sehingga tidak perlu mengubah kepemilikan.

Perbandingan dan Pilihan Praktis

Ringkasnya:

  • &str: hemat memori, cocok untuk teks konstan, dipinjam dari parameter atau literal.
  • String: fleksibel untuk data dinamis, cocok saat menulis, menyimpan, atau mengembalikan data dari fungsi.

Kombinasi keduanya sering muncul: buat String untuk manipulasi, lalu serahkan &str ke fungsi lain untuk dibaca. Praktik umum seperti mengumpulkan input pengguna di String lalu memformat pesan sebelum dicetak.

Kesalahan Umum dan Tips Debug

Beberapa kesalahan pemula:

  • Mencoba memodifikasi &str secara langsung. Ingat bahwa literal tidak boleh diubah, dan Rust akan menolak dengan compiler error.
  • Mencoba mengembalikan referensi ke string lokal yang diubah. Contoh fn buat() -> &str dengan String::from di dalam tidak valid karena String di-drop saat fungsi selesai.
  • Lupa menggunakan & saat mengirim String ke fungsi yang menerima &str. Jika fungsi butuh referensi, tuliskan &variabel.

Debugging tips:

  • Perhatikan pesan compiler. Rust memberi saran detail seperti “borrowed value does not live long enough”.
  • Gunakan cargo fmt dan cargo clippy untuk memastikan gaya dan pemakaian referensi tepat.
  • Kalau ragu, awali dengan String karena lebih fleksibel. Setelah itu, lihat apakah referensi bisa dipinjam untuk mencegah alokasi berlebihan.

Kesimpulan

Memahami perbedaan String dan &str adalah dasar menulis program Rust yang jelas dan efisien. Gunakan &str untuk teks statis dan pembacaan saja, serta String ketika aplikasi perlu membangun atau memodifikasi teks. Kombinasi keduanya, dengan manajemen kepemilikan yang tepat, membuat kode Rust mudah ditulis dan dipelihara.

Mulailah dengan mengenali kebutuhan data: apakah teks akan berubah? Apakah perlu dikembalikan dari fungsi? Dari sana, pilih tipe yang paling sesuai. Pelajari pesan compiler saat ada error, dan praktikkan operasi dasar seperti push_str dan peminjaman referensi agar kebingungan hilang perlahan.