Rust Cheat Sheet: ściąga z Rusta
Ostatnia aktualizacja
Hello World i struktura programu
Program w Rust zaczyna się od fn main; instrukcje kończą się średnikiem.
| Operacja | Składnia |
|---|---|
| Punkt wejścia | fn main() { ... } |
| Wypisanie linii | println!("Hello, World!"); |
| Wypisanie z wartościami | println!("{} is {}", name, age); |
| Wypisanie w formie debug | println!("{:?}", value); |
| Komentarz liniowy | // comment |
| Użycie elementu z modułu | use std::collections::HashMap; |
| Kompilacja i uruchomienie | cargo run |
| Kompilacja wersji release | cargo build --release |
Zmienne i typy (let / mut)
Wiązania są domyślnie niemutowalne; dodaj mut, aby pozwolić na ponowne przypisanie.
| Operacja | Składnia |
|---|---|
| Wiązanie niemutowalne | let x = 5; |
| Wiązanie mutowalne | let mut count = 0; |
| Jawny typ | let age: u32 = 30; |
| Stała | const MAX: u32 = 100; |
| Shadowing | let x = x + 1; |
| Typy całkowite | i32, u32, i64, usize |
| Inne typy skalarne | f64, bool, char |
| Krotka | let pair: (i32, &str) = (1, "a"); |
| Konwersja typu | let f = x as f64; |
Instrukcje sterujące
if jest wyrażeniem, a Rust ma trzy rodzaje pętli.
| Operacja | Składnia |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| If jako wyrażenie | let y = if x > 0 { 1 } else { -1 }; |
| Pętla nieskończona | loop { ... } |
| Pętla zwracająca wartość | let v = loop { break 5; }; |
| Pętla while | while x < 100 { ... } |
| Pętla for po zakresie | for i in 0..10 { ... } |
| Pętla for po kolekcji | for item in &items { ... } |
| Break / continue | break;, continue; |
Funkcje
Ostatnie wyrażenie (bez średnika) jest wartością zwracaną.
| Operacja | Składnia |
|---|---|
| Podstawowa funkcja | fn add(a: i32, b: i32) -> i32 { a + b } |
| Jawne zwrócenie wartości | fn f() -> i32 { return 5; } |
| Brak wartości zwracanej | fn log(msg: &str) { ... } |
| Przyjęcie referencji | fn len(s: &String) -> usize { s.len() } |
| Domknięcie | let add = |a, b| a + b; |
| Domknięcie z typem | let sq = |x: i32| -> i32 { x * x }; |
| Funkcja jako argument | fn apply(f: impl Fn(i32) -> i32) { ... } |
Ownership i pożyczanie
Każda wartość ma jednego właściciela; referencje pożyczają ją bez przejmowania własności.
| Operacja | Składnia |
|---|---|
| Przeniesienie (move, zmiana właściciela) | let b = a; (a przestaje być ważne) |
| Klonowanie (głęboka kopia) | let b = a.clone(); |
| Pożyczka niemutowalna | let r = &x; |
| Pożyczka mutowalna | let r = &mut x; |
| Pożyczka w funkcji | fn read(s: &String) { ... } |
| Dereferencja | *r |
| Reguła pożyczania | Wiele & ALBO jedno &mut naraz, nigdy oba |
| Wycinek (pożycza zakres) | let part = &arr[1..3]; |
Struktury i enumy
Struktury grupują powiązane dane; enumy opisują wartość, która jest jednym z kilku wariantów.
| Operacja | Składnia |
|---|---|
| Definicja struktury | struct Point { x: i32, y: i32 } |
| Utworzenie instancji | let p = Point { x: 1, y: 2 }; |
| Dostęp do pola | p.x |
| Struktura krotkowa | struct Pair(i32, i32); |
| Metoda (blok impl) | impl Point { fn dist(&self) -> f64 { ... } } |
| Funkcja powiązana | impl Point { fn new() -> Self { ... } } |
| Definicja enuma | enum Shape { Circle(f64), Rect(f64, f64) } |
| Enum z nazwanymi polami | enum Msg { Move { x: i32, y: i32 } } |
| Wyprowadzenie traitów (derive) | #[derive(Debug, Clone)] |
Dopasowanie wzorców (match)
match porównuje wartość ze wzorcami i musi obejmować wszystkie przypadki.
| Operacja | Składnia |
|---|---|
| Dopasowanie wartości | match x { 1 => "one", _ => "other" } |
| Dopasowanie enuma | match shape { Shape::Circle(r) => ... } |
| Dopasowanie zakresu | match n { 1..=5 => ..., _ => ... } |
| Wiązanie ze strażnikiem (guard) | match x { n if n > 0 => ... } |
| Dopasowanie krotki | match point { (0, y) => ..., (x, _) => ... } |
| if let (jeden wzorzec) | if let Some(v) = opt { ... } |
| while let | while let Some(v) = stack.pop() { ... } |
| Destrukturyzacja struktury | let Point { x, y } = p; |
Traity i typy generyczne
Traity definiują wspólne zachowanie; typy generyczne pozwalają kodowi działać dla wielu typów.
| Operacja | Składnia |
|---|---|
| Definicja traita | trait Area { fn area(&self) -> f64; } |
| Implementacja traita | impl Area for Circle { fn area(&self) -> f64 { ... } } |
| Metoda domyślna | trait Greet { fn hi(&self) { ... } } |
| Funkcja generyczna | fn largest<T: PartialOrd>(list: &[T]) -> &T { ... } |
| Struktura generyczna | struct Wrapper<T> { value: T } |
| Ograniczenie traitem (where) | fn f<T>(x: T) where T: Display { ... } |
| Argument impl Trait | fn print(item: impl Display) { ... } |
| Obiekt traita | let shapes: Vec<Box<dyn Area>> = ...; |
Obsługa błędów (Result / Option)
Rust opisuje brak wartości przez Option, a błędy, które da się obsłużyć, przez Result.
| Operacja | Składnia |
|---|---|
| Wartość opcjonalna | Option<T>: Some(v) lub None |
| Typ Result | Result<T, E>: Ok(v) lub Err(e) |
| Zwrócenie Result | fn read() -> Result<String, Error> { ... } |
| Propagacja przez ? | let data = read()?; |
| Unwrap (panika przy None/Err) | opt.unwrap() |
| Wartość domyślna | opt.unwrap_or(0) |
| Przekształcenie wartości | opt.map(|v| v + 1) |
| Obsługa obu gałęzi | match res { Ok(v) => ..., Err(e) => ... } |
| Zamiana Option na Result | opt.ok_or("missing")? |
Popularne kolekcje (Vec / HashMap)
Vec to rozszerzalna tablica; HashMap to magazyn klucz-wartość.
| Operacja | Składnia |
|---|---|
| Utworzenie wektora | let mut v: Vec<i32> = Vec::new(); |
| Literał wektora | let v = vec![1, 2, 3]; |
| Push / pop | v.push(4);, v.pop(); |
| Dostęp przez indeks | v[0] |
| Bezpieczny dostęp | v.get(0) zwraca Option<&T> |
| Iteracja | for x in &v { ... } |
| Długość | v.len() |
| Utworzenie mapy | let mut m: HashMap<String, i32> = HashMap::new(); |
| Wstawienie / odczyt | m.insert(k, v);, m.get(&k) |
| Entry API | *m.entry(k).or_insert(0) += 1; |
Najczęściej używana składnia Rusta na jednej stronie. Ten Rust cheat sheet to szybka ściąga z rdzenia języka: zmienne i mutowalność, ownership i pożyczanie, struktury i enumy, dopasowanie wzorców, traity i typy generyczne oraz typy Result i Option, na których opiera się obsługa błędów w Rust.
Wszystko tutaj to standardowy Rust, który kompiluje się na aktualnym stabilnym toolchainie. Skopiuj to, czego potrzebujesz, albo uruchom każdy fragment w edytorze online Rusta, bez instalowania cargo.
Rust cheat sheet: FAQ
Czy ten Rust cheat sheet jest darmowy?
Tak. Ten Rust cheat sheet jest całkowicie darmowy i nie wymaga rejestracji. Dodaj go do zakładek i wracaj, gdy potrzebujesz sprawdzić wzorzec match, ograniczenie traitem albo metodę kolekcji.
Czym są ownership i pożyczanie w Rust?
Ownership (własność) to model pamięci Rusta: każda wartość ma dokładnie jednego właściciela i jest zwalniana, gdy ten właściciel wychodzi z zakresu. Pożyczanie pozwala korzystać z wartości bez przejmowania własności dzięki referencji:
&x dla pożyczki niemutowalnej lub &mut x dla mutowalnej. Kompilator pilnuje jednej reguły: naraz możesz mieć wiele pożyczek niemutowalnych albo dokładnie jedną mutowalną, co zapobiega wyścigom danych już na etapie kompilacji.Czym różni się Result od Option w Rust?
Option<T> oznacza wartość, której może nie być: jest to Some(v) albo None, a używasz go, gdy nie ma błędu do zgłoszenia, tylko brakująca wartość. Result<T, E> oznacza operację, która może się nie udać: jest to Ok(v) albo Err(e) z wartością błędu, gdy coś pójdzie nie tak. Używaj Option dla sytuacji „może jest, może nie” i Result dla „to może się nie udać”; operator ? propaguje oba.Czy mogę ćwiczyć Rusta online?
Tak. Otwórz edytor online Rusta, aby skompilować i uruchomić dowolny fragment z tej ściągi w przeglądarce, bez instalowania cargo ani toolchaina. Gdy chcesz nauki krok po kroku, darmowy interaktywny kurs Rusta w Coddy przeprowadzi cię od zmiennych i ownership do traitów i obsługi błędów.
Czy ta ściąga nadaje się dla początkujących?
Tak. Jest uporządkowana od najczęstszych tematów (zmienne, instrukcje sterujące, funkcje) do bardziej zaawansowanych (traity, typy generyczne, obsługa błędów), więc górne sekcje przydadzą się od pierwszego dnia, a ownership i resztę opanujesz z czasem.
Powiązane materiały
Więcej ściąg
