In dit artikel gaan we een uitleg geven van hoe je workspaces kan aanmaken en tevens binaire Go-bestanden bouwen, compileren, cross-compileren en uitvoeren van Go applicaties. Deze onderwerpen zijn erg belangrijk als je van plan bent om grootschalige Go-applicaties te ontwikkelen en implementeren in een productieomgeving.

Voordat we verder gaan met deze onderwerp, moeten we eerst uitleggen wat een workspace is en waarom je deze nodig hebt.

workspaces

Een workspace in Go is een directory die bestaat uit de volgende hiërarchie:

Bin

De bin directory staat voor binair en dit bestand bevat alle binaire bestanden van de project.

Pkg

De pkg directory staat voor pakketten en in deze bestand worden alle externe pakketten opgeslagen die tot het project behoren.

Src

De src is de broncodes map waarbij alle broncodes opgeslagen worden inclusief hun dependency.

Wanneer je Go op Windows installeren is je standaardomgeving C:\Go waar alle benodigde bestanden/packages worden opgeslagen. De vraag is nu: waarom een workspace aanmaken? Een workspace is een werkruimte waar alleen de benodigde pakketten en binaire bestanden van je project worden opgeslagen. In al onze gebruikte voorbeeld tot nu toe gebruikten we de standaardomgeving (bekend als GOROOT) om onze Go broncodes uit te voeren. Een workspace biedt de mogelijkheid om pakketten en broncodes in je eigen werkruimte te importeren. Zodra je werkruimte is aangemaakt, worden alle pakketten die geïmporteerd zijn voor je project opgeslagen in de pkg map van je werkruimte.

Voordat de werkruimte gebruikt kunnen worden, moet je de GOPATH instellen in de omgevingsvariabelen die naar je projectdirectory verwijst. Wanneer je de GOPATH vaststellen, verwacht Go een uitvoerbaar bestand in de opgegeven directory. De GOPATH geef aan de locatie van je workspace.

In Windows, wordt dit gespecificeerd in uw omgevingsvariabelen in het Configuratiescherm. De volgende instructies laten zien hoe u uw basisdirectory voor de werkruimte en GOPATH in de omgevingsvariabelen instelt.

Begin met het maken van je project map. In dit voorbeeld gaan we deze map op ons bureaublad opslagen.

Nadat de project map is aangemaakt, moet je de src map aanmaken waarin de broncodes worden opgeslagen.

Vervolgens moet je het Go-bestand aanmaken die de main package bevat. Aangezien het ten minste één .go bestand vereist om een workspace te creëren in de opgegeven map. Voor dit voorbeeld gebruiken we Atom als onze code-editor, maar het hangt allemaal af van uw persoonlijke voorkeur. Lees deze artikel voor meer informatie over code-editors die kunnen worden gebruikt.

Maak een nieuw leeg bestand aan

Typ de volgende Go-codes

package main

func main(){

}

Sla het bestand op in je src map

Nu komt de meest belangrijke stap en dat is het specificeren van je GOPATH om de workspace te creëren. Om de GOPATH in Windows in te stellen, moet je naar Configuratiescherm -> Systeem -> Geavanceerde systeeminstellingen -> Geavanceerd -> Omgevingsvariabelen.

Om de werkruimte te creëren, moet je de GOPATH en GOBIN instellen. De volgende instructies laten zien hoe je beide kunt instellen.

GOBIN instellen

Naast de GOPATH, moet je ook de GOBIN pad instellen waarin bij het creëren van de werkruimte wordt de bin-map aangemaakt. In deze map worden alle uitvoerbare bestanden opgeslagen. Volg deze stappen om je GOBIN in te stellen:

GOPATH instellen

Op dezelfde manier stel je de GOPATH in:

Nadat je zowel de GOPATH als GOBIN hebt ingesteld, klik op OK.

Sluit de opdrachtprompt om de wijzigingen door te voeren. Voer de volgende opdracht uit om te controleren of de wijzigingen zijn doorgevoerd:

go env

Controleer vanuit het Go-omgevingsresultaat of de GOBIN en GOPATH zijn ingesteld.

Als alles is correct ingesteld moeten we alleen de laatste stap nog uitvoeren, namelijk het creëren van de workspace. Opent de Opdrachtprompt en navigeert naar de map src van de project map waar het .go-bestand zich bevindt:

cd Desktop\go_project\src

En voert u de volgende opdracht uit:

go install

Wanneer je deze opdracht op de project map uitvoeren worden de uitvoerbare bestanden gecompileerd en opslagen in de bin map.

Gefeliciteerd! Je workspace is aangemaakt en vanaf nu kun je pakketten importeren met behulp van de go get commando. Voer bijvoorbeeld de volgende opdracht uit:

go get -u github.com/gorilla/mux

En je pkg -map verschijnt met het geïmporteerde pakket in je workspace.

Tijdens het uitvoeren van zo’n opdracht zal Go door de volledig codebase heen lopen en zoek naar alle externe referenties. Indien externe referenties zijn gedetecteerd zal Go het package importeren en beschikbaar maken in je workspace.

Pakketten importeren

De meeste pakketten worden geïmporteerd vanuit andere repositories via een versiebeheersysteem zoals Git, Mercurial, SVN en Bazaar. Wanneer je een pakket importeert, haalt Go alle codebase op uit Git en checkt de laatste commit uit de standaard branch.

Go build

Om Go-applicaties te bouwen, moet je de go build opdracht uitvoeren waarmee het uitvoerbare bestand wordt gegenereerd. Wanneer je een uitvoerbaar bestand maakt, betekent het dat deze bestand geen externe bibliotheken nodig hebben om te kunnen draaien. Dus een standalone uitvoerbare bestand.

Voordat een uitvoerbaar bestand gemaakt kunnen worden zal Go door een aantal regels heen lopen. Dit zorgt ervoor om fouten en bugs te voorkomen. De go build opdracht helpt je ook om je code leesbaarder te maken.

Je moet altijd onthouden dat de Go-compiler is om je te helpen en niet een ellende van te maken.

Het doel van de compiler is om je Go-code te compileren en de kwaliteit van je broncodes te verbeteren.

Een van de regels zijn dat iedere package die geïmporteerd worden in je project moet gebruikt worden.

package main
import (
“fmt”
“os”
)

func main() {
fmt.Println(“Hello world!”)
}

Dit zal de volgende foutmelding weergeven wanneer je een uitvoerbaar bestand probeer te maken:

# command-line-arguments
./main.go:5:1: imported and not used: “os”

Hoewel je deze regel omzeilen door een onderstrepingsteken te gebruiken.

package main
import (
“fmt”
_”os”
)

func main() {
fmt.Println(“Hello world!”)
}

Het gebruik van puntkomma’s worden streng gecontroleerd door de compiler omdat Go in veel contexten gebruik de puntkomma’s als terminator van instructies. De compiler voegt automatisch de vereiste puntkomma’s in wanneer hij denkt dat dit nodig is. Bekijk het volgende voorbeeld:

package main
import (
“fmt”
)

func main()
{
fmt.Println(“Hello world!”)
}

De code ziet er goed uit, maar als je een uitvoerbaar bestand probeer van te maken krijgt je de volgende syntaxisfoutmelding en de code zal niet compileren:

# command-line-arguments
./main.go:7:6: missing function body
./main.go:8:1: syntax error: unexpected semicolon or newline before {

Dit komt omdat het plaatsen van de haakje { in een nieuwe regel ervoor zorgt dat de Go-compiler een puntkomma invoegt aan het einde van main (). Vandaar de foutmelding.

Go format (fmt)

Met de go fmt commando kun je codes weer in het juiste formaat gesteld worden. Dat betekent dat als je code er rommelig uitziet, kun je met deze commando ervoor zorgen dat ze weer netjes uitziet.

Cross-compileren

Cross-compilatie is een belangrijke functie als je uitvoerbare bestanden wilt genereren voor verschillende machines met een andere besturingssysteem en architectuur. Gelukkig heeft Go een ingebouwde ondersteuning voor cross-compilatie, wat betekent dat je alleen maar één machine nodig hebt voor het ontwikkelen van je Go applicatie.

Voor het cross-compileren van een Go-bestand, moet je de GOOS (besturingssysteem van keuze) en GOARCH (architectuur van keuze) instellen. Voer de volgende opdracht uit om deze gegevens op te achterhalen:

• go version
• go version go1.10.3 windows/amd64

In dit voorbeeld is de GOOS windows en amd64 de GOARCH. De cross-compilatie kan gedaan worden door de volgende opdracht uit te voeren:

env GOOS=[besturingssysteem] GOARCH=[architectuur] go build [go bestand]

In Windows kunt je deze opdracht niet uitvoeren in de opdrachtprompt. Daarom zullen we Git Bash gebruiken om deze opdracht uit te voeren. Voor onze voorbeeld wordt de opdracht als volgt:

env GOOS=windows GOARCH=arm64 go build main.go

Het resultaat ziet als volgt uit:

Deze opdracht genereert een uitvoerbaar bestand dat werkt op Windows met een ARM-architectuur. Zie de lijst van alle ondersteunde Go GOOS en GOARCH.

Voer Go-codes uit

In bijna alle onze eerdere artikelen wordt de go run opdracht gebruikt. Bij het uitvoeren van go run zal de Go-compiler een tijdelijk uitvoerbaar bestand aanmaken. Na de uitvoering van de Go-applicatie wordt deze uitvoerbare bestand verwijderd. Dat betekent dat Go geen bestanden op je harde schijf achterlaat.

Voor het maken van zelfstandig uitvoerbaar bestanden moet je de go build opdracht gebruiken. Doormiddel van deze opdracht wordt deze uitvoerbare bestand gemaakt die rechtstreeks uitgevoerd kunnen worden zonder go run te gebruiken. Een go build opdracht ziet er als volgt uit:

go build [go bestandsnaam]

In een voorbeeld waar je de bestandsnaam main.go hebt, zal de go build opdracht als volgt uitziet:

go build main.go

Zodra de uitvoering voltooid is, wordt de uitvoerbare bestand(en) gemaakt en opgeslagen in de src-map.

Om de main uitvoerbare bestand uit te voeren, moet je naar de src-map navigeren in je workspace:

cd Desktop\go_project\src

en voer de volgende opdracht uit:

./main

Volg ons: