Structure du système de fichiers d'un projet Go

Structure des dossiers

Les projets Go sont composés depaquets. Nous appelonscommandesles packages qui ont lemainidentifiant.

Un projet peut avoir

  • 1paquet
  • npaquets
  • 1commander
  • 1commande et1paquet
  • ncommandes et1paquet
  • 1commande etnpaquets
  • ncommandes etnpaquets

Selon la nature de votre projet, vous devez organiser la structure des dossiers d'une certaine manière.

Quelques exemples du monde réel

Voyons quelques exemples concrets de cela dans la nature, ci-dessous. Je les ai pris deCinq suggestions pour mettre en place un projet Gopar Dave Cheney.

Exemple de projet avec1paquet:

https://github.com/kr/fs

Exemple de projet avecnpaquets

https://github.com/pkg/term

Exemple de projet avec1commander

https://github.com/tools/godep

Exemple de projet avec1commande et1paquet

https://github.com/monochromegane/the_platinum_searcher

Exemple de projet avecncommandes etnpaquets

https://github.com/golang/tools

Conventions pour la structure de fichiers dans un projet

À partir de ces exemples, nous pouvons dire ces conventions:

Si vous avez une commande, elle peut vivre dans unmain.gofichier à la racine du projet.

Avec plusieurs commandes, créez uncmd/dossier, et sous celui-ci, créez un dossier avec le nom de la commande. Dans chaque dossier, idéalement un.gole fichier avec le même nom contiendra lemain()fonction, bien que ce ne soit pas obligatoire.

Les packages vont dans leur propre dossier, sauf si vous n'avez qu'un seul package.

Emplacement du système de fichiers pour les packages installés

Tout projet Go peut être installé en utilisantgo get.go getinstallera les packages sous$GOPATH/src. Par exemple en tapant

go get github.com/kr/fs

va télécharger et installer le référentiel 1-package situé àhttps://github.com/kr/fs, et il le mettra sous$GOPATH/src/github.com/kr/fs. Nous pouvons simplement le référencer dans nos programmes en utilisantimport github.com/kr/fs.

Et si on tape

go get github.com/tools/godep

au lieu? N'oubliez pas qu'il s'agit du référentiel à commande unique que nous avons répertorié auparavant.

go getva le télécharger comme il l'a fait pourgithub.com/kr/fs, et mettez-le sous$GOPATH/src, MAIS puisque c'est une commande, il compilera et créera également un$GOPATH/bin/godepbinaire.

Les commandes Go sont compilées avec le nom du dossier englobant, dans ce cas, le dossier était le dossier racine, donc c'estgodep. Dans le cas de commandes multiples, il faudradernier sous-dossierNom. Par exemple, un idéalgithub.com/flaviocopes/tools/cmd/unzipserait compilé enunzip. Cela faitne pasprenez le nom du fichier contenant lemain()fonction.

Espaces de travail

Go a un concept tout à fait unique deespace de travail. Un espace de travail est la structure de dossiers qui$GOPATHpointe vers. Lorsque vous créez un nouvel espace de travail, ajoutez le$GOPATH/bindossier sur votre chemin. Par exemple, si vous souhaitez définir votre espace de travail sur~/go(qui d'ailleurs est la valeur par défaut):

export GOPATH=~/go
export PATH=~/go/bin:$PATH

Désormais, tout code Go que vous exécutez fera référence à ce dossier. Cela vous permet de créer des espaces de travail séparés, bien que comme indiquédans la documentation officielle,

Les programmeurs Go conservent généralement tout leur code Go dans un seul espace de travail.

Notez que cela diffère des autres environnements de programmation dans lesquels chaque projet a un espace de travail séparé et les espaces de travail sont étroitement liés aux référentiels de contrôle de version.

Voici un exemple d'espace de travail, répertorié dans la documentation officielle:

    bin/
        hello                          # command executable
        outyet                         # command executable
    pkg/
        linux_amd64/
            github.com/golang/example/
                stringutil.a           # package object
    src/
        github.com/golang/example/
            .git/                      # Git repository metadata
        hello/
            hello.go               # command source
        outyet/
            main.go                # command source
            main_test.go           # test source
        stringutil/
            reverse.go             # package source
            reverse_test.go        # test source
        golang.org/x/image/
            .git/                  # Git repository metadata
        bmp/
            reader.go              # package source
            writer.go              # package source
        #... (many more repositories and packages omitted) ...

Sachant cela, voyons voir ...

Où placer vos commandes et packages

Lors de l'exécution de commandes à l'aide dego run, vous pouvez avoir votre projet où vous le souhaitez, mais cette approche n'est utile que pour des tests rapides.

Vous devez créer vos programmes dans le$GOPATH/srcdossier, avec votre espace de noms unique, par exemple

$GOPATH/src/github.com/flaviocopes/hello

Lors de l'exécution (de n'importe où dans le système)

go install github.com/flaviocopes/hello

Go compilera et placera lehellobinaire en$GOPATH/bin, prêt à être exécuté de n'importe où dans le système.

Il en va de même pour les colis,saufque lors de l'exécutiongo install, il mettra le paquet compilé sous$GOPATH/pkg.

Référence


Plus de tutoriels go: