לדלג לתוכן

Go (שפת תכנות)

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

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

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

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

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

תחביר השפה מבוסס על התחביר של שפת C - שימוש בסוגריים מסולסלים, מבני בקרה דומים והיעדר של מחלקות. בין ההבדלים בתחביר בינה לבין C ניתן להזכיר את היעדר הסוגריים במבני הבקרה, השימוש האופציונלי בנקודה ופסיק ומילות מפתח (למשל, go ו-select) שאינן קיימות בשפת C. התחביר של שפת גו הושפע גם לא מעט מהתחביר של שפת Python[2], ושאב ממנה תכונות כמו השמה מרובה, מחרוזת מרובת-שורות (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 איננה נחשבת שפה מונחית עצמים קלאסית[3] כמו שפות מודרניות אחרות כגון ++C,‏ #C‏ או Java, כיוון שאינה מנהלת היררכיה של עצמים, אך מאפשרת אנקפסולציה, ערכים מוטמעים[4] ,קומפוזיציה ותכונות רבות נוספות אשר מאפשרות תכנות מונחה עצמים בסגנון שונה[5], יש האומרים פשוט ונוח יותר[6].

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

[עריכת קוד מקור | עריכה]

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

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

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

[עריכת קוד מקור | עריכה]

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

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

תוכנית 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)
}

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

[עריכת קוד מקור | עריכה]

הערות שוליים

[עריכת קוד מקור | עריכה]
  1. ^ Go, GitHub (באנגלית)
  2. ^ Google's Go: A New Programming Language That's Python Meets C++, TechCrunch (באנגלית)
  3. ^ Frequently Asked Questions (FAQ) - The Go Programming Language, go.dev
  4. ^ Effective Go - The Go Programming Language, go.dev
  5. ^ Is Go object oriented?, flaviocopes.com (באנגלית)
  6. ^ Composition over Inheritance in Go, odetocode.com
  7. ^ Frequently Asked Questions (FAQ)‎, באתר The Go Programming Language