Comment compiler Aller programme composé de plusieurs fichiers?

Donc, j'ai un petit programme qui se compose de trois fichiers, tous appartenant au même package (principal), mais quand je fais "aller construire principal.aller de" construction ne réussit pas. Quand il était juste un fichier (principale.aller) tout a bien fonctionné. Maintenant que j'ai pris un peu d'effort pour séparer le code, il semble que le compilateur ne trouve pas le truc qui a été sorti de la main.aller et de mettre en ces deux autres fichiers (qui se trouvent dans le même répertoire que le.allez). Qui résultats dans "undefined" type "erreurs".

J'ai lu quelque chose sur la définition de la GOPATH variable, j'ai donc essayé

set GOPATH=%cd%
go build main.go

mais cela aussi n'a pas fonctionné.

Toute aide est appréciée.

InformationsquelleAutor Vitaly | 2012-05-31

74

En supposant que vous êtes en train de rédiger un programme appelé myprog :

Mettre tous vos fichiers dans un répertoire comme ce
```
myproject/go/src/myprog/xxx.go
```
Puis ajouter myproject/go à GOPATH

Et exécuter
```
go install myprog
```
De cette façon vous serez en mesure d'ajouter d'autres paquets et des programmes dans monprojet/go/src si vous le souhaitez.

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

(ce doc est toujours oubliée par les nouveaux arrivants, et souvent mal compris à la première. Il devrait recevoir la plus grande attention de l'équipe de l'OMI)
- En effet, un chapitre très utile que j'ai négligé. Merci!
- pourquoi ne pas se débarrasser de l' /go/ et il suffit de faire myproject/src?
- aussi, je suppose "allez installer myprog", écrit la source du projet dans le $GOPATH emplacement en quelque sorte? Est ce que le droit? si oui, ce serait bien d'avoir des explications dans le cadre de la réponse ainsi
- Seuls les petits projets sont en utilisant une seule technologie.
- pas sûr que je suis d'accord avec ça, mais de toute façon c'est pour les projets simples, vous pouvez simplement déposer la partie - les gens pourraient penser que l'aller chose est nécessaire, et il ne l'est pas. - Vous me dire, ce qui est plus simple, à l'aller ou ne pas aller? 🙂
InformationsquelleAutor Denys Séguret
58

Lorsque vous séparer le code de main.go en par exemple more.go, il vous suffit de passer le fichier à go build/go run/go install ainsi.

Donc, si vous avez déjà exécuté
```
go build main.go
```
vous maintenant simplement
```
go build main.go more.go
```
Que de plus amples informations:
```
go build --help
```
états:
```
If the arguments are a list of .go files, build treats them as a list
of source files specifying a single package.
```
Avis que go build et go install diffèrent de go run en ce que le premier deux de l'état de s'attendre à ce noms de package comme arguments, alors que ce dernier s'attend à ce aller fichiers. Toutefois, les deux premiers seront également accepter d'aller les fichiers que go d'installation ne.

Si vous vous demandez: construire sera juste build les forfaits/fichiers, install va produire de l'objet et des fichiers binaires dans votre GOPATH, et run compiler et exécuter votre programme.
- Si vous ne voulez pas continuer à ajouter de plus en plus des fichiers, utiliser les regex, avec: aller courir *.aller
- ok merci, n'Allez toujours écrire un seul fichier exécutable out? Il permet de ne pas garder l'exécutable des fichiers séparés (comme en Java)?
- aller construire *.aller, cela fonctionne? qui n'a pas pour moi
- à cause de windows, je pense, utiliser nix. ou mingw au moins.
- ouais j'ai été en utilisant MacOS, mais c'est peut-être Bash version 3 qui est fuckin' vers le haut, je doivent mettre à jour Bash 4.
InformationsquelleAutor Kissaki
26

Vous pourriez tout aussi bien exécuter
```
go build
```
dans votre dossier de projet monprojet/go/src/myprog

Alors vous pouvez simplement taper
```
./myprog
```
pour exécuter votre application
- la sortie est un objet, pas un exécutable.
InformationsquelleAutor poopoothegorilla
3

Cela dépend de votre projet de la structure. Mais le plus simple est:
```
go build ./... -o ./myproject
```
puis exécutez ./myproject.

Que votre projet de la structure ressemble à ceci
```
- hello
|- main.go
```
alors vous allez simplement dans le répertoire du projet et exécuter
```
go build -o ./myproject
```
puis exécutez ./myproject de la coque.

ou
```
# most easiest; builds and run simultaneously
go run main.go
```
supposons que votre fichier principal est imbriqué dans un sous-répertoire comme un cmd
```
- hello
|- cmd
 |- main.go
```
puis vous rencontrez
```
go run cmd/main.go
```
- grâce à la -o paramètre m'a aidé
InformationsquelleAutor alamin
1

Vous pouvez utiliser
```
go build *.go 
go run *.go
```
les deux fonctionneront aussi vous pouvez utiliser des
```
go build .
go run .
```
InformationsquelleAutor Tushar Saha
0

Yup! C'est très simple et c'est là que le package de stratégie entre en jeu. il existe trois façons de mes connaissances.
structure de dossier:

GOPATH/src/
github.com/
abc/
myproject/
adaptateur/
principal.aller
pkg1
pkg2
avertissement: la carte peut contenir package principal seulement et le soleil répertoires
1. naviguez jusqu'à "la carte" dossier de. Exécuter:
```
    go build main.go
```
1. naviguez jusqu'à "la carte" dossier de. Exécuter:
```
    go build main.go
```
1. accédez à GOPATH/src
  reconnaître de chemin d'accès relatif à forfait principal, ici "monprojet/adaptateur". Exécuter:
```
    go build myproject/adapter
```
exe fichier sera créé dans le répertoire que vous êtes actuellement.

InformationsquelleAutor Sayan Dey

Vous devez vous connecter pour publier un commentaire.