סקירה כללית של סוגי הנתונים המובנים של Rust

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

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

מספרים שלמים בחלודה

Rust מספקת סוגי מספרים שלמים חתומים ולא חתומים המסווגים על סמך מספר הביטים. סוגי המספרים השלמים החתומים הם i8, i16, i32, ו i64 המייצגים מספרים שלמים עם סימנים של 8 סיביות, 16 סיביות, 32 סיביות ו-64 סיביות, בהתאמה. זה גם תומך בסוגי מספרים שלמים לא חתומים u8, u16, u32, ו u64, המייצג מספרים שלמים ללא סימנים של 8 סיביות, 16 סיביות, 32 סיביות ו-64 סיביות.

// מספרים שלמים חתומים
לתת a: i8 = -10;
לתת b: i16 = -2048;
לתת c: i32 = -2147483648;
לתת d: i64 = -9223372036854775808;
// מספרים שלמים ללא סימנים
לתת ה: u8 = 255;
לתת f: u16 = 65535;
לתת g: u32 = 4294967295;
לתת h: u64 = 18446744073709551615;

חלודה משתמשת ב i32 הקלד עבור מילים שלמים כברירת מחדל.

סוגי נקודות צפה חלודה

חלודה מספקת f32 ו f64 כסוגי נקודה צפה המייצגים מספרי נקודה צפה עם דיוק יחיד ודיוק כפול. ה f32 type משתמש ב-32 סיביות לאחסון ערכים, וה- f64 סוג משתמש ב-64 סיביות.

מספרי נקודה צפה ב-Rust עומדים בתקן IEEE 754 עבור אריתמטיקה של נקודה צפה.

לתת א = 3.14159265358979323_f32;
לתת ב = 2.718281828459045235_f64;

שימוש בבוליאנים של חלודה

חלודה מספקת א bool הקלד לייצג נָכוֹן אוֹ שֶׁקֶר ערכים. בוליאנים משמשים לעתים קרובות בהצהרות זרימה מותנית ובקרה לקבלת החלטות בתוכנית.

לתת משתנה_1: bool = נָכוֹן;
לתת משתנה_2: bool = שֶׁקֶר;

אתה יכול להשוות ערכים בוליאניים עם אופרטור השוויון, ==, ומפעיל אי השוויון, !=. חלודה לא מגדירה את אופרטורי ההשוואה, , <=, ו >=, ל bool ערכים.

לתת משתנה_1: bool = נָכוֹן;
לתת משתנה_2: bool = שֶׁקֶר;
if variable_1 == variable_2 {
 println!("משתנה_1 שווה למשתנה_2");
} אַחֵראם משתנה_1 != משתנה_2 {
 println!("משתנה_1 אינו שווה למשתנה_2");
}

סוג Char

החלודה לְהַשְׁחִיר type מייצג ערך סקלרי יחיד של Unicode שיכול לייצג כל תו ב תקן Unicode. אתה יכול לציין א לְהַשְׁחִיר ערך באמצעות מרכאות בודדות.

// הכרזה על ערך char
לתת c = 'א';

ה לְהַשְׁחִיר סוג מועיל לעבודה עם אימוג'ים ב- Rust.

טופלים בחלודה

מבנה הנתונים של tuple מאפשר לך לקבץ יותר מערך אחד לערך מורכב יחיד. לערכים אלה יכולים להיות אותו סוג או סוגים שונים. אתה יכול להכריז על tuples על ידי כתיבתם כרשימה מופרדת בפסיקים של ערכים מוקפת בסוגריים.

הנה איך אתה יכול להכריז על tuple עם מספרים שלמים של 32 סיביות, מחרוזות וערכי float64.

לתת tup: (i32, &str, f64) = (500, "שלום", 3.14);

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

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

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

לתת my_tuple = (10, "שלום עולם!", שֶׁקֶר);
לתת (x, y, z) = my_tuple;
println!("האלמנט הראשון הוא: {}", איקס);
println!("האלמנט השני הוא: {}", y);
println!("האלמנט השלישי הוא: {}", ז);

כך תוכל לגשת לאלמנטים בודדים באמצעות סימון נקודות:

לתת my_tuple = (10, "שלום עולם!", שֶׁקֶר);
println!("הראשוןאֵלֵמֶנטהוא: {}", my_tuple.0);
println!("השְׁנִיָהאֵלֵמֶנטהוא: {}", my_tuple.1);
println!("השְׁלִישִׁיאֵלֵמֶנטהוא: {}", my_tuple.2);

Tuples שימושיים מאוד בעת קיבוץ נתונים קשורים לערך בודד. הם יכולים גם לשפר את הקריאות של הקוד שלך אם אתה משתמש בהם במשורה.

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

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

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

לתת arr = [1, 2, 3, 4, 5];

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

לתת mut my_array = [1, 2, 3, 4, 5];
// גישה לאלמנטים
println!("הראשוןאֵלֵמֶנטהוא: {}", המערך_שלי[0]);
// שינוי אלמנטים
my_array[0] = 100;
println!("הראשוןאֵלֵמֶנטלאחרשינויהוא: {}", המערך_שלי[0]);
// לולאה מעל מערך ולטפל באלמנטים
לאניב 0..my_array.len() {
 my_array[i] *= 2;
}
// הדפסת המערך
println!("המערך לאחר מניפולציה: {:?}", my_array);

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

עבודה עם פרוסות חלודה

פרוסה היא מבנה נתונים המאפשר התייחסות לרצף רציף של אלמנטים באוסף. פרוסות מיוצגות על ידי &[T] type, כאשר T הוא סוג האלמנטים המאוחסנים בפרוסה.

fn רָאשִׁי(){
// להכריז על מערך
לתת שלי_מערך = [1, 2, 3, 4, 5];
// צור פרוסה מהמערך
לתת שלי_slice = &my_array[1..3];
// הדפס את הפרוסה
 println!("פרוסה: {:?}", שלי_פרוסה);
}

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

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

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

אתה יכול לבנות אפליקציות אינטרנט חזיתיות המופעלות על ידי WebAssembly ב- Rust

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

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

WebAssembly זוכה לאימוץ באמצעות Rust. ישנן מסגרות רבות כמו Yew, Sycamore ו-Seed שבהן אתה יכול להשתמש כדי לבנות חזיתות מבוססות WebAssembly עם Rust.