Télécharger une étiquette spécifique avec Git

git clone --branch my_abc http://git.abc.net/git/abc.git

clonera le repo et vous laissera sur l'étiquette qui vous intéresse.

de la Documentation pour la version 1.8.0 de git clone états.

-- branch peut aussi prendre des tags et détacher la tête à cette propagation dans le dépôt résultant.

Je ne suis pas un expert git, mais je pense que cela devrait fonctionner:

git clone http://git.abc.net/git/abc.git
cd abc
git checkout my_abc 

ou

git clone http://git.abc.net/git/abc.git
cd abc
git checkout -b new_branch my_abc

la seconde variante établit une nouvelle branche basée sur l'étiquette, ce qui permet d'éviter une 'tête détachée'. (git-extraction manuelle)

chaque git repo contient l'historique complet de la révision, donc cloner le repo vous donne accès à la dernière propagation, plus Tout ce qui est venu avant, y compris la balise vous êtes à la recherche pour.

pour vérifier seulement une étiquette donnée pour le déploiement, j'utilise par exemple:

git clone -b 'v2.0' --single-branch --depth 1 https://github.com/git/git.git

cela semble être le moyen le plus rapide de vérifier le code d'un dépôt distant si l'on ne s'intéresse qu'au code le plus récent au lieu d'un dépôt complet. De cette façon, il ressemble à la commande "svn co".

vous pouvez utiliser git archive pour télécharger une bille tar pour une étiquette donnée ou pour l'identifier:

git archive --format=tar --remote=[hostname]:[path to repo] [tag name] > tagged_version.tar

Vous pouvez également exporter une archive zip d'une balise.

1. "151930920 de la Liste des" tags":

   git tag
   
   0.0.1
   0.1.0
   

2. exporter une étiquette:

   git archive -o /tmp/my-repo-0.1.0.zip --prefix=my-repo-0.1.0/ 0.1.0
   

3. Notes:

   • vous n'avez pas besoin de préciser le format. Il sera pris par le nom de fichier de sortie.
   • spécifier le préfixe fera l'exportation de votre code vers un répertoire (Si vous incluez une barre oblique).

utiliser le --single-branch switch (disponible à partir de la version 1.7.10) . La syntaxe est:

git clone -b <tag_name> --single-branch <repo_url> [<dest_dir>] 

par exemple:

git clone -b 'v1.9.5' --single-branch https://github.com/git/git.git git-1.9.5

l'avantage: Git recevra des objets et (besoin de) résoudre des deltas pour la branche/étiquette spécifiée seulement - tout en vérifiant la même quantité exacte de fichiers! Selon le dépôt source, cela vous permettra d'économiser beaucoup d'espace disque. (En Plus, ça va être beaucoup plus rapide.)

récupérez d'abord toutes les étiquettes de cette télécommande spécifique

git fetch <remote> 'refs/tags/*:refs/tags/*'

ou juste il suffit de taper

git fetch <remote>

puis vérifier les étiquettes disponibles

git tag -l

puis passer à cette étiquette spécifique en utilisant la commande ci-dessous

git checkout tags/<tag_name>

espérons que cela vous aidera!

j'ai vérifié la documentation git checkout , il a révélé une chose intéressante:

git checkout-b est le nom d'un commit où commencer la nouvelle branche; Par défaut à la tête

pour que nous puissions mentionner le nom de la balise (car la balise n'est rien d'autre qu'un nom de propagation) comme, disons:

> > git checkout - B 1.0.2_branch 1.0.2

plus tard, modifier certains fichiers

> > git push --tags

P. S: dans Git, vous ne pouvez pas mettre à jour une balise directement(puisque la balise est juste une étiquette à un commit), vous devez vérifier la même balise qu'une branche et ensuite vous y engager et ensuite créer une balise séparée.

si vos tags sont sortables en utilisant la commande linux sort , utilisez ceci:

git tag | sort -n | tail -1

par exemple. si git tag retourne:

v1.0.1
v1.0.2
v1.0.5
v1.0.4

git tag | sort -n | tail -1 sera de sortie:

v1.0.5

git tag | sort -n | tail -2 | head -1 sortira:

v1.0.4

(parce que vous avez demandé la deuxième étiquette la plus récente)

pour vérifier l'étiquette, d'abord cloner le repo, puis taper:

git checkout v1.0.4

..ou n'importe quelle étiquette dont tu as besoin.

git fetch <gitserver> <remotetag>:<localtag>

===================================

je viens de faire ça. D'abord, je me suis assuré de connaître l'orthographe du nom du tag.

git ls-remote --tags gitserver; : or origin, whatever your remote is called

cela m'a donné une liste d'étiquettes sur mon serveur git à choisir. L'affiche originale connaissait déjà le nom de son étiquette, donc cette étape n'est pas nécessaire pour tout le monde. La sortie ressemblait à cela, bien que la liste réelle était plus longue.

8acb6864d10caa9baf25cc1e4857371efb01f7cd    refs/tags/v5.2.2.2
f4ba9d79e3d760f1990c2117187b5010e92e1ea2    refs/tags/v5.2.3.1
8dd05466201b51fcaf4ca85897347d82fcb29518    refs/tags/Fix_109
9b5087090d9077c10ba22d99d5ce90d8a45c50a3    refs/tags/Fix_110

j'ai choisi l'étiquette que je voulais et les cheveux que et rien de plus, comme suit.

git fetch gitserver Fix_110

j'ai alors étiqueté ceci sur ma machine locale, donnant à mon étiquette le même nom.

git tag Fix_110 FETCH_HEAD

Je ne voulais pas cloner le dépôt à distance comme d'autres l'ont suggéré, car le projet sur lequel je travaille est vaste et je veux me développer dans un environnement propre. Je pense que c'est plus proche des questions originales "j'essaye de comprendre comment télécharger une étiquette particulière" que la solution ce qui suggère de cloner tout le dépôt. Je ne vois pas pourquoi quelqu'un devrait avoir une copie du code source Windows NT et Windows 8.1 s'il veut regarder le code source DOS 0.1 (par exemple).

Je ne voulais pas non plus utiliser la caisse comme d'autres l'ont suggéré. J'ai fait vérifier une branche et je ne voulais pas affecter ça. Mon intention était d'aller chercher le logiciel que je voulais pour que je puisse choisir quelque chose et ajouter cela à mon développement.

là est probablement un moyen de récupérer l'étiquette elle-même plutôt qu'une simple copie de la propagation qui a été marquée. J'ai eu de la balise extraites de m'engager. EDIT: Ah oui, j'ai trouvé cela maintenant.

git fetch gitserver Fix_110:Fix_110

où vous voyez le colon, qui est nom distant: nom local et ici ils sont les noms d'étiquette. Cela fonctionne sans déranger l'arbre de travail, etc. Il semble juste de copier des choses de la télécommande à la machine locale de sorte que vous avez votre propre copie.

git fetch gitserver --dry-run Fix_110:Fix_110

avec l'option -- dry-run ajoutée vous permettra de voir ce que ferait la commande, si vous voulez vérifier ce que vous voulez. Donc je suppose un simple

git fetch gitserver remotetag:localtag

est la vraie réponse.

=

Une note sur les balises ... Quand je commence quelque chose de nouveau, je marque habituellement le dépôt vide après git init, depuis

git rebase -i XXXXX 

nécessite un commit, et la question se pose: Cela inclut votre premier changement de logiciel?"Alors quand je commence à travailler je fais

git init
touch .gitignore
[then add it and commit it, and finally]
git tag EMPTY

c'est-à-dire créer un commit avant mon premier changement réel puis utiliser plus tard

git rebase -i EMPTY 

si je veux rebaser tout mon travail, y compris le premier changement .

travaillant à partir de la réponse de Peter Johnson, j'ai créé un joli petit pseudonyme pour moi-même:

alias gcolt="git checkout \`git tag | sort -V | tail -1\`"

alias 'git checkout latest tag'.

cela s'appuie sur la version GNU de sort, qui gère correctement des situations comme celle que lOranger a fait remarquer:

v1.0.1
...
v1.0.9
v1.0.10

si vous êtes sur mac, brew install coreutils et appelez gsort à la place.

, essayez:

git clone -b <name_of_the_tag> <repository_url> <destination>

vérification des étiquettes

si vous voulez voir les versions des fichiers pointés par une balise, vous pouvez faire un checkout git, bien que cela mette votre dépôt dans l'état "detached HEAD", qui a quelques effets secondaires néfastes:

$ git checkout 2.0.0
Note: checking out '2.0.0'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:

  git checkout -b <new-branch-name>

HEAD is now at 99ada87... Merge pull request #89 from schacon/appendix-final

$ git checkout 2.0-beta-0.1
Previous HEAD position was 99ada87... Merge pull request #89 from schacon/appendix-final
HEAD is now at df3f601... add atlas.json and cover image

dans l'état" detached HEAD", si vous faites des modifications et créez ensuite une commit, la balise restera la même, mais votre nouvelle commit n'appartiendra à aucune branche et sera inaccessible, sauf par le hash exact de commit. Ainsi, si vous avez besoin d'effectuer des modifications-par exemple, si vous corrigez un bug sur une version plus ancienne-vous voulez généralement créer une branche:

$ git checkout -b version2 v2.0.0
Switched to a new branch 'version2'

si vous faites ceci et faites un commit, votre branche version2 sera légèrement différente de votre v2.0.0 tag car il va aller de l'avant avec vos nouveaux changements, alors faites attention.

je le fais via L'API GitHub:

curl -H "Authorization: token %(access_token)s" -sL -o /tmp/repo.tar.gz "http://api.github.com/repos/%(organisation)s/%(repo)s/tarball/%(tag)s" ;\
tar xfz /tmp/repo.tar.gz -C /tmp/repo --strip-components=1 ; \

Clone avec option-b aide aussi: clone git https://git01.codeplex.com/aspnetwebstack.git - B v2.0

le post suivant utilise l'option ci-dessus pour télécharger asp.net mvc: http://vijayt.com/Post/Setting-up-aspnet-mvc-for-debugging-in-your-system