Rust Cheat Sheet: דף עזר מהיר
עודכן לאחרונה
Hello World ומבנה
תוכנית Rust מתחילה ב-fn main; פקודות מסתיימות בנקודה-פסיק.
| פעולה | תחביר |
|---|---|
| נקודת כניסה | fn main() { ... } |
| הדפסת שורה | println!("Hello, World!"); |
| הדפסה עם ערכים | println!("{} is {}", name, age); |
| הדפסה בפורמט debug | println!("{:?}", value); |
| הערת שורה | // comment |
| שימוש בפריט ממודול | use std::collections::HashMap; |
| בנייה והרצה | cargo run |
| בניית קובץ הרצה ל-release | cargo build --release |
משתנים וטיפוסים (let / mut)
קישורים (bindings) הם בלתי ניתנים לשינוי כברירת מחדל; הוסיפו mut כדי לאפשר השמה מחדש.
| פעולה | תחביר |
|---|---|
| קישור בלתי ניתן לשינוי | let x = 5; |
| קישור שניתן לשינוי | let mut count = 0; |
| טיפוס מפורש | let age: u32 = 30; |
| קבוע | const MAX: u32 = 100; |
| הצללה (Shadowing) | let x = x + 1; |
| טיפוסי מספרים שלמים | i32, u32, i64, usize |
| סקלרים אחרים | f64, bool, char |
| Tuple | let pair: (i32, &str) = (1, "a"); |
| המרת טיפוס | let f = x as f64; |
בקרת זרימה
if הוא ביטוי, ול-Rust יש שלוש צורות של לולאה.
| פעולה | תחביר |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| if כביטוי | let y = if x > 0 { 1 } else { -1 }; |
| לולאה אינסופית | loop { ... } |
| לולאה שמחזירה ערך | let v = loop { break 5; }; |
| לולאת while | while x < 100 { ... } |
| for על טווח | for i in 0..10 { ... } |
| for על אוסף | for item in &items { ... } |
| Break / continue | break;, continue; |
פונקציות
הביטוי האחרון (בלי נקודה-פסיק) הוא הערך המוחזר.
| פעולה | תחביר |
|---|---|
| פונקציה בסיסית | fn add(a: i32, b: i32) -> i32 { a + b } |
| החזרה מפורשת | fn f() -> i32 { return 5; } |
| בלי ערך מוחזר | fn log(msg: &str) { ... } |
| קבלת הפניה (reference) | fn len(s: &String) -> usize { s.len() } |
| Closure | let add = |a, b| a + b; |
| Closure עם טיפוס | let sq = |x: i32| -> i32 { x * x }; |
| פונקציה כארגומנט | fn apply(f: impl Fn(i32) -> i32) { ... } |
Ownership ו-borrowing
לכל ערך יש בעלים אחד; הפניות שואלות אותו בלי לקחת בעלות.
| פעולה | תחביר |
|---|---|
| Move (העברת בעלות) | let b = a; (a כבר לא תקף) |
| Clone (העתקה עמוקה) | let b = a.clone(); |
| השאלה בלתי ניתנת לשינוי | let r = &x; |
| השאלה שניתנת לשינוי | let r = &mut x; |
| השאלה בפונקציה | fn read(s: &String) { ... } |
| Dereference | *r |
| כלל ההשאלה | הרבה & או &mut אחד בכל רגע נתון, לא שניהם |
| Slice (השאלה של טווח) | let part = &arr[1..3]; |
Structs ו-enums
Structs מקבצים נתונים קשורים; enums מתארים ערך שהוא אחת מכמה אפשרויות (variants).
| פעולה | תחביר |
|---|---|
| הגדרת struct | struct Point { x: i32, y: i32 } |
| יצירת מופע | let p = Point { x: 1, y: 2 }; |
| גישה לשדה | p.x |
| Tuple struct | struct Pair(i32, i32); |
| מתודה (בלוק impl) | impl Point { fn dist(&self) -> f64 { ... } } |
| פונקציה משויכת | impl Point { fn new() -> Self { ... } } |
| הגדרת enum | enum Shape { Circle(f64), Rect(f64, f64) } |
| Enum עם שדות בשם | enum Msg { Move { x: i32, y: i32 } } |
| גזירת traits (derive) | #[derive(Debug, Clone)] |
Pattern matching (match)
match משווה ערך מול תבניות וחייב לכסות את כל המקרים.
| פעולה | תחביר |
|---|---|
| match על ערכים | match x { 1 => "one", _ => "other" } |
| match על enum | match shape { Shape::Circle(r) => ... } |
| match על טווח | match n { 1..=5 => ..., _ => ... } |
| קישור עם תנאי (guard) | match x { n if n > 0 => ... } |
| match על tuple | match point { (0, y) => ..., (x, _) => ... } |
| if let (תבנית יחידה) | if let Some(v) = opt { ... } |
| while let | while let Some(v) = stack.pop() { ... } |
| פירוק struct | let Point { x, y } = p; |
Traits ו-generics
Traits מגדירים התנהגות משותפת; generics מאפשרים לקוד לעבוד עם הרבה טיפוסים.
| פעולה | תחביר |
|---|---|
| הגדרת trait | trait Area { fn area(&self) -> f64; } |
| מימוש trait | impl Area for Circle { fn area(&self) -> f64 { ... } } |
| מתודת ברירת מחדל | trait Greet { fn hi(&self) { ... } } |
| פונקציה גנרית | fn largest<T: PartialOrd>(list: &[T]) -> &T { ... } |
| struct גנרי | struct Wrapper<T> { value: T } |
| הגבלת trait (where) | fn f<T>(x: T) where T: Display { ... } |
| ארגומנט impl Trait | fn print(item: impl Display) { ... } |
| Trait object | let shapes: Vec<Box<dyn Area>> = ...; |
טיפול בשגיאות (Result / Option)
Rust מייצגת היעדר ערך עם Option ושגיאות שניתן להתאושש מהן עם Result.
| פעולה | תחביר |
|---|---|
| ערך אופציונלי | Option<T>: Some(v) או None |
| הטיפוס Result | Result<T, E>: Ok(v) או Err(e) |
| החזרת Result | fn read() -> Result<String, Error> { ... } |
| העברת שגיאה הלאה עם ? | let data = read()?; |
| Unwrap (גורם ל-panic על None/Err) | opt.unwrap() |
| ערך ברירת מחדל | opt.unwrap_or(0) |
| המרת ערך (map) | opt.map(|v| v + 1) |
| טיפול בשני המקרים | match res { Ok(v) => ..., Err(e) => ... } |
| המרת Option ל-Result | opt.ok_or("missing")? |
אוספים נפוצים (Vec / HashMap)
Vec הוא מערך שיכול לגדול; HashMap הוא מאגר של מפתח וערך.
| פעולה | תחביר |
|---|---|
| יצירת ווקטור | let mut v: Vec<i32> = Vec::new(); |
| ליטרל של ווקטור | let v = vec![1, 2, 3]; |
| Push / pop | v.push(4);, v.pop(); |
| גישה לפי אינדקס | v[0] |
| גישה בטוחה | v.get(0) מחזיר Option<&T> |
| מעבר על האיברים | for x in &v { ... } |
| אורך | v.len() |
| יצירת map | let mut m: HashMap<String, i32> = HashMap::new(); |
| הכנסה / קבלה | m.insert(k, v);, m.get(&k) |
| Entry API | *m.entry(k).or_insert(0) += 1; |
התחביר של Rust שאתם צריכים הכי הרבה, בעמוד אחד. ה-Rust cheat sheet הזה הוא דף עזר מהיר לליבת השפה: משתנים ו-mutability, ownership ו-borrowing, structs ו-enums, pattern matching, traits ו-generics, והטיפוסים Result ו-Option שעומדים מאחורי הטיפול בשגיאות ב-Rust.
כל מה שכאן הוא Rust סטנדרטי שמתקמפל בגרסת stable עדכנית. העתיקו את מה שאתם צריכים, או נסו כל קטע קוד בזמן אמת בעורך האונליין של Rust, בלי להתקין cargo.
שאלות נפוצות על ה-Rust cheat sheet
האם ה-Rust cheat sheet הזה חינמי?
כן. ה-Rust cheat sheet הזה חינמי לגמרי, בלי צורך בהרשמה. שמרו אותו במועדפים וחזרו אליו בכל פעם שתצטרכו לבדוק תבנית match, הגבלת trait או מתודה של אוסף.
מה זה ownership ו-borrowing ב-Rust?
Ownership הוא מודל הזיכרון של Rust: לכל ערך יש בדיוק בעלים אחד, והערך משוחרר כשהבעלים יוצא מהטווח (scope). Borrowing מאפשר לגשת לערך בלי לקחת עליו בעלות, בעזרת הפניה:
&x להשאלה בלתי ניתנת לשינוי או &mut x להשאלה שניתנת לשינוי. הקומפיילר אוכף כלל אחד: בכל רגע נתון אפשר להחזיק הרבה השאלות בלתי ניתנות לשינוי או בדיוק השאלה אחת שניתנת לשינוי, וכך נמנעים מרוצי נתונים (data races) כבר בזמן הקומפילציה.מה ההבדל בין Result ל-Option ב-Rust?
Option<T> מייצג ערך שעשוי להיות חסר: הוא Some(v) או None, ומשתמשים בו כשאין שגיאה לדווח עליה, רק ערך חסר. Result<T, E> מייצג פעולה שעלולה להיכשל: הוא Ok(v) או Err(e), ונושא ערך שגיאה כשמשהו משתבש. השתמשו ב-Option עבור "אולי קיים" וב-Result עבור "זה עלול להיכשל"; האופרטור ? מעביר את שניהם הלאה.אפשר לתרגל Rust אונליין?
כן. פתחו את עורך האונליין של Rust כדי לקמפל ולהריץ כל קטע קוד מדף העזר הזה בדפדפן, בלי להתקין cargo או toolchain. כשתרצו מסגרת מסודרת, קורס ה-Rust האינטראקטיבי והחינמי של Coddy ייקח אתכם צעד אחר צעד ממשתנים ו-ownership ועד traits וטיפול בשגיאות.
האם דף העזר הזה מתאים למתחילים?
כן. הוא מסודר מהנושאים הנפוצים ביותר (משתנים, בקרת זרימה, פונקציות) ועד המתקדמים (traits, generics, טיפול בשגיאות), כך שאפשר להשתמש בחלקים העליונים כבר מהיום הראשון ולהתקדם ל-ownership ולשאר בהמשך.
משאבים קשורים
עוד דפי עזר
