כל מה שאתה צריך לדעת כדי להתחיל לכתוב חלודה

מאז השקתו ב-2015, Rust צברה פופולריות כאחת משפות התכנות המועדפות על מפתחים. Rust מציעה ביצועים מצוינים ותכונות אבטחה עם תחביר אינטואיטיבי ותמציתי שהופכים את השפה לנחשקת.

Rust מתאים לבניית תוכניות שונות, כולל אפליקציות אינטרנט, כלים בשורת הפקודה ושירותי רשת. Rust כולל תכונות רבות שתצפו משפת תכנות מודרנית, כמו מקבילות, מסקנות מסוג ועוד.

תחילת העבודה עם חלודה

Rust היא שפת תכנות חוצת פלטפורמות הפועלת ברוב מערכות ההפעלה. כדי להתחיל עם Rust, עבור אל הגורם הרשמי אתר חלודה והתקן את הגרסה המועדפת עבור מערכת ההפעלה שלך.

לאחר התקנת Rust, תוכל להתחיל לכתוב תוכניות בקבצי Rust עם א .rs סיומת. חלודה היא תכליתית וקלה ללמידה. אתה תמצא את זה פשוט אם יש לך ניסיון קודם בתכנות.

משתנים וקבועים בחלודה

חלודה היא מאוד אקספרסיבית, וישנן מספר דרכים להכריז על משתנים. אתה יכול להשתמש ב לתת מילת מפתח להצהרה על משתנים.

כך תוכל להכריז על משתנים ב- Rust:

לתת א: חוּט;
לתת ב: i32;
לתת c: () = ();

ה א ו ב משתנים הם מחרוזת ומספר שלם, בהתאמה. ה ג משתנה הוא סוג יחידת Rust שפועל כמציין מיקום לפונקציות וביטויים.

לאחר הצהרת סוג הנתונים האופציונלית, ניתן להצהיר ולאתחל משתנים עם ערכים באמצעות סימן שוויון.

fnרָאשִׁי(){
לתת גיל: חוּט = חוּט::מ("בן חמש שנים");
לתת גיל = 5; // שווה ערך לתת גיל: i32 = 5;
println!("{}", גיל);
}

התוכנית מצהירה על שניים גיל משתנים לפני הדפסה עם println! מאקרו. הראשון גיל המשתנה מציין את סוג הנתונים, והשני לא.

אינך צריך לציין את סוג הנתונים של משתנה כאשר אתה מצהיר עליו. מהדר Rust מסיק את הסוג מסוג הנתונים של הערך בזמן ההידור.

אתה יכול גם להכריז על קבועים ב-Rust עם ה const מילת מפתח באופן דומה להצהרת משתנים:

const גיל: &str = "בן חמש שנים";

אתה לא יכול לשנות את הערך של משתנה שאתה מכריז כקבוע.

חלודה מספקת פונקציונליות להערות בשורה אחת ובלוק. אתה יכול להשתמש באלכסונים כפולים קדימה (//) להערות בשורה אחת:

fnרָאשִׁי() {
// זוהי הערת שורה
לתת x = 5; // הערה זו מסבירה את מטרת המשתנה 'x'
}

להערות מרובות שורות (הערות חסימה), השתמש בקו נטוי קדימה ואחריו כוכבית (/*) וסגור את הבלוק עם כוכבית ואחריה קו נטוי קדימה (*/):

fnרָאשִׁי() {
/*
 זוהי הערת בלוק המשתרעת על פני מספר שורות.
 הוא משמש לעתים קרובות לתיאור גוש קוד גדול יותר.
 */
לתת x = 5;
}

ההערות שלך צריכות להיות תמציתיות ופשוטות.

מערכים בחלודה

מערכים הם אוסף בגודל קבוע של אלמנטים מאותו סוג נתונים. Rust מקצה מערכים בערימה כברירת מחדל.

כך תוכל להכריז על מערכים ב- Rust:

fnרָאשִׁי() {
לתת מספרים = [1, 2, 3, 4, 5];
}

ה מספרים מערך מכיל חמישה פריטים. אתה יכול לגשת לערך במיקום במערך באמצעות האינדקס שלו:

fnרָאשִׁי() {
לתת מספרים = [1, 2, 3, 4, 5];
לתת x = מספרים[3];
println!("{}", איקס)
}

ה רָאשִׁי הפונקציה מדפיסה את איקס משתנה הניגש לאלמנט הרביעי של המערך.

וקטורים בחלודה

חלודה מספקת וקטורים כדי לכסות את המגבלות של המערך. וקטורים הם בגודל דינמי; הם יכולים לגדול ולהצטמצם לפי הצורך.

כך תוכל להכריז על וקטורים ב- Rust:

fnרָאשִׁי() {
לתת my_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
לתת x = my_vec[3];
println!("{}", איקס)
}

ה my_vec וקטור הוא וקטור של מספרים שלמים של 32 סיביות. ה איקס משתנה ניגש לאלמנט הרביעי של הווקטור, ול- רָאשִׁי הפונקציה מדפיסה את הערך לקונסולה.

ההצהרות המותנות של Rust

הצהרות מותנות הן אחת מהן מבני הבקרה של חלודה לקבלת החלטות בתוכניות. אתה יכול להשתמש ב אם ו אַחֵר מילות מפתח לטיפול בהחלטות בתוכניות שלך.

הנה א אם הצהרה שמדפיסה מחרוזת למסוף בהתבסס על שוויון של שני מספרים שלמים.

fnרָאשִׁי() {
לתת א: i32 = 12;
אם a == 12 {
println!("א שווה שתים עשרה");
 }
}

ה רָאשִׁי הפונקציה מדפיסה את המחרוזת עם println! מאקרו מכיוון שהמשתנה שווה ל-12.

אתה יכול להשתמש ב אַחֵר מילת מפתח לטיפול במקרים שבהם ה אם הצהרה מעריכה שקר:

fnרָאשִׁי() {
לתת א: i32 = 12;
אם a == 123 {
println!("א שווה שתים עשרה");
 } אַחֵר {
println!("א לא שווה שתים עשרה");
 }
}

בדוגמה זו, ה אַחֵר המשפט פועל מכיוון שהערך של a אינו שווה ל-123.

אתה יכול להכריז על הצהרות התאמה עם התאמה מילת מפתח עבור תנאים מורכבים:

fnרָאשִׁי() {
לתת גיל: i32 = 7;
התאמה גיל {
1 => println!("אחד"),
2 => println!("שתיים"),
3 => println!("שְׁלוֹשָׁה"),
 _ => println!("אֶפֶס"),
 }
}

ה רָאשִׁי הפונקציה תואמת את גיל משתנה למקרים ב- התאמה משפט ומבצע את הביטוי התואם את הערך. הקו התחתון (_) הוא משפט ברירת המחדל שפועל אם יש התאמה לערך.

לולאות בחלודה

חלודה מספקת לולאות למשימות שחוזרות על עצמן. לחלודה שלושה סוגים עיקריים של לולאות: לוּלָאָה, בזמן, ו ל לולאות.

ה לוּלָאָה מילת מפתח יוצרת לולאה אינסופית הפועלת עד שהיא נתקלת במילת מפתח הפסקה:

fnרָאשִׁי() {
לוּלָאָה {
println!("מודפס שוב ושוב עד שנתקל בהצהרת הפסקה.");
לשבור;
 }
}

ה בזמן לולאה שימושית כאשר אתה רוצה לחזור על גוש קוד כל עוד תנאי מוערך כאמת:

fnרָאשִׁי() {
לתתמוט לספור = 0;
בזמן לספור < 5 {
println!("הספירה היא {}", לספור);
 לספור += 1;
 }
}

א ל לולאה טובה לחזרה על אוסף של פריטים, כמו מערך:

fnרָאשִׁי() {
לתת מספרים = [1, 2, 3, 4, 5];
ל פריט ב numbers.iter() {
println!("הפריט הנוכחי הוא {}", פריט);
 }
}

זֶה ל לולאה חוזרת דרך מספרים מערך ומדפיס כל פריט לקונסולה.

הכרזה וקריאה של פונקציות חלודה

להשתמש ב fn מילת מפתח ל להכריז על פונקציית חלודה, ואחריו שם הפונקציה, רשימת פרמטרים וסוג החזרה (אם יש).

כך תוכל להכריז על פונקציה עם פרמטרים וסוג החזרה:

fnלְהוֹסִיף(א: i32,ב: i32) -> i32 {
לַחֲזוֹר a + b;
}

ה לְהוֹסִיף הפונקציה לוקחת שני מספרים שלמים של 32 סיביות ומחזירה מספר שלם של 32 סיביות, סכום שני הפרמטרים.

כדי לקרוא לפונקציה ממקום אחר בקוד שלך, פשוט ציין את השם והארגומנטים (אם יש):

fnרָאשִׁי() {
לתת תוצאה = הוסף(2, 3);
println!("2 + 3 = {}", תוצאה);
}

ה תוֹצָאָה משתנה מחזיק את התוצאה מקריאה ל- לְהוֹסִיף פוּנקצִיָה. ה רָאשִׁי הפונקציה מדפיסה את התוצאה למסוף באמצעות ה- println! מאקרו.

מבנים בחלודה

Rust מספק מבנים להגדרת סוגי נתונים מותאמים אישית המקבצים ערכים קשורים. מבנים הם שרטוטים ליצירת אובייקטים בעלי מאפיינים ספציפיים.

כך תוכל להכריז על מבנה:

structאדם {
 שֵׁם: חוּט,
 גיל: u32,
 הוא_זכר: bool,
}

ה אדם ל-struct יש שלושה שדות: מחרוזת, מספר שלם של 32 סיביות ללא סימן ובוליאני.

לאחר הגדרת מבנה, תוכל ליצור מופעים שלו בחלקים אחרים של התוכנית שלך:

fnרָאשִׁי() {
לתת person1 = אדם {
 שֵׁם: חוּט::מ("קנדס פלין"),
 גיל: 16,
 הוא_זכר: שֶׁקֶר,
 };
}

ה אדם1 משתנה הוא מופע של ה אדם struct. במופע, אתה יכול להקצות ערכים לשדות ה-struct. אתה יכול ליצור כמה מופעים של מבנה שתרצה.

אתה יכול ליישם קונספטים של OOP בחלודה

Rust גמיש, ואתה יכול ליישם את מושגי ה-OOP ב-Rust עם מבני נתונים מובנים כמו מבנים.

אתה תשתמש במבנים כחלופה לשיעורים. עם המבנה של Rust, אתה יכול להגדיר תוכנית לסוג וליישם את מושגי OOP השונים עם הפונקציונליות ש-Rust מספקת על מבנים.