Learn Rust Coding · Pelajaran

String vs &str

Kepemilikan teks

Pelajaran 1 dari 413 langkah

String vs &str adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Teks Dimiliki vs Dipinjam

Rust memisahkan kepemilikan teks menjadi dua tipe:

String — memiliki datanya di heap.
&str — meminjam tampilan teks yang tidak dimilikinya.

fn main() {
    let owned = String::from("I own this");
    let borrowed: &str = "I am borrowed";
    println!("{} / {}", owned, borrowed);
}

Tempat Data Disimpan

String menyimpan byte-nya di heap dan dapat bertambah besar. Literal string &str tertanam dalam biner program dan ukurannya tetap.

fn main() {
    let mut heap = String::from("grows");
    heap.push_str(" bigger");
    let fixed = "never changes";
    println!("{} | {}", heap, fixed);
}

Kepemilikan Berarti Tanggung Jawab

Pemilik String membebaskan memorinya saat keluar dari cakupan. &str tidak memiliki apa pun, sehingga tidak pernah membebaskan apa pun.

fn main() {
    {
        let s = String::from("temporary");
        println!("{}", s);
    } // s is dropped and its memory freed here
    println!("done");
}

Meminjam String

Anda dapat meminjam String sebagai &str menggunakan &. String tetap memiliki datanya; irisan tersebut hanya melihatnya.

fn main() {
    let owned = String::from("shared text");
    let view: &str = &owned;
    println!("{} / {}", owned, view);
}

Memindahkan String

Menetapkan String ke variabel lain memindahkan kepemilikannya. Nilai asli tidak dapat digunakan lagi.

fn main() {
    let a = String::from("hello");
    let b = a; // ownership moves to b
    // println!("{}", a); // would error: a was moved
    println!("{}", b);
}

Menggandakan agar Keduanya Tetap Ada

Jika Anda memerlukan dua string dimiliki yang independen, gunakan clone untuk menyalin datanya.

fn main() {
    let a = String::from("hello");
    let b = a.clone();
    println!("{} and {}", a, b);
}

Menyalin &str Itu Murah

&str hanyalah pointer dan panjang, sehingga menyalinnya tidak menyalin teks yang mendasarinya. Tipe ini mengimplementasikan Copy.

fn main() {
    let original = "data";
    let copy = original; // both still valid
    println!("{} {}", original, copy);
}

Fungsi dan Kepemilikan

Meneruskan String berdasarkan nilai akan memindahkannya ke dalam fungsi. Meneruskan &str atau &String hanya meminjamnya, sehingga nilai milik pemanggil tetap dapat digunakan.

fn length(s: &str) -> usize {
    s.len()
}

fn main() {
    let text = String::from("measure me");
    println!("{}", length(&text));
    println!("still here: {}", text);
}

Mengembalikan String yang Dimiliki

Saat fungsi harus menghasilkan teks baru, fungsi tersebut mengembalikan String yang dimiliki agar pemanggil mengambil kepemilikannya.

fn make_greeting(name: &str) -> String {
    format!("Hello, {}!", name)
}

fn main() {
    let g = make_greeting("Rust");
    println!("{}", g);
}

Memilih Tipe yang Tepat

Panduan:

Menyimpan teks yang dimiliki? Gunakan String.
Hanya membaca atau meneruskan teks? Terima &str.
Membangun teks baru dalam fungsi? Kembalikan String.

fn first_word(s: &str) -> &str {
    s.split_whitespace().next().unwrap_or("")
}

fn main() {
    let sentence = String::from("learn rust today");
    println!("{}", first_word(&sentence));
}

Mengapa Perbedaan Ini Penting

Pemisahan ini memungkinkan Rust menghindari penyalinan yang tidak perlu dan menjamin keamanan memori tanpa pengumpul sampah. Anda selalu mengetahui siapa yang memiliki bagian teks tertentu.

fn main() {
    let owned = String::from("safe");
    let borrowed = &owned[..];
    println!("owner {} borrows {}", owned, borrowed);
}

Pemeriksaan Singkat

Ingat kembali apa yang terjadi saat Anda memindahkan String.

Jawab di pelajaran interaktif

Ringkasan

Kepemilikan String vs &str:

String memiliki data di heap dan membebaskannya saat dilepas.
&str meminjam teks yang sudah ada dan tidak memiliki apa pun.
Memindahkan String membuat nilai asli tidak valid; clone menyalinnya.
Terima &str untuk membaca, dan kembalikan String untuk menghasilkan teks baru.

fn shout(s: &str) -> String {
    s.to_uppercase()
}

fn main() {
    let name = String::from("rust");
    let loud = shout(&name);
    println!("{} -> {}", name, loud);
}

Gratis untuk memulai

Belajar Rust dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 39
Pelajaran: 144

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “String vs &str” gratis?

Ya — teks lengkap “String vs &str” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “String vs &str”?

Kepemilikan teks Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “String vs &str” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Learn Rust Coding