Googles Go-programmeringsspråk har funnits sedan 2009 och i 2012 nådde språket sin officiella v1.0-status. Under de mellanliggande åren har mycket förändrats, inklusive hur språket är installerat. I sin spädbarn fanns det inga officiella binära utdelningar och du måste antingen bygga Go från källkoden, vilket var den rekommenderade metoden eftersom språket ändrade ofta eller använd en förbyggd paket för din Linux-distribution. Därefter var Windows-support begränsat, vilket var stöd för andra CPU-arkitekturer än Intel.

Sakerna har förbättrats väldigt sedan dess. För Linux finns det två enkla sätt att installera Go. Ladda ner den officiella Linux-binära byggningen från Go-nedladdningsidan eller välj en förbyggd paket för din Linux-distribution. Det enklaste sättet att installera Gå på Ubuntu är att använda apt-get :

 sudo apt-get install golang

När Go är installerat kan du börja utveckla program. Ett av de enklaste Go-programmen är det klassiska "Hello World!" -programmet. Använd en textredigerare, skapa en fil som heter " hellomte.go " med följande korta Go-kod:

 Paket Huvud Import "Fmt" Func Main () {fmt.Println ("Hej Gör Tech Mindre!")}

Sedan v1.0 of Go har behovet av individuella kompilera och länkkommandon tagits bort och de gamla 8g och 8l kommandona har ersatts med go kommandot.

För att köra hellomte.go, öppna en terminal och ändra katalogen till mappen som innehåller källkodsfilen och skriv sedan:

 gå köra hellomte.go

Detta kommer att kompilera och köra Go-programmet, men det kommer inte att producera en körbar binär. För att skapa en binär och kör sedan använd kommandot go build :

 gå bygg hellomte.go ./hellomte

Kraften av samtidighet

Ett av de definierande funktionerna i Go-programmeringsspråket är dess stöd för samtidighet som gör att ett program kan fungera med flera uppgifter samtidigt. Parallelism, som liknar samtidighet, tillåter ett program att utföra många uppgifter samtidigt, men samtidighet går ett steg längre genom att det gör det möjligt för dessa separata uppgifter att kommunicera och interagera. Som en följd gör att Go tillåter programmerare att använda en mängd olika samtidiga mönster, inklusive arbetarkollekar, pipelines (där en uppgift händer efter varandra) och synkrona eller asynkrona bakgrundsuppgifter. Grunden för denna samtidighet är goroutine kopplad till channels och Gos select uttalande.

Här är ett enkelt Go-program som skriver ut en sträng flera gånger med en samtidig goroutine:

 paketets huvudsakliga import ("fmt" "time") func say (s string) {för i: = 0; jag <5; i ++ {fmt.Println (s)} func main () {go say ("Hej gör Tech enklare!") fmt.Println ("Sova lite ...") time.Sleep (100 * time.Millisecond)}

Funktionen say() utför bara en enkel slinga för att skriva ut strängen (parameter s ) fem gånger. Det intressanta är hur den funktionen heter. Istället för att bara ringa say("Hello Make Tech Easier!") Går sökordet framför funktionskallet. Det innebär att funktionen kommer att köras som en separat uppgift. Resten av huvudfunktionen main() fungerar då bara lite för att ge tid för goroutine att slutföra.

Utgången kan överraska dig:

Som du ser ser funktionen say() som en goroutine och medan den installeras fortsätter resten av huvudfunktionen main(), skriver ut Sleep a little... och sedan går och lägger sig. Då är goroutine aktiv och börjar skriva ut strängen fem gånger. Slutligen slutar programmet en gång tidsgränsen som uppnåtts.

kanaler

goroutines kan kommunicera med kanaler. En kanal öppnar en kommunikationslinje mellan två olika delar av ett Go-program. Vanligtvis kallas en funktion som en goroutine och om den behöver skicka tillbaka data (säg från en nätverksoperation) kan den använda en kanal för att passera med den dataen. Om en annan del av Go-programmet väntar på den data kommer den att sova tills datan är klar. Kanaler skapas med funktionen make() och de kan överföras som parametrar till goroutines .

Tänk på den här koden:

 paketets huvudsakliga import ("fmt") func say (s sträng, c chan int) {var jag int för i = 0; jag <5; i ++ {fmt.Println (s)} c <- i} func main () {c: = gör (chan int) go say ("Hej gör det enklare!", c) sts: = <- c fmt.Println m)}

say() -funktionen är mycket lik det första exemplet med undantag för att den andra parametern är en kanal och att efter att ha skrivit ut strängen kommer antalet iterationer att skickas ner via kanalen via c <- i raden av kod.

Huvudfunktionen skapar en kanal, startar funktionen say() som en goroutine och väntar sedan på att data kommer ner i kanalen, sts := <- c innan resultatet skrivs ut.

Slutsats

Go-språket har utvecklats betydligt under de senaste åren, om du inte har tittat på det nyligen är det kanske nu bra!