מערכים באורך קבוע

ב-Go למערך יש אורך קבוע, אפוי בסוגו: [N]T. זהו פרימיטיבי המשמש לעתים רחוקות ישירות בקוד היישום - אתה תעשה זאת כמעט תמיד עובדים עם פרוסות (השיעור הבא), שהן דינמיות תצוגות על מערכים.

ובכל זאת, הבנה טובה של מערכים חיונית: הכל ב-Go בנוי מעליהם.

הצהרה ואתחול

var a [3]int = [3]int{10, 20, 30}
b := [3]int{1, 2, 3}            // inference with :=
c := [3]int{}                   // all zero: [0, 0, 0]
d := [...]int{1, 2, 3, 4}       // length inferred = 4

הערך האפס של מערך הוא מערך באורך המוצהר עם כל אלמנט בערך האפס שלו:

var nums [5]int  // [0 0 0 0 0]

יצירת אינדקס וlen

a := [3]int{10, 20, 30}
fmt.Println(a[0])      // 10
a[1] = 99
fmt.Println(len(a))    // 3

גישה מחוץ לטווח גורמת לבהלה בזמן ריצה (לא לבלתי מוגדר שקט כמו ב-C).

אורך הוא חלק מהסוג

var a [3]int
var b [4]int
// a = b   // ERROR: different types

[3]int ו-[4]int הם סוגים נפרדים, למרות ששניהם מחזיקים int. זו הסיבה שמערכים מועברים רק לעתים רחוקות לפונקציות: תצטרך קוד קשיח את האורך לסוג הפרמטר.

העתק לפי ערך

בניגוד לפרוסות (הפניה) ומפות (הפניה), מערכים מועתקים על ידי ערך:

a := [3]int{1, 2, 3}
b := a               // copy
b[0] = 99
fmt.Println(a[0])    // 1 — a is unchanged

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

מתי להשתמש במערכים?

• מאגרים בגודל קבוע ידועים בזמן ההידור (למשל [16]byte עבור MD5).
• מפתחות מפה מורכבים (פרוסות אינן "ניתנות להשוואה", מערכים כן).
• ביצועים קיצוניים (ללא עקיפה, ידידותי למטמון).

עבור 99% מהקוד: השתמש בפרוסות.

נסה את זה

var a [3]int
var b [4]int
// a = b ?

לְסַכֵּם

• [N]T: אורך קבוע, חלק מהסוג.
• ערך אפס: כל אלמנט בערך האפס שלו.
• [...]int{...} מאפשר למהדר להסיק את האורך.
• העתק לפי ערך (כולל פונקציות פנימיות).
• מחוץ לטווח = פאניקה, לא בלתי מוגדר.
• בפועל, השתמש בפרוסות, שהן תצוגות על מערכים.