טיפוסים פרימיטיביים ב-Zero: מספרים שלמים, Float, Bool, String ו-Void

הטיפוסים המובנים

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

זו הרשימה המלאה של הפרימיטיביים שתיגעו בהם ביום-יום. טיפוסים מורכבים, shapes, enums, choices, בנויים מהם.

מספרים שלמים

טיפוסי המספרים השלמים עוקבים אחרי דפוס שמות אחיד: i לטיפוס עם סימן, u לטיפוס בלי סימן, ואחריהם רוחב הביטים. כך i32 הוא מספר שלם של 32 ביט עם סימן; u8 הוא בית בלי סימן; i64 הוא מספר שלם של 64 ביט עם סימן.

let small_signed: i8   = -120
let byte:         u8   = 250
let id:           i32  = 1
let big:          i64  = 9_000_000_000
let index:        usize = 0

ברירת המחדל לליטרל בלי סיומת היא i32, אלא אם ההקשר מסביב מחייב משהו אחר:

let answer = 42       // i32

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

let byte = 250_u8     // ליטרל עם טיפוס
let byte: u8 = 250    // קישור עם טיפוס

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

let pair: BytePair = Pair { left: 1_u8, right: 2_u8 }

איזה רוחב לבחור

כלל אצבע קצר:

• i32 לרוב החישובים עם סימן. רחב מספיק כמעט לכל דבר שתספרו, ומהיר בכל פלטפורמה.
• u8 לעבודה ברמת הבית. בתים מקובץ, בתים במאגר, בתים ברשת.
• u32 / u64 לספירות לא שליליות כשהטווח חשוב. היסטים בקובץ מעל 2 GB, ספירות גדולות.
• usize לגדלים ולאינדקסים. בגודל מצביע: תואם למה שהפלטפורמה משתמשת בו לכתובות זיכרון.
• i64 לזמן מאז ה-epoch ודומיו. גדול מספיק לננו-שניות לאורך מאות שנים.

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

בוליאנים

let ok = true
let done: bool = false

ל-bool יש בדיוק שני ערכים: true ו-false. אלה ליטרלים, לא קבועים שמייבאים ממקום כלשהו. התנאי ב-if או ב-while הוא bool: אין truthiness מרומזת למספרים שלמים או למחרוזות.

if ok {
    check world.out.write("yes\n")
} else {
    check world.out.write("no\n")
}

If/else מכסה תנאים בפירוט.

מספרים עשרוניים

f32 ו-f64 הם מספרי נקודה צפה של 32 ביט ו-64 ביט לפי IEEE-754, בהתאמה. השתמשו בהם כשצריך ערכים שבריים: מדידות, יחסים, גאומטריה. לחשבון מדויק על כסף, העדיפו מספרים שלמים ביחידה הקטנה ביותר (אגורות, סנטים, satoshis) על פני מספרים עשרוניים.

let ratio: f32 = 0.5
let pi:    f64 = 3.141592653589793

f64 הוא ברירת המחדל לליטרלים עשרוניים בלי סיומת.

תווים ומחרוזות

char מחזיק ערך סקלרי יחיד של Unicode:

let initial: char = 'Z'

String הוא רצף של תווים, שהספרייה הסטנדרטית מקודדת בדרך כלל כ-UTF-8. ליטרלים של מחרוזות משתמשים במירכאות כפולות:

let message: String = "hello from zero\n"

רצפי הבריחה הצפויים עובדים: \n לשורה חדשה, \t לטאב, \\ ללוכסן הפוך, \" למירכאות כפולות.

let multi_line = "line one\nline two\n"

הספרייה הסטנדרטית חושפת תצוגות ברמת הבית על מחרוזת לעבודה ברמה נמוכה. הצורה std.mem.span("zero") מחזירה Span<u8> על הבתים: שימושי כשמנתחים, מחשבים hash או משווים בית אחר בית.

Void

Void הוא הטיפוס של Zero ל"אין ערך החזרה שימושי". פונקציות שקיימות בשביל תופעות הלוואי שלהן משתמשות בו:

pub fun main(world: World) -> Void raises {
    check world.out.write("hello\n")
}

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

קווים תחתונים בליטרלים מספריים

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

let big   = 9_000_000_000_i64
let bytes = 1_048_576_u32     // 1 MiB

הוסיפו אותם בכל מקום שבו קשה לספור את הספרות.

דף עזר לסיומות טיפוס של ליטרלים

השתמשו בהן כשאתם בונים ערך וההקשר מסביב לא קובע את הטיפוס.

הבא בתור: פונקציות

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