Comment compiler un programme Go composé de plusieurs fichiers?

J'ai un petit programme qui se compose de trois fichiers, tous appartenant au même package (main), mais quand je fais "go build main.go", la construction ne réussit pas. Quand il n'y avait qu'un seul fichier (main.go), tout fonctionnait bien. Maintenant que j'ai pris quelques efforts pour séparer le code, il semble que le compilateur est incapable de trouver le contenu qui a été retiré de main.go et placé dans ces deux autres fichiers (qui résident dans le même répertoire que le main.go) . Ce qui entraîne des erreurs de "type" indéfini ".

Comment compiler ce programme composé de plusieurs fichiers?

Nouvelle méthode ( recommandée ):

Veuillez jeter un œil à cette réponse .

Ancienne façon:

Supposons que vous écriviez un programme appelé myprog:

Mettez tous vos fichiers dans un répertoire comme celui-ci

myproject/go/src/myprog/xxx.go

Puis ajoutez myproject/goà GOPATH

Et courir

go install myprog

De cette façon, vous pourrez ajouter d'autres packages et programmes dans myproject / go / src si vous le souhaitez.

Référence: http://golang.org/doc/code.html

(ce doc est toujours manqué par les nouveaux arrivants, et souvent mal compris au début. Il devrait recevoir la plus grande attention de l'équipe Go IMO)

Lorsque vous séparez le code de main.godans, par exemple more.go, vous transmettez simplement ce fichier à go build/ go run/ go install.

Donc, si vous avez déjà couru

go build main.go

toi maintenant simplement

go build main.go more.go

Comme informations complémentaires:

go build --help

États:

Si les arguments sont une liste de fichiers .go, build les traite comme une liste de fichiers source spécifiant un seul package.

Notez que go buildet go installdiffèrent de go runcela, les deux premiers état d'attendre des noms de package comme arguments, tandis que le dernier attend des fichiers go . Cependant, les deux premiers acceptent également les fichiers go comme le fait go install.

Si vous vous demandez: build ne contiendra que buildles packages / fichiers, installproduira des objets et des fichiers binaires dans votre GOPATH, et runcompilera et exécutera votre programme.

Vous pouvez aussi simplement courir

go build

dans le dossier de votre projet myproject / go / src / myprog

Ensuite, vous pouvez simplement taper

./myprog

pour exécuter votre application

Depuis Go 1.11+, GOPATH n'est plus recommandé, la nouvelle méthode utilise les modules Go.

Disons que vous écrivez un programme appelé simple:

1. Créez un répertoire:

   mkdir simple
   cd simple

2. Créez un nouveau module:

   go mod init github.com/username/simple
   # Here, the module name is: github.com/username/simple.
   # You're free to choose any module name.
   # It doesn't matter as long as it's unique.
   # It's better to be a URL: so it can be go-gettable.

3. Mettez tous vos fichiers dans ce répertoire.

4. Enfin, exécutez:

   go run .

5. Vous pouvez également créer un programme exécutable en le construisant:

   go build .
   
   # then:
   ./simple     # if you're on xnix
   
   # or, just:
   simple       # if you're on Windows

Pour plus d'informations, vous pouvez lire ceci .

Go a inclus le support des modules versionnés comme proposé ici depuis 1.11. Le prototype initial de vgo a été annoncé en février 2018. En juillet 2018, les modules versionnés ont atterri dans le référentiel principal de Go. Dans Go 1.14, la prise en charge des modules est considérée comme prête à être utilisée en production et tous les utilisateurs sont encouragés à migrer vers des modules à partir d'autres systèmes de gestion des dépendances.

Vous pouvez utiliser

go build *.go 
go run *.go

les deux fonctionneront aussi vous pouvez utiliser

go build .
go run .

Cela dépend de la structure de votre projet. Mais le plus simple est:

go build ./... -o ./myproject

puis courez ./myproject.

Supposons que la structure de votre projet ressemble à ceci

- hello
|- main.go

alors vous allez simplement dans le répertoire du projet et exécutez

go build -o ./myproject

puis exécutez ./myprojectsur shell.

ou

# most easiest; builds and run simultaneously
go run main.go

supposons que votre fichier principal soit imbriqué dans un sous-répertoire comme un cmd

- hello
|- cmd
 |- main.go

alors tu vas courir

go run cmd/main.go

Ouaip! C'est très simple et c'est là que la stratégie de package entre en jeu. il y a trois manières à ma connaissance. structure des dossiers:

GOPATH / src / github.com/ abc / myproject / adapter / main.go pkg1 pkg2 avertissement: l'adaptateur ne peut contenir que les répertoires principal du package et sun

1. accédez au dossier «adaptateur». Courir:

    go build main.go

2. accédez au dossier «adaptateur». Courir:

    go build main.go

3. naviguez vers GOPATH / src reconnaissez le chemin relatif vers le package principal, ici "myproject / adapter". Courir:

    go build myproject/adapter

exe sera créé dans le répertoire dans lequel vous vous trouvez actuellement.