Belajar Pengaturcaraan Rust · Pelajaran

String berbanding &str

Pemilikan teks

Pelajaran 1 daripada 413 langkah

String berbanding &str ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Belajar Pengaturcaraan Rust, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 4 pelajaran.

Teks Dimiliki berbanding Dipinjam

Rust membezakan pemilikan teks kepada dua jenis:

String — memiliki datanya pada timbunan.
&str — meminjam paparan 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 baitnya pada timbunan dan boleh berkembang. Literal rentetan &str terbina dalam perduaan program dan bersifat tetap.

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

Pemilikan Bermaksud Tanggungjawab

Pemilik String membebaskan memorinya apabila keluar daripada skop. &str tidak memiliki apa-apa, jadi ia tidak pernah membebaskan apa-apa.

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

Meminjam String

Anda boleh meminjam String sebagai &str menggunakan &. String masih memiliki data tersebut; hirisan itu hanya melihatnya.

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

Memindahkan String

Menetapkan String kepada pemboleh ubah lain memindahkan pemilikan. Nilai asal tidak boleh 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);
}

Mengklon untuk Mengekalkan Kedua-duanya

Jika anda memerlukan dua rentetan dimiliki yang berasingan, gunakan clone untuk menyalin data.

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

Menyalin &str Tidak Mahal

&str hanyalah penuding dan panjang, jadi menyalinnya tidak menyalin teks asas. Ia melaksanakan Copy.

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

Fungsi dan Pemilikan

Melalukan String mengikut nilai akan memindahkannya ke dalam fungsi. Melalukan &str atau &String hanya meminjamnya, lalu nilai pemanggil masih boleh digunakan.

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

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

Memulangkan Rentetan Dimiliki

Apabila fungsi perlu menghasilkan teks baharu, fungsi itu memulangkan String yang dimiliki supaya pemanggil mengambil pemilikan.

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

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

Memilih Jenis yang Betul

Garis panduan:

Menyimpan teks yang dimiliki? Gunakan String.
Hanya membaca atau melalukan teks? Terima &str.
Membina teks baharu dalam fungsi? Pulangkan 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 Perbezaan Ini Penting

Pemisahan ini membolehkan Rust mengelakkan salinan yang tidak diperlukan dan menjamin keselamatan memori tanpa pengutip sampah. Anda sentiasa tahu siapa yang memiliki sesuatu bahagian teks.

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

Semakan Pantas

Ingat semula perkara yang berlaku apabila anda memindahkan String.

Jawab dalam pelajaran interaktif

Ringkasan

Pemilikan String berbanding &str:

String memiliki data timbunan dan membebaskannya apabila digugurkan.
&str meminjam teks sedia ada dan tidak memiliki apa-apa.
Memindahkan String membatalkan nilai asal; clone menyalinnya.
Terima &str untuk membaca, dan pulangkan String untuk menghasilkan teks baharu.

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

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

Percuma untuk bermula

Pelajari Rust dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 39
Pelajaran: 144

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “String berbanding &str” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “String berbanding &str”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “String berbanding &str”?

Pemilikan teks Anda berlatih Belajar Pengaturcaraan Rust menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Belajar Pengaturcaraan Rust?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Belajar Pengaturcaraan Rust di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “String berbanding &str” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Belajar Pengaturcaraan Rust ini?

Ya. Setiap pelajaran Belajar Pengaturcaraan Rust menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

String berbanding &str
Hirisan
Kaedah String
UTF-8 dan Aksara

← Kembali ke Belajar Pengaturcaraan Rust