Explication détaillée de GOROOT, GOPATH et GOBIN en langage Go

Go Language est un tout nouveau langage de développement de types statiques, avec un garbage collection automatique, des types intégrés riches, plusieurs valeurs de retour pour les fonctions, une gestion des erreurs , et fonctions anonymes, programmation simultanée, réflexion et autres fonctionnalités.

La commande go repose sur une variable d'environnement importante : $GOPATH
GOPATH autorise plusieurs répertoires. Lorsqu'il y a plusieurs répertoires, faites attention au séparateur. Lorsqu'il y a plusieurs répertoires, Windows utilise un point-virgule.

Lorsqu'il y a plusieurs GOPATH, le package obtenu par go get sera stocké par défaut dans le premier répertoire

Le répertoire $GOPATH a trois sous-répertoires

1 , src stocke le code source (par exemple : .go .c .h .s, etc.) Selon la convention par défaut de golang, le chemin de travail actuel de go run, go install et d'autres commandes (c'est-à-dire exécuter ce qui précède commandes sous ce chemin).

2. Le fichier intermédiaire généré lors de la compilation de pkg (par exemple : .a) Lorsque golang compile le package

3. Le fichier exécutable généré après la compilation bin (pour plus de commodité, vous pouvez ajouter. ce répertoire dans la variable $PATH, s'il y a plusieurs gopaths, utilisez ${GOPATH//://bin:}/bin pour ajouter tous les répertoires bin)

Planification de la structure des répertoires de code

Le répertoire src sous GOPATH est le répertoire principal du prochain programme de développement. Tous les codes sources sont placés sous ce répertoire. Donc, généralement, notre approche est d'avoir un répertoire et un projet,

. Par exemple : $ GOPATH/src/mymath représente le package d'application mymath ou l'application exécutable. Cela dépend si le package est principal ou autre. S'il est principal, c'est une application exécutable. S'il est autre, c'est un package d'application. Ce package sera présenté en détail ultérieurement.

Jetez d'abord un œil à mon environnement go : go env

C:\Users\Administrator>go env
set GOARCH=amd64
set GOBIN=
set GOEXE=.exe
set GOHOSTARCH=amd64
set GOHOSTOS=windows
set GOOS=windows
set GOPATH=D:\project
set GORACE=
set GOROOT=D:\BaiduNetdiskDownload\go
set GOTOOLDIR=D:\BaiduNetdiskDownload\go\pkg\tool\windows_amd64
set GCCGO=gccgo
set CC=gcc
set GOGCCFLAGS=-m64 -mthreads -fmessage-length=0
set CXX=g++
set CGO_ENABLED=1
set CGO_CFLAGS=-g -O2
set CGO_CPPFLAGS=
set CGO_CXXFLAGS=-g -O2
set CGO_FFLAGS=-g -O2
set CGO_LDFLAGS=-g -O2
set PKG_CONFIG=pkg-config

GOROOT

est en fait le chemin d'installation de golang
Après avoir installé Golang, cela existe déjà

GOBIN

Jetez d'abord un œil à la structure :

Nous exécutons généralement go build dans le répertoire du projet, par exemple :

D:\project\src\go_dev\day1\package_example\main>go run main.go
400 100

Maintenant, nous devons compiler main.go, golang ira automatiquement dans src pour trouver le répertoire hello, car le code dans mon main.go est importé. Le package principal Packag peut donc être compilé dans un fichier exécutable, mais par défaut, le fichier exécutable est généré dans le répertoire courant. Bien que le répertoire puisse être spécifié, cela ne semble toujours pas très pratique

d:\project>go build go_dev/day1/package_example\main

Donc il y en a deux autres très bonnes Commandes utilisées : go get et go install

go get

go get fera deux choses :

1. Télécharger à distance. Le paquet est arrivé

2. Exécuter go install

go install

go install générera un exécutable. et placez-le directement dans le répertoire bin. Bien sûr, il y a des prérequis

Ce que vous compilez est un fichier exécutable. S'il s'agit d'un package ordinaire, il sera compilé et généré dans le répertoire pkg. le fichier se termine par .a

A propos de go L'ensemble du répertoire de développement

go_project     // go_project为GOPATH目录
  -- bin
     -- myApp1  // 编译生成
     -- myApp2  // 编译生成
     -- myApp3  // 编译生成
  -- pkg
  -- src
     -- myApp1     // project1
        -- models
        -- controllers
        -- others
        -- main.go 
     -- myApp2     // project2
        -- models
        -- controllers
        -- others
        -- main.go 
     -- myApp3     // project3
        -- models
        -- controllers
        -- others
        -- main.go

Configuration de l'environnement go sous Linux

1. Téléchargez d'abord le package go sous Linux : https://studygolang.com/ dl/golang/go1.9.2.linux-amd64.tar.gz

2 Après avoir téléchargé

tar -zxvf. go1.9.2.linux-amd64.tar.gz Décompressez le package source

3. Déplacez-vous vers /usr/local/go, qui est GOROOT

4. Définissez les variables d'environnement GOPATH et PATH<.>

export GOROOT=/usr/local/go #设置为go安装的路径
export GOPATH=$HOME/gocode #默认安装包的路径
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

Voir Linux go env

GOARCH="amd64"
GOBIN=""
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
GOPATH="/root/gocode"
GORACE=""
GOROOT="/usr/local/go"
GOTOOLDIR="/usr/local/go/pkg/tool/linux_amd64"
GCCGO="gccgo"
CC="gcc"
GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build057487015=/tmp/go-build -gno-record-gcc-switches"
CXX="g++"
CGO_ENABLED="1"
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"
PKG_CONFIG="pkg-config"

go env

Pour plus de connaissances sur Golang, veuillez faire attention à la colonne

tutoriel golang

.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!