Googles Go-programmeringsspråk har eksistert siden 2009, og i 2012 nådde språket sin offisielle v1.0-status. I de mellomliggende årene har mye endret seg, inkludert hvordan språket er installert. Tilbake i sin barndom var det ikke noen offisielle binære distribusjoner, og du måtte enten bygge Go fra kildekoden, som var den anbefalte metoden siden språket endret ofte, eller bruk en forhåndsbygget pakke for Linux-distribusjonen din. Tilbake da var Windows-støtte begrenset, som var støtte for CPU-arkitekturer annet enn Intel.

Ting har forbedret seg langt siden da. For Linux er det to enkle måter å installere Go på. Last ned den offisielle Linux-binære bygningen fra Go-nedlastingssiden, eller velg en forhåndsbygd pakke for Linux-distribusjonen din. Den enkleste måten å installere Go on Ubuntu er å bruke apt-get :

 sudo apt-get installer golang

Når Go er installert, kan du begynne å utvikle programmer. En av de enkleste Go-programmene er det klassiske "Hello World!" -programmet. Bruk en tekstredigerer, opprett en fil som heter " hellomte.go " med følgende korte Go-kode:

 pakke viktigste importen "fmt" func main () {fmt.Println ("Hei gjør det enklere!")}

Siden v1.0 of Go har behovet for individuelle kompilere og koblingskommandoer blitt fjernet, og de gamle 8g og 8l kommandoene er erstattet med go kommandoen.

For å kjøre hellomte.go, åpne en terminal og endre katalogen til mappen som inneholder kildekoden filen, og skriv deretter inn:

 gå løp hellomte.go

Dette vil kompilere og kjøre Go-programmet, men det vil ikke produsere en kjørbar binær. For å lage en binær og deretter kjøre den, bruk kommandoen go build :

 gå bygge hellomte.go ./hellomte

Kraften til samtidighet

En av de definerende funksjonene i Go-programmeringsspråket er dens støtte for samtidighet som gjør det mulig for et program å arbeide med flere oppgaver samtidig. Parallelisme, som ligner samtidighet, tillater et program å utføre mange oppgaver samtidig, men samtidighet går ett skritt videre, fordi det tillater disse separate oppgavene å kommunisere og samhandle. Som et resultat lar Go programmerere å bruke en rekke forskjellige samtidige motiver, inkludert arbeiderspooler, rørledninger (hvor en oppgave skjer etter hverandre) og synkron eller asynkron bakgrunnsoppgaver. Grunnlaget for denne samtidigheten er goroutine kombinert med channels og Go's select statement.

Her er et enkelt Go-program som skriver ut en streng flere ganger ved hjelp av en samtidig goroutine:

 pakke viktigste import ("fmt" "tid") func si (s streng) {for i: = 0; jeg <5; i ++ {fmt.Println (s)} func main () {go say ("Hello Make Tech Easier!") fmt.Println ("Sleep a little ...") time.Sleep (100 * time.Millisecond)}

Funksjonen say() utfører bare en enkel sløyfe for å skrive ut strengen (parameter s ) fem ganger. Det interessante er hvordan denne funksjonen kalles. I stedet for bare å ringe say("Hello Make Tech Easier!") Blir søkeordet plassert foran funksjonen. Dette betyr at funksjonen vil bli kjørt som en egen oppgave. Resten av main() fungerer så bare litt for å gi tid til goroutine å fullføre.

Utgangen kan overraske deg:

Som du kan se, er say() -funksjonen kjørt som en goroutine og mens den blir installert fortsetter resten av main() -funksjonen, skriver ut Sleep a little... og deretter går i dvale. Da er goroutine aktiv og begynner å skrive ut strengen fem ganger. Endelig avsluttes programmet når tidsgrensen er nådd.

kanaler

goroutines kan kommunisere ved hjelp av kanaler. En kanal åpner en kommunikasjonslinje mellom to forskjellige deler av et Go-program. Vanligvis vil en funksjon bli kalt som en goroutine og hvis den trenger å sende tilbake data (si fra en nettverksoperasjon), kan den bruke en kanal til å passere sammen med dataene. Hvis en annen del av Go-programmet venter på dataene, vil den sove til dataene er klare. Kanaler opprettes ved hjelp av make() -funksjonen, og de kan sendes som parametere til goroutines .

Vurder denne koden:

 pakke viktigste import ("fmt") func si (s streng, c chan int) {var jeg int for i = 0; jeg <5; i ++ {fmt.Println (s)} c <- i} func main () {c: = gjør (chan int) go say ("Hei gjør det enklere!", c) sts: = <- c fmt.Println m)}

say() -funksjonen er veldig lik det første eksemplet med unntak av at den andre parameteren er en kanal, og at etter å ha skrevet ut strengen, vil antall iterasjoner bli sendt ned via kanalen via c <- i serien.

Hovedfunksjonen skaper en kanal, starter say() -funksjonen som en goroutine og venter deretter på at dataene kommer ned i kanalen, sts := <- c før du skriver ut resultatet.

Konklusjon

Go-språket har utviklet seg betydelig de siste årene, hvis du ikke har sett på det nylig, er kanskje det nå en god tid!