ארגון פרויקטי חלודה עם חבילות, נתיבים ומודולים

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

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

הקמת פרויקטים של חלודה

הגדרת פרויקטים של Rust היא קלה לאחר שהתקנת Rust על המחשב שלך; אתה יכול להשתמש ב-Cargo (מנהל החבילות המובנה ומערכת הבנייה של Rust) כדי ליצור ולהגדיר פרויקט Rust. זה דומה למנהלי חבילות אחרים כמו npm עבור Node.js ו pip עבור Python. Cargo מנהל תלות, קומפילציה של קוד ומייצר תיעוד, מה שהופך אותו לכלי חיוני לפיתוח Rust.

הפעל פקודה זו כדי לאמת את התקנת Cargo שלך:

מטען --גרסה

הפקודה מציגה את גרסת המטען המותקנת.

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

cargo new my_project

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

מרחב השמות של חבילת חלודה

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

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

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

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

הנה דוגמה לייבוא ​​an Rng פונקציה מא ראנד אַרְגָז:

להשתמש rand:: Rng;

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

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

הנה דוגמה לגישה לפונקציה ממרחב שמות אחר:

// קובץ במרחב השמות של תיקייה1
פָּאבּfnתיקייה() -> u32 {
// גוף פונקציה כאן
לַחֲזוֹר0;
}
// קובץ במרחב השמות של תיקייה2
להשתמש תיקייה1::תיקייה;
פָּאבּfnמַדרִיך() {
// גישה לפונקציית התיקייה ממרחב השמות של תיקייה1
לתת folder_func = תיקייה();
}

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

ה תיקייה2 מודול מייבא את תיקייה פונקציה מה תיקייה1 מרחב שמות עם ה- להשתמש מילת מפתח, המאפשרת את מַדרִיך פונקציה כדי לגשת ל תיקייה פונקציה מה תיקייה1 מודול. ה מַדרִיך הפונקציה קוראת ל- תיקייה פונקציה, וערך ההחזרה מוקצה ל- folder_func מִשְׁתַנֶה.

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

הנה דוגמה לפונקציה ציבורית שניתן לייצא.

// פונקציה מיוצאת לחבילות וארגזים אחרים
פָּאבּfnMyFunction() {
// גוף פונקציה כאן
}

תצטרך גם להשתמש ב- פָּאבּ מילת מפתח. ב- Rust, ה פָּאבּ מילת מפתח היא קיצור של פּוּמְבֵּי. כאשר פונקציה, מבנה, enum, כל סוג נתוני חלודה או מודול מסומן במילת המפתח פאב, הוא הופך לנגיש מחוץ למודול שלו. הפריט פרטי למודול שלו ללא מילת המפתח פאב וניתן לגשת אליו רק מתוכו.

הגדרת מודולים לשליטה בהיקף ובפרטיות

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

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

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

להלן התחביר למודול פשוט:

mod my_module {
// תוכן המודול עבור לכאן
}

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

mod my_module {
fnadd_numbers(א: i32,ב: i32) -> i32 {
 a + b
 }
}

אתה יכול להשתמש ב פָּאבּ מילת מפתח לייצוא הפונקציה וגישה לפונקציה בחלקים אחרים של התוכנית.

mod my_module {
פָּאבּfnadd_numbers(א: i32,ב: i32) -> i32 {
 a + b
 }
}

עכשיו, אתה יכול להתקשר ל add_numbers תפקוד מחלקים אחרים של התוכנית שלך.

אתה יכול גם לשלוט בפרטיות של מודולים עם פָּאבּ מילת מפתח על הגדרות מודול.

פָּאבּmod my_module {
פָּאבּfnadd_numbers(א: i32,ב: i32) -> i32 {
 a + b
 }
}

עכשיו ה my_module המודול הוא ציבורי, ואתה יכול לגשת למודול ממודולים אחרים.

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

mod my_module {
פָּאבּstructMyStruct {
פָּאבּ(אַרְגָז) some_field: u32,
 }
}

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

fnרָאשִׁי() {
לתת my_struct = my_module:: MyStruct { some_field: 42 };
println!("{}", my_struct.some_field);
}

ה my_struct משתנה הוא מופע של ה MyStruct struct. המשתנה ניגש ל-struct עם מפריד הנתיבים (::). ה רָאשִׁי הפונקציה מדפיסה את איזה_שדה שדה של המבנה עם println! מאקרו.

מודל הבעלות של Rust מבטיח בטיחות זיכרון

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

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