Go (שפת תכנות)

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

Go

פרדיגמות	תכנות מובנה, concurrent computing, תכנות מונחה-עצמים, תכנות אימפרטיבי, תכנות פרוצדורלי, תכנות פונקציונלי
תאריך השקה	10 בנובמבר 2009
מתכנן	רוב פייק, קן תומפסון, רוברט גריזמר
מפתח	חברת גוגל
הושפעה על ידי	APL, C, מודולה־2, Newsqueak, BCPL, מודולה, Smalltalk, פסקל, אוברון-2, אוברון, לימבו, CSP, אקטיב אוברון, occam, בפסקה זו רשומה אחת נוספת שטרם תורגמה
רישיון	רישיון BSD
סיומת	‎.go
go.dev

מספר יישומי מחשב שנכתבו תוך שימוש ב-Go לרבות Hugo, Datadog, Docker‏ וטרפורם.

מטרות

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

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

תכונות

תחביר השפה מבוסס על התחביר של שפת C - שימוש בסוגריים מסולסלים, מבני בקרה דומים והיעדר של מחלקות. בין ההבדלים בתחביר בינה לבין C ניתן להזכיר את היעדר הסוגריים במבני הבקרה, השימוש האופציונלי בנקודה ופסיק ומילות מפתח (למשל, go ו-select) שאינן קיימות בשפת C. התחביר של שפת גו הושפע גם לא מעט מהתחביר של שפת Python, ושאב ממנה תכונות כמו השמה מרובה, מחרוזת מרובת-שורות (multi-line string), האופן בו ניתן "לגזור" מקטעים ממערך או מחרוזת (למשל: "[2:12]str") ועוד.

הבדל בולט נוסף משפת C ודומותיה הוא סדר ההצהרה על משתנים ופרמטרים לפונקציות. ההצהרות להלן בשפת C:

int a, b;
int foo(int a, int b);

שקולות בקירוב להצהרות:

var a, b int
func foo(a, b int) int

סגנון הכתיבה מוגדר על ידי תוכנה (הנקראת fmt) המגדירה סגנון הזחות ורווחים אחיד באופן אוטומטי. לכל מזהה שהאות הראשונה שלו היא אות גדולה ניתן לגשת גם ממודולים נפרדים. סוגריים מסולסלים הפותחים בלוק של לולאה או תנאי חייבים להופיע באותה שורה כמו פקודת הלולאה או התנאי המתאימה (בניגוד להרגל של מתכנתים רבים בשפות ממשפחת ה-C). תכונה זו מסייעת לשמור על סגנון אחיד, מסייעת למהדר של השפה, ותקל על כתיבת מפרש לשפה.

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

אין בשפה תמיכה במנגנון טיפול בחריגות בסגנון try..catch הקיים בשפות ++C, ג'אווה או #C. במקום זאת השפה מאפשרת החזרת מספר ערכים מפונקציה ושימוש במשתנה מסוג "error" המאפשר טיפול בחריגות בסגנון:

if value, err := someFunction(someVar);err!=nil{
 fmt.Println("there was an error calling 'somefunction' : %s ", err.Error())
}

וכן ישנו מנגנון panic עבור חריגות קשות, וכן מנגנון defer המגדיר פונקציות שריצתן תתבצע בסוף ריצת הפונקציה הנוכחית.

מערכת הטיפוסים

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

טיפוס	מייצג	סוגים	גודל	הערות	דוגמה לליטרל
integer	מספר שלם	int8 int16 int32 int64	‏8 ביטים 16 ביטים 32 ביטים 64 ביטים	מספר שלם בייצוג משלים ל-2	24-
unsigned integer	מספר טבעי	uint8 uint16 uint32 uint64	‏8 ביטים 16 ביטים 32 ביטים 64 ביטים	מספר שלם בייצוג בינארי סטנדרטי	24
float	מספר ממשי	float32 float64	‏32 ביטים 64 ביטים	נקודה צפה על פי התקן המקובל	0.5
complex	מספר מרוכב	complex64 complex128	‏64 ביטים 128 ביטים	מספר מרוכב בייצוג נקודה צפה על פי התקן המקובל. החלק המדומה נכתב בעזרת האות i	‏ 12+5i
string	מחרוזת	string	דינמי	מחרוזת תווי יוניקוד ניתנת לשינוי (לא מערך)	"hello"

תכנות מונחה עצמים

שפת GO איננה נחשבת שפה מונחית עצמים קלאסית כמו שפות מודרניות אחרות כגון ++C,‏ #C‏ או Java, כיוון שאינה מנהלת היררכיה של עצמים, אך מאפשרת אנקפסולציה, ערכים מוטמעים ,קומפוזיציה ותכונות רבות נוספות אשר מאפשרות תכנות מונחה עצמים בסגנון שונה, יש האומרים פשוט ונוח יותר.

מאפיינים כלליים

מאפייני מערכת הטיפוסים:

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

ממשקים ותכנות גנרי

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

ב-GO אין תמיכה בתכנות גנרי (נכון לגרסה 1.01), למעט בעזרת מנגנון interface - שנותן מענה עבור פונקציות או מתודות הניגשות אך ורק למתודות של הארגומנטים שלהן, אך לא עבור פונקציה כללית, כגון פונקציית Max המוצאת את האיבר הגדול ביותר במערך. עבור מבני נתונים כגון רשימה, מחסנית וכדומה, ניתן להשתמש בממשק ריק ({}interface) המקביל לשימוש ב-*void בשפת C, ולבצע המרה (הכוללת בדיקה אוטומטית בזמן ריצה) בעת הוצאת איברים ממבנה הנתונים. עם זאת, זהו מענה חלקי ואיננו גמיש כמו תבניות בשפת ++C או Generics בשפות #C וג'אווה, או בשפות מודרניות רבות אחרות. על פי אתר החברה: ”תמיכה בתכנות גנרי תתווסף בשלב כלשהו. אנחנו לא מרגישים צורך דחוף בכך, אם כי אנו מבינים שישנם מתכנתים שכן חשים כך.”

תוכנית Hello world

תוכנית Hello world, דוגמת קוד הכותבת אל הפלט Hello world:

package main

func main() {
 Println("Hello, World")
}

להלן קוד עבור תוכנית מורכבת יותר, בדומה לפקודת echo בלינוקס:

package main

import (
"os"
 "flag" // command line option parser
)

var omitNewline = flag.Bool("n", false, "don't print final newline")

const (
 Space = " "
 Newline = "\n"
)

func main() {
 flag.Parse() // Scans the arg list and sets up flags
 var s string
 for i := 0; i < flag.NArg(); i++ {
 if i > 0 {
 s += Space
 }

 s += flag.Arg(i)
 }

 if !*omitNewline {
 s += Newline
 }

 os.Stdout.WriteString(s)
}

קישורים חיצוניים

• אתר האינטרנט הרשמי של Go (באנגלית)
• אתר האינטרנט הרשמי של Go (באנגלית)

• Go, ברשת החברתית אקס (טוויטר)

• דף הבית של שפת Go
• שאלות ותשובות אודות השפה
• הצגת שפת ה-Go ב-יוטיוב
• מאמר של חברת גוגל, על המוטיבציה ליצירת שפת Go