Organisieren eines Go-Projekts mit mehreren Dateien [geschlossen]

Hinweis: Diese Frage bezieht sich auf diese , aber zwei Jahre sind eine sehr lange Zeit in der Go-Geschichte.

Was ist die Standardmethode, um ein Go-Projekt während der Entwicklung zu organisieren?

Mein Projekt ist ein einzelnes Paket mypack, also habe ich wohl alle .go-Dateien in einem mypackVerzeichnis abgelegt .

Aber dann möchte ich es während der Entwicklung testen, damit ich mindestens eine Datei benötige, die das mainPaket deklariert , damit ich es tun kanngo run trypack.go

Wie soll ich das organisieren? Muss ich go install mypackjedes Mal tun, wenn ich es versuchen möchte?

Ich würde empfehlen, diese Seite unter Schreiben von Go-Code zu lesen

Es dokumentiert sowohl die go buildfreundliche Strukturierung Ihres Projekts als auch das Schreiben von Tests. Tests müssen mit dem mainPaket kein cmd sein . Sie können einfach TestX-benannte Funktionen als Teil jedes Pakets sein und go testwerden sie dann entdecken.

Die in diesem Link in Ihrer Frage vorgeschlagene Struktur ist etwas veraltet, jetzt mit der Veröffentlichung von Go 1. Sie müssten kein pkgVerzeichnis mehr unter platzieren src. Die einzigen 3 spezifikationsbezogenen Verzeichnisse sind die 3 im Stammverzeichnis Ihres GOPATH: bin, pkg, src. Unter src können Sie einfach Ihr Projekt platzieren mypack, und darunter befinden sich alle Ihre .go-Dateien, einschließlich mypack_test.go

go build wird dann in die Root-Ebene pkg und bin bauen.

Ihr GOPATH könnte also so aussehen:

~/projects/
    bin/
    pkg/
    src/
      mypack/
        foo.go
        bar.go
        mypack_test.go

export GOPATH=$HOME/projects

$ go build mypack
$ go test mypack

Update: wie von> = Go 1.11, das Modulsystem ist jetzt ein Standardteil des Werkzeugs und das GOPATH Konzept ist in der Nähe obsolet zu werden.

jdi hat die richtigen Informationen bezüglich der Verwendung von GOPATH. Ich würde hinzufügen, dass Sie, wenn Sie auch eine Binärdatei haben möchten, möglicherweise eine zusätzliche Ebene zu den Verzeichnissen hinzufügen möchten.

~/projects/src/
    myproj/
        mypack/
            lib.go
            lib_test.go
            ...
        myapp/
            main.go

Durch Ausführen go build myproj/mypackwird das mypackPaket zusammen mit den Abhängigkeiten erstellt. Durch Ausführen go build myproj/myappwird die myappBinärdatei zusammen mit den Abhängigkeiten erstellt, die wahrscheinlich die mypackBibliothek enthalten.

Ich habe eine Reihe von Go-Projekten studiert und es gibt einiges an Abwechslung. Sie können feststellen, wer von C und wer von Java kommt, da der erstere Speicherauszug fast alles im Stammverzeichnis des Projekts in einem mainPaket enthält und der letztere dazu neigt, alles in ein srcVerzeichnis zu stellen. Beides ist jedoch nicht optimal. Beide haben Konsequenzen, da sie sich auf Importpfade auswirken und darauf, wie andere sie wiederverwenden können.

Um die besten Ergebnisse zu erzielen, habe ich den folgenden Ansatz ausgearbeitet.

myproj/
  main/
    mypack.go
  mypack.go

Wo mypack.goist package mypackund main/mypack.goist (offensichtlich) package main.

Wenn Sie zusätzliche Unterstützungsdateien benötigen, haben Sie zwei Möglichkeiten. Bewahren Sie sie entweder alle im Stammverzeichnis auf oder speichern Sie private Supportdateien in einem libUnterverzeichnis. Z.B

myproj/
  main/
    mypack.go
  myextras/
    someextra.go
  mypack.go
  mysupport.go

Oder

myproj.org/
  lib/
    mysupport.go
    myextras/
      someextra.go
  main/
    mypack.go
  mypage.go

Legen Sie die Dateien nur in einem libVerzeichnis ab, wenn sie nicht von einem anderen Projekt importiert werden sollen. Mit anderen Worten, wenn es sich um private Supportdateien handelt. Das ist die Idee dahinter, liböffentliche von privaten Schnittstellen zu trennen.

Wenn Sie die Dinge auf diese Weise myproj.org/mypackausführen , erhalten Sie einen schönen Importpfad, um den Code in anderen Projekten wiederzuverwenden. Wenn Sie verwenden, haben libinterne Support-Dateien einen Importpfad, der darauf hinweist myproj.org/lib/mysupport.

Verwenden Sie beim Erstellen des Projekts main/mypackz go build main/mypack. Wenn Sie mehr als eine ausführbare Datei haben, können Sie diese auch unter trennen, mainohne separate Projekte erstellen zu müssen. zB main/myfoo/myfoo.gound main/mybar/mybar.go.

Ich finde es sehr nützlich zu verstehen, wie man Code in Golang in diesem Kapitel http://www.golang-book.com/11 des Buches von Caleb Doxsey organisiert

Es scheint keine Standardmethode zum Organisieren von Go-Projekten zu geben, aber https://golang.org/doc/code.html gibt eine bewährte Methode für die meisten Projekte an. Die Antwort von jdi ist gut, aber wenn Sie Github oder Bitbucket verwenden und zusätzliche Bibliotheken haben, sollten Sie die folgende Struktur erstellen:

~/projects/
bin/
pkg/
src/
  github.com/
    username/
        mypack/
            foo.go
            bar.go
            mypack_test.go
        mylib/
            utillib.go
            utillib_test.go

Auf diese Weise können Sie ein separates Repository für mylib einrichten, das für andere Projekte verwendet und über "go get" abgerufen werden kann. Ihr mypack-Projekt kann Ihre Bibliothek über "github.com/username/mylib" importieren. Für mehr Informationen:

http://www.alexvictorchan.com/2014/11/06/go-project-structure/

Bewahren Sie die Dateien im selben Verzeichnis auf und verwenden Sie sie package mainin allen Dateien.

myproj/
   your-program/
      main.go
      lib.go

Dann renne:

~/myproj/your-program$ go build && ./your-program

Lassen Sie uns untersuchen, wie der go get repository_remote_urlBefehl die Projektstruktur unter verwaltet $GOPATH. Wenn wir ago get github.com/gohugoio/hugo wird das Repository unter geklont

$ GOPATH / src / repository_remote / benutzername / projektname

$ GOPATH / src / github.com/gohugoio/hugo

Dies ist eine gute Möglichkeit, Ihren ersten Projektpfad zu erstellen . Lassen Sie uns nun untersuchen, welche Projekttypen es gibt und wie ihre inneren Strukturen organisiert sind. Alle Golang-Projekte in der Community können unter kategorisiert werden

• Libraries (keine ausführbaren Binärdateien)
• Single Project (enthält nur 1 ausführbare Binärdatei)
• Tooling Projects (enthält mehrere ausführbare Binärdateien)

Im Allgemeinen können Golang-Projektdateien nach beliebigen Entwurfsprinzipien wie DDD , POD gepackt werden

Die meisten verfügbaren Go-Projekte folgen diesem paketorientierten Design

Paketorientiertes Design ermutigt den Entwickler, die Implementierung nur in seinen eigenen Paketen zu belassen, außer in dem /internalPaket, das diese Pakete nicht miteinander kommunizieren können

Bibliotheken

• Projekte wie Datenbanktreiber , qt in diese Kategorie .
• Einige Bibliotheken wie Farbe , jetzt folgt eine flache Struktur ohne weitere Pakete.
• Die meisten dieser Bibliotheksprojekte verwalten ein Paket namens intern .
• /internal Paket wird hauptsächlich verwendet, um die Implementierung vor anderen Projekten zu verbergen.
• Haben keine ausführbare Binärdateien, so dass keine Dateien, die die enthält Haupt Func .

 ~/$GOPATH/
    bin/
    pkg/
    src/
      repository_remote/
        user_name/
            project_name/
              internal/
              other_pkg/

Einzelprojekt

• Projekte wie hugo , etcd haben eine einzige Hauptfunktion in root level und.
• Ziel ist es, eine einzelne Binärdatei zu generieren

Werkzeugprojekte

• Projekte wie kubernetes , go-ethereum haben mehrere Hauptfunktionen, die unter einem Paket namens cmd organisiert sind
• cmd/ Paket verwaltet die Anzahl der Binärdateien (Tools), die wir erstellen möchten

 ~/$GOPATH/
    bin/
    pkg/
    src/
      repository_remote/
        user_name/
            project_name/
              cmd/
                binary_one/
                   main.go
                binary_two/
                   main.go
                binary_three/
                   main.go
              other_pkg/