Wie importiere ich eine bestimmte Version eines Pakets mit go get?

NodeIch komme aus einer Umgebung, in der ich eine bestimmte Version einer Herstellerbibliothek im Projektordner ( node_modules) npminstalliert habe, indem ich angewiesen habe , diese Version dieser Bibliothek von der package.jsonoder sogar direkt von der Konsole aus zu installieren , wie folgt:

$ npm install express@4.0.0

Dann habe ich diese Version dieses Pakets in mein Projekt importiert, nur mit:

var express = require('express');

Jetzt möchte ich das Gleiche tun go. Wie kann ich das machen? Ist es möglich, eine bestimmte Version eines Pakets zu installieren? Wenn ja, $GOPATHwie kann ich mithilfe einer zentralen Version eine Version anstelle einer anderen importieren?

Ich würde so etwas machen:

$ go get github.com/wilk/uuid@0.0.1
$ go get github.com/wilk/uuid@0.0.2

Aber wie kann ich dann beim Import einen Unterschied machen?

Go 1.11 wird eine Funktion namens go modules haben und Sie können einfach eine Abhängigkeit mit einer Version hinzufügen. Folge diesen Schritten:

go mod init .
go mod edit -require github.com/wilk/uuid@0.0.1` 
go get -v -t ./...   
go build
go install 

Hier finden Sie weitere Informationen zu diesem Thema - https://github.com/golang/go/wiki/Modules

Wirklich überrascht, dass niemand gopkg.in erwähnt hat .

gopkg.inist ein Dienst, der einen Wrapper (Redirect) bereitstellt, mit dem Sie Versionen als Repo-URLs ausdrücken können, ohne tatsächlich Repos zu erstellen. ZB gopkg.in/yaml.v1vs gopkg.in/yaml.v2, obwohl beide bei lebenhttps://github.com/go-yaml/yaml

• gopkg.in/yaml.v1 leitet zu https://github.com/go-yaml/yaml/tree/v1 weiter
• gopkg.in/yaml.v2 leitet zu https://github.com/go-yaml/yaml/tree/v2 weiter

Dies ist nicht perfekt, wenn der Autor nicht die richtigen Versionsverfahren befolgt (indem er die Versionsnummer erhöht, wenn die Abwärtskompatibilität unterbrochen wird), aber es funktioniert mit Zweigen und Tags.

git checkoutMit dieser Version können Sie eine bestimmte Version abrufen und Ihr Programm erstellen.

Beispiel:

export GOPATH=~/
go get github.com/whateveruser/whateverrepo
cd ~/src/github.com/whateveruser/whateverrepo
git tag -l
# supose tag v0.0.2 is correct version
git checkout tags/v0.0.2
go run whateverpackage/main.go

Glide ist ein wirklich elegantes Paketmanagement für Go, besonders wenn Sie von Node's npm oder Rust's Fracht kommen.

Es verhält sich ähnlich wie die neue Herstellerfunktion von Godep in 1.6, ist jedoch viel einfacher. Ihre Abhängigkeiten und Versionen sind in Ihrem Projektverzeichnis / Herstellerverzeichnis "gesperrt", ohne auf GOPATH angewiesen zu sein.

Mit Brew installieren (OS X)

$ brew install glide

Initialisieren Sie die Datei glide.yaml (ähnlich wie package.json). Dadurch werden auch die vorhandenen importierten Pakete in Ihrem Projekt von GOPATH abgerufen und dann in den Anbieter / das Verzeichnis des Projekts kopiert.

$ glide init

Holen Sie sich neue Pakete

$ glide get vcs/namespace/package

Aktualisieren und sperren Sie die Versionen der Pakete. Dadurch wird die Datei glide.lock in Ihrem Projektverzeichnis erstellt, um die Versionen zu sperren.

$ glide up

Ich habe versucht zu gleiten und benutze es gerne für mein aktuelles Projekt.

Update 18-11-23 : From Go 1.11 Mod ist offizielles Experiment. Bitte siehe @krish Antwort.
Update 19-01-01 : From Go 1.12 Mod ist noch offizielles Experiment. Ab Go 1.13 ist der Modulmodus die Standardeinstellung für alle Entwicklungen.
Update 19-10-17 : From Go 1.13 Mod ist offizieller Paketmanager.

https://blog.golang.org/using-go-modules

Alte Antwort:

Sie können die Version durch offizielle Abteilung einstellen

dep ensure --add github.com/gorilla/websocket@1.2.0

Ab Go 1.5 gibt es das "Herstellerexperiment" , mit dem Sie Abhängigkeiten verwalten können. Ab Go 1.6 ist dies kein Experiment mehr. Es gibt auch einige andere Optionen im Go-Wiki. .

Bearbeiten: Wie in dieser Antwort erwähnt, ist gopkg.in eine gute Option zum Fixieren von Github-Abhängigkeiten vor 1.5.

depist das offizielle Experiment zum Abhängigkeitsmanagement für die Go-Sprache. Zum Kompilieren ist Go 1.8 oder neuer erforderlich.

depFühren Sie den folgenden Befehl aus dem Stammverzeichnis Ihres Projekts aus, um mit der Verwaltung von Abhängigkeiten zu beginnen :

dep init

Nach der Ausführung werden zwei Dateien generiert: Gopkg.toml("Manifest") Gopkg.lockund die erforderlichen Pakete werden in das vendorVerzeichnis heruntergeladen .

Nehmen wir an, Sie haben das Projekt, das das github.com/gorilla/websocketPaket verwendet. depgeneriert folgende Dateien:

Gopkg.toml

# Gopkg.toml example
#
# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
# for detailed Gopkg.toml documentation.
#
# required = ["github.com/user/thing/cmd/thing"]
# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
#
# [[constraint]]
#   name = "github.com/user/project"
#   version = "1.0.0"
#
# [[constraint]]
#   name = "github.com/user/project2"
#   branch = "dev"
#   source = "github.com/myfork/project2"
#
# [[override]]
#  name = "github.com/x/y"
#  version = "2.4.0"


[[constraint]]
  name = "github.com/gorilla/websocket"
  version = "1.2.0"

Gopkg.lock

# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.


[[projects]]
  name = "github.com/gorilla/websocket"
  packages = ["."]
  revision = "ea4d1f681babbce9545c9c5f3d5194a789c89f5b"
  version = "v1.2.0"

[solve-meta]
  analyzer-name = "dep"
  analyzer-version = 1
  inputs-digest = "941e8dbe52e16e8a7dff4068b7ba53ae69a5748b29fbf2bcb5df3a063ac52261"
  solver-name = "gps-cdcl"
  solver-version = 1

Es gibt Befehle, die Ihnen beim Aktualisieren / Löschen / etc-Paketen helfen. Weitere Informationen zum offiziellen Github-Repo von dep(Abhängigkeitsmanagement-Tool für Go).

Heutzutage kann man es einfach dafür verwenden go get. Sie können Ihre Abhängigkeit über das Versions-Tag, den Zweig oder sogar das Commit abrufen.

go get github.com/someone/some_module@master
go get github.com/someone/some_module@v1.1.0
go get github.com/someone/some_module@commit_hash

Weitere Details hier - Wie kann die Go-Modulabhängigkeit in go.mod auf ein aktuelles Commit in einem Repo hingewiesen werden?

Go getwird auch installieren die binäre, wie es in der Dokumentation sagt -

Get downloads the packages named by the import paths, along with their dependencies. It then installs the named packages, like 'go install'.

(von https://golang.org/cmd/go/ )

go get ist der Go-Paketmanager. Es funktioniert vollständig dezentral und wie die Paketerkennung ohne ein zentrales Paket-Hosting-Repository noch möglich ist.

Neben dem Auffinden und Herunterladen von Paketen besteht die andere große Rolle eines Paketmanagers darin, mehrere Versionen desselben Pakets zu verarbeiten. Go verfolgt den minimalsten und pragmatischsten Ansatz eines Paketmanagers. Es gibt nicht mehrere Versionen eines Go-Pakets.

go get zieht immer aus dem HEAD des Standardzweigs im Repository. Immer. Dies hat zwei wichtige Auswirkungen:

1. Als Paketautor müssen Sie sich an die stabile HEAD-Philosophie halten. Ihr Standardzweig muss immer die stabile, freigegebene Version Ihres Pakets sein. Sie müssen in Feature-Zweigen arbeiten und erst dann zusammenführen, wenn Sie zur Freigabe bereit sind.

2. Neue Hauptversionen Ihres Pakets müssen über ein eigenes Repository verfügen. Einfach ausgedrückt, hätte jede Hauptversion Ihres Pakets (nach der semantischen Versionierung) ein eigenes Repository und damit einen eigenen Importpfad.

   zB github.com/jpoehls/gophermail-v1 und github.com/jpoehls/gophermail-v2.

Als jemand, der eine Anwendung in Go erstellt, hat die obige Philosophie wirklich keinen Nachteil. Jeder Importpfad ist eine stabile API. Es gibt keine Versionsnummern, über die Sie sich Sorgen machen müssen. Genial!

Für weitere Informationen: http://zduck.com/2014/go-and-package-versioning/

Der Ansatz, den ich für praktikabel befunden habe, ist das Submodul-System von git . Damit können Sie eine bestimmte Version des Codes submodulieren und das Upgrade / Downgrade ist explizit und aufgezeichnet - niemals zufällig.

Die Ordnerstruktur, die ich damit genommen habe, ist:

+ myproject
++ src
+++ myproject
+++ github.com
++++ submoduled_project of some kind.

Das hat bei mir funktioniert

GO111MODULE=on go get -u github.com/segmentio/[email protected]

Es gibt einen Befehl go edit -replace, mit dem ein bestimmtes Commit (auch aus einem anderen gegabelten Repository) an die aktuelle Version eines Pakets angehängt werden kann . Das Coole an dieser Option ist, dass Sie nicht vorher die genaue Pseudoversion kennen müssen, sondern nur die Commit-Hash-ID .

Zum Beispiel verwende ich die stabile Version des Pakets "github.com/onsi/ginkgo v1.8.0".

Jetzt möchte ich - ohne diese Zeile des erforderlichen Pakets in go.mod zu ändern - einen Patch von meiner Gabel über die Ginkgo-Version anhängen:

$ GO111MODULE="on"  go mod edit -replace=github.com/onsi/ginkgo=github.com/manosnoam/ginkgo@d6423c2

Nach dem ersten Erstellen oder Testen Ihres Moduls versucht GO, die neue Version abzurufen und anschließend die Zeile "Ersetzen" mit der richtigen Pseudoversion zu generieren. In meinem Fall wird beispielsweise unten in go.mod Folgendes hinzugefügt:

Ersetzen Sie github.com/onsi/ginkgo => github.com/manosnoam/ginkgo v0.0.0-20190902135631-1995eead7451

Ein kleiner Spickzettel zu Modulabfragen.

So überprüfen Sie alle vorhandenen Versionen: z go list -m -versions github.com/gorilla/mux

1. Spezifische Version @ v1.2.8
2. Spezifisches Commit @ c783230
3. Spezifisches Commit @master
4. Versionspräfix @ v2
5. Vergleich @> = 2.1.5
6. Neueste @latest

Z.B go get github.com/gorilla/[email protected]