Go (שפת תכנות)

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

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

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

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

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

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

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

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

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

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

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

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

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

אין בשפה תמיכה במנגנון ניהול חריגות בסגנון try..catch הקיים בשפות ++C, ג'אווה או #C. במקום זאת השפה מאפשרת החזרת מספר ערכים מפונקציה, מנגנון panic עבור חריגות קשות, וכן מנגנון defer המגדיר פונקציות שריצתן תתבצע בסוף ריצת הפונקציה הנוכחית.

מערכת הטיפוסים[עריכת קוד מקור | עריכה]

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

טיפוס מייצג סוגים גודל הערות דוגמה לליטרל
integer מספר שלם byte
short
int32
int64
‏8 ביטים
16 ביטים
32 ביטים
64 ביטים
מספר שלם בייצוג משלים ל-2 24-
unsigned integer מספר טבעי ubyte
ushort
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 וג'אווה, או בשפות מודרניות רבות אחרות. על פי אתר החברה‏[1]: "תמיכה בתכנות גנרי תתווסף בשלב כלשהו. אנחנו לא מרגישים צורך דחוף בכך, אם כי אנו מבינים שישנם מתכנתים שכן חשים כך."

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

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

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

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

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. ^ [Frequently Asked Questions (FAQ) http://golang.org/doc/go_faq.html#generics], באתר The Go Programming Language