گو (زبان برنامه‌نویسی)

از ویکی‌پدیا، دانشنامهٔ آزاد
پرش به: ناوبری، جستجو
گو
گونه ترجمه‌شده، دستوری، ساخت‌یافته، همروند
منتشر شده در ۲۰۰۹
طراح(ها) رابرت گریسمر، راب پایک، کن تامپسون
توسعه‌دهنده(ها) شرکت گوگل
آخرین نسخه پایدار ۱٫۲  (۰۱ دسامبر ۲۰۱۳؛ ۳۶۰ روز پیش)
وب‌گاه golang.org

گو (به انگلیسی: Go) یک زبان برنامه‌نویسی ترجمه‌شده و دارای زباله جمع‌کن و همروند است که در شرکت گوگل و توسط رابرت گریسمر، راب پایک و کن تامپسون توسعه داده می‌شود.[۱]

اهداف ایجاد[ویرایش]

اهداف ایجاد زبان گو شامل موارد زیر است:[۲]

  • کارایی زبان‌های ترجمه‌شده دارای سامانه نوع ایستا[پ ۱]، و آسانی برنامه‌نویسی زبان‌های پویا[پ ۲]
  • امنیت نوع‌ها، و امنیت حافظه
  • پشتیبانی برای همروندی و ارتباط[پ ۳]
  • زباله جمع‌کن کارا، و بدون تاخیر
  • زمان ترجمه کوتاه

شی‌گرایی[ویرایش]

در زبان گو، ارث‌بری نوع‌ها وجود ندارد.[۳] در این زبان، می‌توان برای هر نوع داده‌ای، حتی برای نوع‌های داخلی، مثل اعداد صحیح فاقد بسته‌بندی[پ ۴]، تابع عضو تعریف کرد، و این عمل محدود به ساخت‌ها[پ ۵] (رده‌ها) نمی‌شود.[۴]

در زبان گو از رابط‌ها (به انگلیسی: Interfaces) می‌توان برای تعریف رفتار یک شی استفاده کرد. هر رابط مجموعه‌ای از تعریف توابع است، و هر نوعی که توابع این رابط را داشته باشد، این رابط را پیاده‌سازی کرده است.[۵]

در نمونه زیر، یک رابط تعریف شده است که یک تابع به نام Abs و نوع خروجی float64 مشخص کرده است. هر نوعی که این تابع را پیاده‌سازی کند، در واقع این رابط را پیاده‌سازی کرده است. به عنوان نمونه، هم MyFloat و هم Vertex این چنین هستند.

type Abser interface {
	Abs() float64
}
 
type MyFloat float64
 
func (f MyFloat) Abs() float64 {
	if f <0 {
		return float64(-f)
	}
	return float64(f)
}
 
type Vertex struct {
	X, Y float64
}
 
func (v Vertex) Abs() float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
 
func main() {
	var a Abser
	f := MyFloat(-math.Sqrt2)
	v := Vertex{3, 4}
        a = f  // a MyFloat implements Abser
        fmt.Println(a.Abs())
        a = v // a Vertex implements Abser 
        fmt.Println(a.Abs())
}

همروندی[ویرایش]

گوروتین (به انگلیسی: goroutine) تابعی است که به صورت همروند با بقیه گوروتین‌ها در فضای حافظه یکسان اجرا می‌شود.[۶] گوروتین‌ها معادل با ریسمان‌های[پ ۶] سیستم‌عامل نیستند، بلکه چندین گوروتین بین چندین ریسمان سیستم‌عامل تسهیم[پ ۷] می‌شوند.

برای ایجاد یک گوروتین، قبل از فراخوانی تابع، عبارت go را استفاده می‌کنیم. در نمونه زیر، یک گوروتین به‌صورت همروند با گوروتین فعلی ایجاد و اجرا می‌شود:

go list.Sort() // run list.Sort concurrently; don't wait for it.

گوروتین‌ها برای تبادل داده از کانال‌ها (به انگلیسی: channel) استفاده می‌کنند. در نمونه زیر، یک کانال به نام c ایجاد می‌شود که برای مشخص کردن تکمیل اجرای گوروتین داخلی استفاده می‌شود:

c := make(chan int) // Allocate a channel.
// Start the sort in a goroutine; when it completes, signal on the channel.
go func() {
    list.Sort()
    c <- 1  // Send a signal; value does not matter.
}()
doSomethingForAWhile()
<-c // Wait for sort to finish; discard sent value.

مثال‌ها[ویرایش]

برنامه Hello World[ویرایش]

مثال زیر برنامه Hello World را در گو پیاده‌سازی می‌کند:

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

برنامه Echo[ویرایش]

مثال زیر چگونگی نوشتن برنامه‌ای مشابه فرمان 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. compiled statically typed language
  2. dynamic language
  3. communication
  4. unboxed
  5. structs
  6. thread
  7. multiplex

منابع[ویرایش]


پیوند به بیرون[ویرایش]