הבנה של מערך וחתך בגו

הקדמה

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

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

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

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

אסירים

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

הגדרת אסיר

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

הנה התבנית הכללית להציע מערך:

[capacity]data_type{element_values}

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

לדוגמה, המערך הבא numbers בודד שלושה אלמנטים מספריים שעדיין אינם מוגדרים:

var numbers [3]int

אם תדפיק numbers, תקבל את היציאה הבאה:

Output
[0 0 0]

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

[4]string{"blue coral", "staghorn coral", "pillar coral", "elkhorn coral"}

אתה יכול לאחסן מערך במשתמש ולדפיק אותו:

coral := [4]string{"blue coral", "staghorn coral", "pillar coral", "elkhorn coral"}
fmt.Println(coral)

ריצוף תוכנית עם השורות הקודמות יתנתק עם היציאה הבאה:

Output
[blue coral staghorn coral pillar coral elkhorn coral]

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

fmt.Printf("%q\n", coral)

זה ייצא בערך כך:

Output
["blue coral" "staghorn coral" "pillar coral" "elkhorn coral"]

עכשיו, לכל פיסת מידע יש תווים. הפעלה \n תועצב לפנקציית העיצוב להוסיף סימן חזרה שורה בסוף.

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

מציאת מספרי תווים במערך (ובשיקומים)

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

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

עבור המערך coral, הפריסה של התווים נראית כך:

הרכב הראשון, המילה "blue coral", מתחיל במקום המפתח 0, והחתך נמצא עד למקום המפתח 3 עם האלם "elkhorn coral".

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

עכשיו אנחנו יכולים לקרוא לאלם יחיד בחתך על ידי הפניית למספר המפתח שלו:

fmt.Println(coral[1])

Output
staghorn coral

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

coral[0] = "blue coral"
coral[1] = "staghorn coral"
coral[2] = "pillar coral"
coral[3] = "elkhorn coral"

אם אנחנו קוראים למערך coral עם מספר מפתח גדול מ 3, זה יהיה מחוץ לטווח, כי זה לא יהיה תקין:

fmt.Println(coral[18])

Output
panic: runtime error: index out of range

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

fmt.Println(coral[-1])

Output
invalid array index -1 (index must be non-negative)

אנחנו יכולים להצמיד אלמים מספרים במערך או חתך עם מילים אחרות בעזרת מפתח ה +:

fmt.Println("Sammy loves " + coral[0])

Output
Sammy loves blue coral

הצלחנו להצמיד את האלם במקום המפתח 0 עם המילה "Sammy loves ".

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

שינוי אלמנטים

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

אם אנחנו רוצים לשנות את הערך של האלמנט במספר 1 של הרצף coral מ "staghorn coral" ל "foliose coral", אנחנו יכולים לעשות זאת באופן הבא:

coral[1] = "foliose coral"

עכשיו בעוד אנחנו מדפיסים coral, הרצף יהיה שונה:

fmt.Printf("%q\n", coral)

Output
["blue coral" "foliose coral" "pillar coral" "elkhorn coral"]

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

ספירת אלמנטים בעזרת len()

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

לדוגמה, כדי למצוא כמה אלמנטים יש ברצף coral, אתה יכול להשתמש בדבר הבא:

len(coral)

אם תדפיסו את אורכו של המערך coral, תקבלו את ההפלט הבא:

Output
4

זה נותן למערך coral את אורך המערך 4 בסוג המידע int, שהוא נכון בגלל שלמערך coral יש ארבעה פריטים:

coral := [4]string{"blue coral", "foliose coral", "pillar coral", "elkhorn coral"}

אם תיצרו מערך של מספרים עם יותר רכיבים, תוכלו להשתמש בפונקציית len() עליון:

numbers := [13]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
fmt.Println(len(numbers))

זה ייצא בהפלט הבא:

Output
13

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

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

הוספת פריטים בעזרת append()

append() הוא שיטה בנייתית בGo שמוסיפה פריטים למבנה מידע אוסף. אף על פי שהשיטה זו לא תעבד עם מערך, כפי שהזכרתי קודם, הדרך העיקרית בה מערכות שונהת מסlices היא שאורך של המערך לא יכול להימורגם. זה אומר שלמרות שאתה יכול לשנות את הערכים בתוך המערך, אתה לא יכול להגביר או להקטין את המערך אחרי ההגדרה המקורית שלו.

בואו נחשוב על המערך coral שלכם:

coral := [4]string{"blue coral", "foliose coral", "pillar coral", "elkhorn coral"}

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

coral = append(coral, "black coral")

תקבל שגיאה בגלל היציאה שלך:

Output
first argument to append must be slice; have [4]string

כדי ל修正 את זה, בואו נלמד עוד על סוג המידע הזה של החתך (slice), איך להגדיר סליק, ואיך להמיר מערך לסליק.

סליקים

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

הגדרת סליק

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

בואו ניצור חלק שיכלל אלמנטים מסוג מילה:

seaCreatures := []string{"shark", "cuttlefish", "squid", "mantis shrimp", "anemone"}

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

fmt.Printf("%q\n", seaCreatures)

זה ייצא בתוצאה הבאה:

Output
["shark" "cuttlefish" "squid" "mantis shrimp" "anemone"]

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

oceans := make([]string, 3)

אם היינו מדפיסים את החלק הזה, היינו קיבלים:

Output
["" "" ""]

אם רוצים לקיחת הזיכרון עבור יכולת מסויימת, ניתן להעביר משהו כשלישי לתוך פונקציית make():

oceans := make([]string, 3, 5)

זה ייצר חלק עם אורך של 3 ואוכלוסיית מקומית של 5 אלמנטים.

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

חלקים של מערכות לחלקים

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

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

fmt.Println(coral[1:3])

הרצת תוכנית עם השורה הזו תישאר את התוצאה הבאה:

Output
[foliose coral pillar coral]

כאשר יוצרים חתיכה, כמו ב[1:3], המספר הראשון הוא היכן החתיכה מתחילה (כולל), והמספר השני הוא הסכום של המספר הראשון ומספר האלמנטים שברצונך לשאול:

array[starting_index : (starting_index + length_of_slice)]

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

array[1 : (1 + 2)]

כך הגעת לסימון הזה:

coral[1:3]

אם ברצונך להכניס את ההתחלה או הסוף של המערך כנקודת התחלה או סוף החתיכה, ניתן להתעלם מאחד המספרים בסינטקס array[first_index:second_index]. למשל, אם ברצונך להדפיס את שלושת האלמנטים הראשונים של המערך coral — שהם "blue coral", "foliose coral", ו"pillar coral" — ניתן לעשות זאת על ידי הקלדה:

fmt.Println(coral[:3])

זה ידפיס:

Output
[blue coral foliose coral pillar coral]

הדפסה הזו יצרה את הראש של המערך, הפסקה ממש לפני המפתח 3.

כדי לכל את הפרימיטים בסוף המערך, תשנו את הסינTAX:

fmt.Println(coral[1:])

זה יעניק את החתך הבא:

Output
[foliose coral pillar coral elkhorn coral]

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

המרה ממערך לחתך

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

coral[:]

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

coralSlice := coral[:]

אם תדפיסו coralSlice, תקבלו את היוצאה הבאה:

Output
[blue coral foliose coral pillar coral elkhorn coral]

עכשיו, ניסוי להוסיף את האלמונית black coral כמו באזור המערך, בעזרת append() עם החתך המופיע לאחר ההמרה:

coralSlice = append(coralSlice, "black coral")
fmt.Printf("%q\n", coralSlice)

זה ייצא עם החתך עם האלמונית הנוספת:

Output
["blue coral" "foliose coral" "pillar coral" "elkhorn coral" "black coral"]

אנחנו גם יכולים להוסיף יותר מאחד אלמנט באותו המסגרת append():

coralSlice = append(coralSlice, "antipathes", "leptopsammia")

Output
["blue coral" "foliose coral" "pillar coral" "elkhorn coral" "black coral" "antipathes" "leptopsammia"]

כדי לשלב שני חלקים ביחד, ניתן להשתמש ב append(), אך עליך להרחיב את הגוף השני על ידי שימוש בסינTAX ... להרחבה:

moreCoral := []string{"massive coral", "soft coral"}
coralSlice = append(coralSlice, moreCoral...)

Output
["blue coral" "foliose coral" "pillar coral" "elkhorn coral" "black coral" "antipathes" "leptopsammia" "massive coral" "soft coral"]

עכשיו שלמדת איך להוסיף אלמנט לסליק שלך, אנחנו נסתכל על איך להסיר אחד.

הסירת אלמנט מסליק

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

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

אם i הוא מדד לאלמנט שצריך להסיר, אז הפורמט של התהליך יראה כך:

slice = append(slice[:i], slice[i+1:]...)

מ coralSlice, נסיר את הפריט "elkhorn coral". הפריט הזה ממוקם במיקום המדד 3.

coralSlice := []string{"blue coral", "foliose coral", "pillar coral", "elkhorn coral", "black coral", "antipathes", "leptopsammia", "massive coral", "soft coral"}

coralSlice = append(coralSlice[:3], coralSlice[4:]...)

fmt.Printf("%q\n", coralSlice)

Output
["blue coral" "foliose coral" "pillar coral" "black coral" "antipathes" "leptopsammia" "massive coral" "soft coral"]

עכשיו האלמנט במיקום המדד 3, המילה "elkhorn coral", אינו יותר בסליק coralSlice שלנו.

אנחנו גם יכולים למחוק טווח באותה הגישה. אם אנחנו רוצים להסיר לא רק את הפריט "elkhorn coral", אלא גם "black coral" ו "antipathes", אנחנו יכולים להשתמש בטווח בתווך הביטוי להגשים את זה:

coralSlice := []string{"blue coral", "foliose coral", "pillar coral", "elkhorn coral", "black coral", "antipathes", "leptopsammia", "massive coral", "soft coral"}

coralSlice = append(coralSlice[:3], coralSlice[6:]...)

fmt.Printf("%q\n", coralSlice)

הקוד הזה יקח את העמודים 3, 4, ו 5 מהסליק:

Output
["blue coral" "foliose coral" "pillar coral" "leptopsammia" "massive coral" "soft coral"]

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

מדידת האפסים של סליק עם cap()

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

שימוש נפוץ ב cap() הוא ליצור סליק עם מספר אלמנטים קבעי ואז להמלא אותם באופן קודמטרי. זה מאvoid הרעיון של האלocation מידה מיותר שיכולה להתרחש על ידי השתמשות בפונקציית append() להוסיף אלמנטים מעבר ליכולת הסליק הנוכחית.

בואו נקח את הדוגמה בה אנחנו רוצים ליצור רשימה של מספרים, מ0 עד 3. אנחנו יכולים להשתמש בappend() במעגל לעשות זאת, או שאנחנו יכולים לקישור קודם את הסליק ולהשתמש בcap() כדי להלך במעגל ולמלא את הערכים.

ראשית, אנחנו יכולים להסתכל על השימוש בappend():

numbers := []int{}
for i := 0; i < 4; i++ {
	numbers = append(numbers, i)
}
fmt.Println(numbers)

Output
[0 1 2 3]

בדוגמה הזו, יצרנו סליק, ואז יצרנו מעגל for שיהיה מסווה ארבע פעמים. כל היוזמה הואלקטה את ערכו של המשתנה המעגלי i למקום בסליק numbers. אך זה יכול להוביל לרישום חלקים מינוח בלתי צריכה שיעיל את התוכנית שלך. כשאתה מוסיף לסליק ריק, כל פעם שאתה מגיש append(), התוכנית מביטה ביכולת הסליק. אם המיליארד הוסף יגיע ליתר היכולת שלו, התוכנית תאריך חלק מזיכרון נוסף כדי להגיע לזה. זה יוצר עודף מערך בתוכנית שלך ויגרם לאידך יותר ביצוע.

עכשיו בואו נספק את הסליק בלי להשתמש בappend() על ידי קישור קודם לאורך/היכולת מסויימת:

numbers := make([]int, 4)
for i := 0; i < cap(numbers); i++ {
	numbers[i] = i
}

fmt.Println(numbers)

Output
[0 1 2 3]

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

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

בניית סלים רב-מימדי

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

בואו נבדוק את הסלים הרב-מימדי הבא:

seaNames := [][]string{{"shark", "octopus", "squid", "mantis shrimp"}, {"Sammy", "Jesse", "Drew", "Jamie"}}

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

fmt.Println(seaNames[1][0])
fmt.Println(seaNames[0][0])

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

Output
Sammy
shark

המספרים הבאים הם העמודים לאלמנטים הנפרדים הנוספים:

seaNames[0][0] = "shark"
seaNames[0][1] = "octopus"
seaNames[0][2] = "squid"
seaNames[0][3] = "mantis shrimp"

seaNames[1][0] = "Sammy"
seaNames[1][1] = "Jesse"
seaNames[1][2] = "Drew"
seaNames[1][3] = "Jamie"

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

סיכוי

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

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