Learn Rust Coding · Lekcja

String a &str

Własność napisu

String a &str to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Tekst posiadany a pożyczony

Rust rozróżnia dwa typy własności tekstu:

String — posiada swoje dane na stercie.
&str — pożycza widok tekstu, którego nie posiada.

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

Gdzie znajdują się dane

Typ String przechowuje bajty na stercie i może się powiększać. Literał tekstowy &str jest zapisany w pliku binarnym programu i ma stały rozmiar.

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

Własność oznacza odpowiedzialność

Właściciel wartości String zwalnia zajmowaną przez nią pamięć, gdy wartość wychodzi poza zakres. &str niczego nie posiada, więc niczego nie zwalnia.

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

Pożyczanie wartości String

Można pożyczyć wartość String jako &str, używając &. String nadal posiada dane, a wycinek tylko je odczytuje.

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

Przenoszenie wartości String

Przypisanie wartości String do innej zmiennej przenosi własność. Nie można już używać oryginalnej zmiennej.

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

Klonowanie, aby zachować obie wartości

Jeśli potrzebne są dwa niezależne napisy posiadające własne dane, należy użyć clone, aby skopiować dane.

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

Kopiowanie &str jest tanie

&str to tylko wskaźnik i długość, więc jego kopiowanie nie kopiuje tekstu, na który wskazuje. Implementuje cechę Copy.

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

Funkcje a własność

Przekazanie wartości String przez wartość przenosi ją do funkcji. Przekazanie &str lub &String tylko pożycza dane, dzięki czemu wywołujący nadal może używać swojej wartości.

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

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

Zwracanie napisów posiadających dane

Gdy funkcja musi utworzyć nowy tekst, zwraca posiadającą dane wartość String, aby wywołujący przejął własność.

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

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

Wybór właściwego typu

Wskazówki:

Przechowujesz tekst posiadający własne dane? Użyj String.
Chcesz tylko odczytać tekst lub go przekazać? Przyjmij &str.
Tworzysz nowy tekst w funkcji? Zwróć 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));
}

Dlaczego to rozróżnienie ma znaczenie

Podział ten pozwala Rust unikać niepotrzebnego kopiowania i zapewnia bezpieczeństwo pamięci bez modułu garbage collectora. Zawsze wiadomo, kto jest właścicielem danego fragmentu tekstu.

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

Szybkie sprawdzenie

Przypomnij sobie, co dzieje się podczas przenoszenia wartości String.

Podsumowanie

Własność String a &str:

String posiada dane na stercie i zwalnia je podczas usuwania.
&str pożycza istniejący tekst i niczego nie posiada.
Przeniesienie wartości String unieważnia oryginał; clone tworzy jego kopię.
Przyjmuj &str do odczytu, a zwracaj String, aby utworzyć nowy tekst.

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

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

Często zadawane pytania

Czy lekcja „String a &str” jest bezpłatna?

Tak — pełny tekst „String a &str” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Co nauczysz się w „String a &str”?

Własność napisu Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „String a &str”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Learn Rust Coding