Learn Rust Coding · Lekcja

Napisy i &str

Napisy będące własnością i pożyczone

Napisy i &str to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 2 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.

Dwa typy napisów

Rust ma dwa główne typy tekstowe:

String — napis posiadający własność danych i mogący rosnąć.
&str — pożyczony wycinek napisu, czyli widok na tekst.

fn main() {
    let owned: String = String::from("hello");
    let borrowed: &str = "world";
    println!("{} {}", owned, borrowed);
}

Literały napisowe mają typ &str

Gdy zapisujesz tekst w cudzysłowie, otrzymujesz &str. Jest on stały i przechowywany w pliku binarnym programu.

fn main() {
    let greeting = "Hi there"; // type is &str
    println!("{}", greeting);
}

Tworzenie typu String

Utwórz napis posiadający własność danych za pomocą String::from lub metody .to_string().

fn main() {
    let a = String::from("abc");
    let b = "xyz".to_string();
    println!("{} {}", a, b);
}

Powiększanie napisu

Ponieważ String posiada własność danych i może rosnąć, można do niego dołączać tekst za pomocą push_str i push.

fn main() {
    let mut s = String::from("Hello");
    s.push_str(", ");
    s.push_str("Rust");
    s.push('!');
    println!("{}", s);
}

Łączenie napisów

Łącz napisy za pomocą operatora + lub makra format!. format! nie zużywa swoich argumentów.

fn main() {
    let first = String::from("Hello");
    let second = String::from("World");
    let joined = format!("{} {}", first, second);
    println!("{}", joined);
}

Pożyczanie String jako &str

Typ String może być automatycznie pożyczony jako &str. Dzięki temu funkcje mogą przyjmować oba typy.

fn print_text(text: &str) {
    println!("text: {}", text);
}

fn main() {
    let owned = String::from("owned");
    print_text(&owned);
    print_text("literal");
}

Dlaczego parametry &str są lepszym wyborem

Funkcje zwykle przyjmują &str, a nie String. Jest to bardziej elastyczne: wywołujący może przekazać napis posiadający własność danych, literał lub wycinek.

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

fn main() {
    println!("{}", shout("quiet"));
}

Długość w bajtach

Metoda len() zwraca długość w bajtach, a nie w znakach. Tekst ASCII ma jeden bajt na znak.

fn main() {
    let s = "hello";
    println!("{} bytes", s.len());
}

Sprawdzanie zawartości

Przydatne metody odczytu to między innymi contains, starts_with i is_empty.

fn main() {
    let s = "hello world";
    println!("{}", s.contains("world"));
    println!("{}", s.starts_with("hello"));
}

Różnica w zakresie własności

Typ String posiada dane na stercie i odpowiada za ich zwolnienie. Typ &str tylko pożycza istniejące dane i nie posiada ich na własność.

fn main() {
    let owned = String::from("data");
    let view: &str = &owned[0..2];
    println!("owned {} view {}", owned, view);
}

Konwersja między nimi

Konwertuj w obie strony:

&str na String: .to_string() lub String::from.
String na &str: &s lub s.as_str().

fn main() {
    let s = String::from("convert");
    let slice: &str = s.as_str();
    let back: String = slice.to_string();
    println!("{} {}", slice, back);
}

Szybkie sprawdzenie

Przypomnij sobie różnicę między dwoma typami tekstowymi.

Podsumowanie

Napisy w Rust:

String — posiadający własność danych, mogący rosnąć i alokowany na stercie.
&str — pożyczony wycinek lub widok; taki typ mają literały.
Utwórz za pomocą String::from lub to_string(); powiększaj za pomocą push_str.
Preferuj &str jako parametr funkcji.

fn main() {
    let mut msg = String::from("Rust");
    msg.push_str(" rocks");
    let view: &str = &msg;
    println!("{} ({} bytes)", view, view.len());
}

Często zadawane pytania

Czy lekcja „Napisy i &str” jest bezpłatna?

Tak — pełny tekst „Napisy i &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 „Napisy i &str”?

Napisy będące własnością i pożyczone Ć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 2 z 4.

Ile czasu zajmuje lekcja „Napisy i &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