Go
Il comando Go

introduzione

Vai a correre

go run eseguirà un programma senza creare un file eseguibile. Principalmente utile per lo sviluppo. run eseguirà solo pacchetti il ​​cui nome del pacchetto è main .

Per dimostrare, useremo un semplice esempio di Hello World: main.go :

package main

import fmt

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

Esegui senza compilarlo in un file:

go run main.go

Produzione:

Hello, World!

Esegui più file nel pacchetto

Se il pacchetto è principale e suddiviso in più file, uno deve includere gli altri file nel comando di run :

go run main.go assets.go

Vai a costruire

go build compilerà un programma in un file eseguibile.

Per dimostrare, useremo un semplice esempio di Hello World: main.go:

package main

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

Compila il programma:

go build main.go

build crea un programma eseguibile, in questo caso: main o main.exe . È quindi possibile eseguire questo file per vedere l'output Hello, World! . Puoi anche copiarlo su un sistema simile che non ha installato Go, renderlo eseguibile ed eseguirlo lì.

Specificare OS o Architecture in build:

Puoi specificare quale sistema o architettura costruire compilando env before build :

env GOOS=linux go build main.go # builds for Linux
env GOARCH=arm go build main.go # builds for ARM architecture

Costruisci più file

Se il pacchetto è diviso in più file e il nome del pacchetto è main (ovvero non è un pacchetto importable ), è necessario specificare tutti i file da compilare:

go build main.go assets.go # outputs an executable: main

Costruire un pacchetto

Per creare un pacchetto chiamato main , puoi semplicemente usare:

go build . # outputs an executable with name as the name of enclosing folder

Vai pulito

go clean pulirà tutti i file temporanei creati durante il richiamo go build su un programma. Pulirà anche i file rimasti da Makefile.

Vai a Fmt

go fmt formatterà il codice sorgente di un programma in un modo pulito, idiomatico, di facile lettura e comprensione. Si consiglia di utilizzare go fmt su qualsiasi sorgente prima di inviarlo per la visualizzazione pubblica o di impegnarsi in un sistema di controllo della versione, per facilitare la lettura.

Per formattare un file:

go fmt main.go

O tutti i file in una directory:

go fmt myProject

Puoi anche usare gofmt -s ( non go fmt ) per tentare di semplificare qualsiasi codice che possa.

gofmt ( not go fmt ) può essere utilizzato anche per il codice refactoring. Comprende Go, quindi è più potente dell'utilizzo di una semplice ricerca e sostituzione. Ad esempio, dato questo programma ( main.go ):

package main

type Example struct {
    Name string
}

func (e *Example) Original(name string) {
    e.Name = name
}

func main() {
    e := &Example{"Hello"}
    e.Original("Goodbye")
}

Puoi sostituire il metodo Original con Refactor con gofmt :

gofmt -r 'Original -> Refactor' -d main.go

Quale produrrà la diff:

-func (e *Example) Original(name string) {
+func (e *Example) Refactor(name string) {
     e.Name = name
 }
 
 func main() {
     e := &Example{"Hello"}
-    e.Original("Goodbye")
+    e.Refactor("Goodbye")
 }

Vai a prendere

go get scaricare i pacchetti nominati dai percorsi di importazione, insieme alle loro dipendenze. Quindi installa i pacchetti con nome, come "vai su". Get accetta anche i flag di compilazione per controllare l'installazione.

vai a ottenere github.com/maknahar/phonecountry

Quando si estrae un nuovo pacchetto, ottenere crea la directory di destinazione $GOPATH/src/<import-path> . Se GOPATH contiene più voci, usa il primo. Allo stesso modo, installerà i binari compilati in $GOPATH/bin .

Durante il check-out o l'aggiornamento di un pacchetto, cerca un ramo o un tag che corrisponda alla versione di Go installata localmente. La regola più importante è che se l'installazione locale sta eseguendo la versione "go1", cerca le ricerche per un ramo o un tag chiamato "go1". Se non esiste una tale versione, recupera la versione più recente del pacchetto.

Quando si usa go get , il flag -d lo fa scaricare ma non installa il pacchetto specificato. Il flag -u consentirà di aggiornare il pacchetto e le sue dipendenze.

Non eseguire mai il check out o aggiornare il codice memorizzato nelle directory del fornitore.

Vai env

go env [var ...] stampa vai informazioni sull'ambiente.

Di default stampa tutte le informazioni.

$go env

GOARCH="amd64"
GOBIN=""
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="darwin"
GOOS="darwin"
GOPATH="/Users/vikashkv/work"
GORACE=""
GOROOT="/usr/local/Cellar/go/1.7.4_1/libexec"
GOTOOLDIR="/usr/local/Cellar/go/1.7.4_1/libexec/pkg/tool/darwin_amd64"
CC="clang"
GOGCCFLAGS="-fPIC -m64 -pthread -fno-caret-diagnostics -Qunused-arguments -fmessage-length=0 -fdebug-prefix-map=/var/folders/xf/t3j24fjd2b7bv8c9gdr_0mj80000gn/T/go-build785167995=/tmp/go-build -gno-record-gcc-switches -fno-common"
CXX="clang++"
CGO_ENABLED="1"

Se uno o più nomi di variabili vengono forniti come argomenti, stampa il valore di ciascuna variabile denominata sulla propria riga.

$go env GOOS GOPATH

darwin
/Users/vikashkv/work