פרוסות: המבנה האידיומטי

פרוסה היא מבנה הנתונים הנפוצים ביותר ב-Go: תצוגה דינמית מעל מערך בסיס. תחביר: []T. בניגוד למערכים, האורך הוא לא חלק מהסוג, ואתה יכול לגדל אותו עם append.

אנטומיה של פרוסה

בפנים פרוסה היא מבנה של שלושה שדות:

• מצביע לרכיב הראשון במערך הבסיסי
• אורך (len): מספר אלמנטים גלויים
• קיבולת (cap): אלמנטים זמינים מתחילת התצוגה עד סוף המערך הבסיסי

s := []int{10, 20, 30}
fmt.Println(len(s), cap(s)) // 3 3

יְצִירָה

a := []int{1, 2, 3}          // literal
b := make([]int, 3)          // [0 0 0]   len=3 cap=3
c := make([]int, 3, 10)      // len=3 cap=10 (reserved)
var d []int                  // nil slice: len=0 cap=0, still usable with append

append: תמיד הקצה את התוצאה

append מוסיף אלמנטים ומחזיר פרוסה חדשה (אפשרי הקצאת מערך חדש אם הקיבולת אינה מספקת):

s := []int{1, 2, 3}
s = append(s, 4)              // [1 2 3 4]
s = append(s, 5, 6, 7)        // append multiple elements
s = append(s, altra...)       // concatenate another slice (spread)

ביטוי פרוסה s[a:b]

מחלץ תת-פרוסה מ-a (כולל) עד ​​b (בלעדי):

s := []int{10, 20, 30, 40, 50}
sub := s[1:4]              // [20 30 40]
inizio := s[:2]            // [10 20]
fine := s[3:]              // [40 50]
intera := s[:]             // [10 20 30 40 50]

תת פרוסות שתף את המערך הבסיסי עם הפרוסה המקורית: מוטציות דרך sub[i] = ... גלויות גם ב-s.

pitfall: שיתוף מערכים

s := []int{1, 2, 3, 4}
sub := s[0:2]
sub[0] = 99
fmt.Println(s)             // [99 2 3 4] — modified!

כדי לקבל עותק עצמאי, השתמש ב-copy או append:

out := make([]int, len(sub))
copy(out, sub)

נסה את זה

s := []int{1, 2, 3}
// (a) s = append(s, 4)
// (b) append(s, 4)

לְסַכֵּם

• []T: תצוגה דינמית על מערך; משולש (ptr, len, cap).
• make([]T, len, cap) להקצאה מראש; var s []T לפרוסה אפסית שמישה.
• s = append(s, ...): הקצה תמיד את התוצאה.
• s[a:b] חולק את המערך הבסיסי: copy(...) עבור עותקים עצמאיים.
• פרוסה nil = בסדר לקריאה/טווח/הוספה; שונה לגמרי ממפה אפסית.