web-dev-qa-db-fra.com

Comment importer une version spécifique d'un package à l'aide de go get?

provenant d’un environnement Node j’avais l'habitude d'installer une version spécifique d'une bibliothèque du fournisseur dans le dossier du projet (node_modules) en disant à npm d’installer cette version de cette lib depuis le package.json ou même directement depuis la console, comme ceci:

$ npm install [email protected]

Ensuite, j'avais l'habitude d'importer cette version de ce paquet dans mon projet simplement avec:

var express = require('express');

Maintenant, je veux faire la même chose avec go. Comment puis je faire ça? Est-il possible d'installer une version spécifique d'un paquet? Si tel est le cas, en utilisant un $GOPATH, comment puis-je importer une version au lieu d'une autre?

Je ferais quelque chose comme ça:

$ go get github.com/wilk/[email protected]
$ go get github.com/wilk/[email protected]

Mais alors, comment puis-je faire une différence lors de l'importation?

gopackagepackage-managers
82
Wilk

Mise à jour 18-11-23: À partir du Go 1.11, le mod est une expérience officielle. S'il vous plaît voir @krish réponse.
Mise à jour 19-01-01: À partir du Go 1.12, le mod est toujours une expérience officielle. À partir de Go 1.13, le mode module sera le mode par défaut pour tous les développements.

Ancienne réponse:

Vous pouvez définir la version par officiel dep

dep ensure --add github.com/gorilla/[email protected]
9
vitams

Vraiment surpris, personne n'a mentionné gopkg.in .

gopkg.in est un service qui fournit un wrapper (redirection) qui vous permet d’exprimer les versions sous forme d’URL de dépôt, sans créer de repos. Par exemple. gopkg.in/yaml.v1 contre gopkg.in/yaml.v2, même s'ils habitent tous les deux à https://github.com/go-yaml/yaml

Ce n'est pas parfait si l'auteur ne suit pas les pratiques de gestion de version appropriées (en incrémentant le numéro de version lors de la suppression de la compatibilité ascendante), mais cela fonctionne avec les branches et les balises.

36
Steven Soroka

Go 1.11 aura une fonctionnalité appelée modules go et vous pouvez simplement ajouter une dépendance avec une version.

Pas

  1. go mod init .
  2. go mod edit -require github.com/wilk/[email protected]

Voici plus d'informations sur ce sujet: https://github.com/golang/go/wiki/Modules

25
krish

Vous pouvez utiliser git checkout pour obtenir une version spécifique et construire votre programme en utilisant cette version.

Exemple:

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
22
João Paraná

Glide est une gestion de paquet très élégante pour Go, surtout si vous venez de Node's npm ou de Rust.

Il se comporte de manière similaire à la nouvelle fonctionnalité de fournisseur de Godep dans la version 1.6, mais est beaucoup plus simple. Vos dépendances et vos versions sont "verrouillées" dans votre répertoire rép_projet/fournisseur sans faire appel à GOPATH.

Installer avec infusion (OS X)

$ brew install glide

Initiez le fichier glide.yaml (semblable à package.json). Cela récupère également les paquets importés existants dans votre projet à partir de GOPATH et les copie ensuite dans le répertoire fournisseur/du projet.

$ glide init

Obtenir de nouveaux forfaits

$ glide get vcs/namespace/package

Mettez à jour et verrouillez les versions des packages. Cela crée un fichier glide.lock dans le répertoire de votre projet pour verrouiller les versions.

$ glide up

J'ai essayé de glisser et je l'ai utilisé avec bonheur pour mon projet actuel.

13
Pie 'Oh' Pah

À partir de Go 1.5, il y a le "expérience de fournisseur" qui vous aide à gérer les dépendances. À partir de Go 1.6, ce n'est plus une expérience. Theres also Quelques autres options sur le wiki Go. .

Edit: comme mentionné dans cette réponsegopkg.in est une bonne option pour épingler des dépendances github antérieures à la version 1.5.

9
larsmoa

dep est l'expérimentation officielle pour la gestion des dépendances en langue Go. Il faut Go 1.8 ou plus récent pour compiler.

Pour commencer à gérer les dépendances à l'aide de dep , exécutez la commande suivante à partir du répertoire racine de votre projet:

dep init

Après exécution, deux fichiers seront générés: Gopkg.toml ("manifeste"), Gopkg.lock et les packages nécessaires seront téléchargés dans le répertoire vendor.

Supposons que vous avez le projet qui utilise github.com/gorilla/websocket paquet. dep générera les fichiers suivants:

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

Il y a des commandes qui vous aident à mettre à jour/supprimer/les paquets/etc, veuillez trouver plus d'informations sur repo officiel de github sur dep (outil de gestion des dépendances pour Go).

8
Aliaksei Maniuk

go get est le gestionnaire de paquets Go. Cela fonctionne de manière totalement décentralisée et comment la découverte de paquets est toujours possible sans référentiel d'hébergement de paquets central.

En plus de la localisation et du téléchargement des paquets, l’autre grand rôle du gestionnaire de paquets est de gérer plusieurs versions du même paquet. Go adopte l'approche la plus minimale et la plus pragmatique de tout gestionnaire de paquets. Il n’existe pas de versions multiples d’un package Go.

va chercher tire toujours du HEAD de la branche par défaut du référentiel. Toujours. Cela a deux implications importantes:

  1. En tant qu'auteur de package, vous devez adhérer à la philosophie stable HEAD. Votre branche par défaut doit toujours être la version stable et publiée de votre package. Vous devez travailler dans les branches de fonctionnalités et fusionner uniquement lorsque vous êtes prêt. à libérer.

  2. Les nouvelles versions majeures de votre paquet doivent avoir leur propre référentiel. En termes simples, chaque version majeure de votre paquet (suivant le versioning sémantique) aurait son propre référentiel et donc son propre chemin d'importation .

    par exemple. github.com/jpoehls/gophermail-v1 et github.com/jpoehls/gophermail-v2.

En tant que concepteur d'applications Go, la philosophie ci-dessus n'a pas d'inconvénient. Chaque chemin d'importation est une API stable. Il n'y a pas de numéro de version à craindre. Impressionnant!

Pour plus de détails: http://zduck.com/2014/go-and-package-versioning/

7
faisal_kk

L’approche que j’ai trouvée viable est système de sous-modules de git . En utilisant cela, vous pouvez créer un sous-module dans une version donnée du code et la mise à niveau/le déclassement est explicite et enregistré - jamais au hasard.

La structure de dossier que j'ai prise avec ceci est:

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