Go
Le Go Command

Introduction

Aller courir

go run lance un programme sans créer de fichier exécutable. Principalement utile pour le développement. run n'exécutera que les packages dont le nom de package est principal .

Pour démontrer, nous allons utiliser un exemple simple Hello World main.go :

package main

import fmt

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

Exécuter sans compiler dans un fichier:

go run main.go

Sortie:

Hello, World!

Exécuter plusieurs fichiers dans un package

Si le package est principal et divisé en plusieurs fichiers, il faut inclure les autres fichiers dans la commande run :

go run main.go assets.go

Aller construire

go build compilera un programme dans un fichier exécutable.

Pour démontrer, nous allons utiliser un exemple simple Hello World main.go:

package main

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

Compilez le programme:

go build main.go

build crée un programme exécutable, dans ce cas: main ou main.exe . Vous pouvez alors exécuter ce fichier pour voir le résultat Hello, World! . Vous pouvez également le copier sur un système similaire sur lequel Go n'est pas installé, le rendre exécutable et l'exécuter.

Spécifiez le système d'exploitation ou l'architecture dans la génération:

Vous pouvez spécifier quel système ou architecture construire en modifiant l' env avant la build :

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

Construire plusieurs fichiers

Si votre package est divisé en plusieurs fichiers et que le nom du package est principal (c'est-à-dire qu'il ne s'agit pas d'un package importable ), vous devez spécifier tous les fichiers à générer:

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

Construire un package

Pour construire un paquet appelé main , vous pouvez simplement utiliser:

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

Aller propre

go clean nettoiera tous les fichiers temporaires créés lors de l'appel de go build sur un programme. Il va également nettoyer les fichiers laissés par Makefiles.

Aller fmt

go fmt formatera le code source d'un programme de manière soignée et idiomatique, facile à lire et à comprendre. Il est recommandé d'utiliser go fmt sur n'importe quelle source avant de la soumettre au public ou de l'engager dans un système de contrôle de version, afin de faciliter sa lecture.

Pour formater un fichier:

go fmt main.go

Ou tous les fichiers d'un répertoire:

go fmt myProject

Vous pouvez également utiliser gofmt -s ( pas go fmt ) pour tenter de simplifier le code possible.

gofmt ( not go fmt ) peut également être utilisé pour refactoriser le code. Il comprend Go, il est donc plus puissant que d'utiliser une simple recherche et de remplacer. Par exemple, étant donné ce programme ( 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")
}

Vous pouvez remplacer la méthode Original par Refactor avec gofmt :

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

Qui produira le 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")
 }

Va chercher

go get télécharge les paquets nommés par les chemins d’importation, avec leurs dépendances. Il installe ensuite les paquets nommés, comme "go install". Get accepte également les indicateurs de construction pour contrôler l'installation.

allez chercher github.com/maknahar/phonecountry

Lors de la récupération d'un nouveau package, get crée le répertoire cible $GOPATH/src/<import-path> . Si le GOPATH contient plusieurs entrées, get utilise le premier. De même, il installera des binaires compilés dans $GOPATH/bin .

Lors de l'extraction ou de la mise à jour d'un package, recherchez une branche ou une balise correspondant à la version de Go installée localement. La règle la plus importante est que si l'installation locale exécute la version "go1", recherchez les branches ou les balises nommées "go1". Si aucune version de ce type n'existe, elle récupère la version la plus récente du package.

Lors de l'utilisation de go get , le drapeau -d télécharge mais n'installe pas le paquet donné. L'indicateur -u permettra de mettre à jour le paquet et ses dépendances.

Obtenir ne vérifie jamais ou met à jour le code stocké dans les répertoires du fournisseur.

Aller env

go env [var ...] imprime des informations sur l'environnement.

Par défaut, il imprime toutes les informations.

$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"

Si un ou plusieurs noms de variables sont donnés en arguments, il imprime la valeur de chaque variable nommée sur sa propre ligne.

$go env GOOS GOPATH

darwin
/Users/vikashkv/work