Google's Go-programmeertaal bestaat al sinds 2009 en in 2012 bereikte de taal zijn officiële v1.0-status. In die tussenliggende jaren is er veel veranderd, inclusief hoe de taal is geïnstalleerd. Terug in de kinderschoenen waren er geen officiële binaire distributies en moest je Go uit de broncode bouwen, wat de aanbevolen methode was omdat de taal vaak aan het veranderen was, of een vooraf gebouwd pakket voor je Linux-distributie gebruikte. Toen was Windows-ondersteuning beperkt, net als ondersteuning voor andere CPU-architecturen dan Intel.

Sindsdien is het enorm verbeterd. Voor Linux zijn er twee eenvoudige manieren om Go te installeren. Download de officiële Linux-binaire build van de Go-downloadpagina of kies voor een vooraf gebouwd pakket voor je Linux-distributie. De gemakkelijkste manier om Go te installeren op Ubuntu is apt-get :

 sudo apt-get install golang

Nadat Go is geïnstalleerd, kunt u beginnen met het ontwikkelen van programma's. Een van de eenvoudigste Go-programma's is het klassieke "Hello World!" -programma. Gebruik een teksteditor en maak een bestand met de naam " hellomte.go " met de volgende korte Go-code:

 pakket main import "fmt" func main () {fmt.Println ("Hello Make Tech Makkelijker!")}

Sinds v1.0 van Go is de behoefte aan afzonderlijke compileer- en koppelopdrachten verwijderd en zijn de oude 8g en 8l opdrachten vervangen door de opdracht go .

Als u hellomte.go wilt uitvoeren, opent u een terminal en wijzigt u de map in de map die het broncodebestand bevat en typt u:

 go running hellomte.go

Hiermee wordt het Go-programma gecompileerd en uitgevoerd, maar er wordt geen uitvoerbaar binair bestand geproduceerd. Om een ​​binair bestand te maken en het vervolgens uit te voeren, gebruikt go build opdracht go build :

 ga bouwen hellomte.go ./hellomte

De kracht van concurrency

Een van de bepalende kenmerken van de Go-programmeertaal is de ondersteuning voor concurrency waarmee een programma met meerdere taken tegelijkertijd kan werken. Parallellisme, vergelijkbaar met concurrency, stelt een programma in staat om veel taken tegelijkertijd uit te voeren, maar concurrency gaat nog een stap verder omdat het deze afzonderlijke taken in staat stelt om te communiceren en te communiceren. Als gevolg hiervan stelt Go programmeurs in staat om een ​​hele reeks verschillende gelijktijdige ontwerpen te gebruiken, inclusief werkstroompools, pijplijnen (waarbij de ene taak na de andere plaatsvindt) en synchrone of asynchrone achtergrondtaken. De basis van deze gelijktijdigheid is de goroutine combinatie met channels en Go's select statement.

Hier is een eenvoudig Go-programma dat meerdere keren een reeks afdrukt met behulp van een gelijktijdige goroutine:

 pakket main import ("fmt" "time") func say (s string) {for i: = 0; i <5; i ++ {fmt.Println (s)}} func main () {go say ("Hello Make Tech Makkelijker!") fmt.Println ("Slaap een beetje ...") time.Sleep (100 * time.Millisecond)}

De functie say() voert slechts een eenvoudige lus uit om de reeks (parameter s ) vijf keer af te drukken. Het interessante is hoe die functie wordt genoemd. In plaats van alleen maar say("Hello Make Tech Easier!") het trefwoord go vóór de functieaanroep geplaatst. Dit betekent dat de functie als een afzonderlijke taak wordt uitgevoerd. De rest van de main() slaapt dan gewoon een beetje om de goroutine tijd te geven om te voltooien.

De uitvoer kan je verrassen:

Zoals je ziet, wordt de functie say() uitgevoerd als een goroutine en terwijl deze wordt ingesteld, gaat de rest van de functie main() door, drukt Sleep a little... en gaat dan slapen. Tegen die tijd is de goroutine actief en begint hij de string vijf keer uit te printen. Uiteindelijk eindigt het programma zodra de time-outlimiet is bereikt.

kanalen

goroutines kunnen communiceren via kanalen. Een kanaal opent een communicatielijn tussen twee verschillende delen van een Go-programma. Meestal wordt een functie als een goroutine en als deze gegevens moet terugsturen (bijvoorbeeld van een netwerkbewerking), kan deze een kanaal gebruiken om die gegevens door te geven. Als een ander deel van het Go-programma op die gegevens wacht, slaapt het totdat de gegevens gereed zijn. Kanalen worden gemaakt met de functie make() en ze kunnen als parameters worden doorgegeven aan goroutines .

Overweeg deze code:

 pakket main import ("fmt") func say (s string, c chan int) {var i int voor i = 0; i <5; i ++ {fmt.Println (s)} c <- i} func main () {c: = make (chan int) ga zeggen ("Hello Make Tech Makkelijker!", c) sts: = <- c fmt.Println ( st)}

De functie say() lijkt erg op het eerste voorbeeld, met de uitzondering dat de tweede parameter een kanaal is en dat na het afdrukken van de tekenreeks het aantal iteraties via de c <- i coderegel door het kanaal wordt verzonden.

De hoofdfunctie maakt een kanaal, start de functie say() als een goroutine en wacht tot de gegevens het kanaal goroutine, sts := <- c voordat het resultaat wordt afgedrukt.

Conclusie

De Go-taal is de laatste paar jaar behoorlijk gegroeid, als je er recent niet naar hebt gekeken, is het misschien nu een goed moment!