כל מה שאתה צריך לדעת כדי להתחיל לכתוב לך

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

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

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

תחילת העבודה עם Go

אתה יכול להפעיל את Go ברוב מערכות ההפעלה. פנה אל דף ההתקנות והורד גרסת Go מועדפת עבור מערכת ההפעלה שלך.

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

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

משתנים ב-Go

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

var א חוּט
var ב int
var ג כל
var גיל חוּט = "בן חמש"
var גיל = 5// שווה ערך ל-var age int = 5
fmt. Println (גיל)

אתה יכול להשתמש כל כסוג הנתונים אם אינך בטוח בסוג הנתונים של המשתנה.

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

const גיל = "בן חמש"

אי אפשר לשנות קבועים לאחר הכרזתם.

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

funcרָאשִׁי() {
 גיל := "בן חמש" // שווה ערך לגיל var = "בן חמש"
}

תנאים ב-Go

לגו יש גם תנאים לקבלת החלטות בתוכניות. אתה יכול להשתמש ב אם ו אַחֵר הצהרות בקוד שלך כדי להתמודד עם החלטות.

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

var א int = 12
אם a == 12 {
 fmt. Println("a שווה שתים עשרה")
}

אתה יכול רק להשתמש אַחֵר הצהרות לאחר ציון א אם הצהרה, ואתה צריך לציין את אַחֵר לחסום לאחר הסגירה אם לַחסוֹם:

var א int = 12
אם a == 12 {
 fmt. Println("a שווה שתים עשרה")
} אַחֵר {
 fmt. Println("a לא שווה שתים עשרה")
}

ה אַחֵר בלוק פועל רק כאשר אם הצהרה מוערכת לשווא. Go לא מספק הצהרות else-if, אבל אתה יכול להשתמש החלף הצהרות להצהרות מותנות מורכבות.

הנה האנטומיה של א החלף הצהרה בגו.

גיל := 7
החלף גיל {
מקרה1:
 fmt. Println("אחד")
מקרה2:
 fmt. Println("שניים")
מקרה3:
 fmt. Println("שלושה")
בְּרִירַת מֶחדָל:
 fmt. Println("אפס")
}

אתה יכול ליצור הצהרות מתג עם החלף מילת מפתח, שלאחריה תוכל לציין מקרים שונים עם ה מקרה מילת מפתח. אתה יכול לטפל במקרה ברירת המחדל באמצעות א בְּרִירַת מֶחדָל מילת מפתח.

עבור Loops in Go

Go מספקת for-loops למשימות שחוזרות על עצמן, ובניגוד לרוב השפות, אין לולאת while או do-while ב-Go.

אתה יכול להשתמש בסגנון C הפופולרי for-loop או ב- טווח for-loop שמבני נתונים מסוימים תומכים בו.

הנה דוגמה לשימוש בסגנון C עבור לולאה בתוכנית Go:

funcמדפסת() {
ל אני := 0; אני <= 3; i++ {
 fmt. Println (i)
 }
}

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

ל אינדקס, ערך := טווח מבנה נתונים {
}

מערכים בגו

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

כך תוכל להכריז על מערכים ב-Go:

var arr [5]חוּט
arr := [7]int{0, 1, 2, 3, 4, 5, 6}

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

arr[3] = "שלושה"

הקוד שלמעלה מעדכן או מוסיף את המחרוזת כערך הרביעי של ה- arr משתנה מערך.

פרוסות בגו

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

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

פרוסה := עשה([]חוּט, 9)
פרוסה[2] = "שניים"

אתה יכול להשתמש בפונקציה append כדי להוסיף אלמנטים לפרוסות. כברירת מחדל, ה לְצַרֵף הפונקציה מכניסה אלמנטים בסוף הפרוסה.

פרוסה = לְצַרֵף(פרוסה, "עשר")

פעולות הוספה על פרוסות עשויות להיות יקרות לעבודה מכיוון ש-Go יוצר מערך חדש בכל פעולת הוספה.

מפות בגו

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

מפות := עשה(מַפָּה[חוּט]int) // באמצעות הפונקציה make
מפות := מַפָּה[חוּט]int{"אחד": 1, "שתיים": 2, "שלושה": 3} // הכרזה ויצירת מפה

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

מפות["אחד"] = 1// הכנסה למפה
one := maps["one"] // גישה לרכיב מהמפה

אתה יכול להשתמש ב לִמְחוֹק פונקציה להסרת צמדי מפתח-ערך ממפות. ה לִמְחוֹק הפונקציה לוקחת את המזהה של המפה ואת המפתח של הזוג שברצונך להסיר:

לִמְחוֹק(מפות, "אחד")

פונקציות ב-Go

פונקציות הן הכלי לשימוש חוזר בקוד ב-Go. אתה יכול להכריז על פונקציות עם ה func מילת מפתח ואחריה מזהה הפונקציה:

funcרָאשִׁי() {
}

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

funcלְהוֹסִיף(איקס חוּט, י int)int {
לַחֲזוֹר x + y
}

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

מבנים בגו

ללכת זה לא שפה מכוונת עצמים בעיצוב, אבל אתה יכול ליישם תכונות מונחה עצמים ב-Go שימוש במבנים.

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

כך תוכל להכריז על מבנה ב-Go:

סוּג מִשְׂחָק struct {
 שֵׁם חוּט
 שָׁנָה int
 זמן משחק לצוף64
 שחקנים כלשהם
 מדינות מַפָּה[חוּט]חוּט
}

ה מִשְׂחָק ל-struct יש שדות עם סוגי מפה, מחרוזת, מספר שלם ונקודה צפה. אתה יכול ליצור מבנים עם ערכי ברירת מחדל או להקצות להם ערכים.

var משחק mko // מופע ברירת מחדל של ערך
// מופע עם ערכים
mko := משחק{
 שם: "ערך",
 שָׁנָה: 1231,
 זמן משחק: 1345412,
 שחקנים: [2]חוּט{"9", "דברים"},
 נתונים: מַפָּה[חוּט]int{"אחד": 1, "שתיים": 2, "שלושה": 2},
}

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

func(ג משחק)תמצא משחק(שֵׁם חוּט) {
 a := g. שָׁנָה // גישה לשדות struct
var b = g. מדינות // גישה לשדות struct
}

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

ל-Go יש מקרי שימוש רבים

למדת את היסודות של שפת התכנות Go ואת התחביר כדי להתחיל לכתוב תוכניות Go.

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