Vous avez juste besoin d'insérer une référence 'vide' au nom de la balise distante:
git Push Origin :tagname
Ou, de manière plus explicite, utilisez l'option --delete (ou -d si votre version de git est antérieure à 1.8.0):
git Push --delete Origin tagname
Notez que git a un espace de noms de balises et un espace de noms de branches, vous pouvez donc utiliser le même nom pour une branche et pour une balise. Si vous voulez vous assurer que vous ne pouvez pas supprimer accidentellement la branche au lieu de la balise, vous pouvez spécifier une référence complète qui ne supprimera jamais une branche:
git Push Origin :refs/tags/tagname
Si vous devez également supprimer la balise locale, utilisez:
git tag --delete tagname
Contexte
Pousser une branche, une balise ou une autre référence vers un référentiel distant implique de spécifier "quel référentiel, quelle source, quelle destination?"
git Push remote-repo source-ref:destination-ref
Un exemple concret dans lequel vous poussez votre branche principale vers la branche principale d’Origine est:
git Push Origin refs/heads/master:refs/heads/master
Ce qui, à cause des chemins par défaut, peut être réduit à:
git Push Origin master:master
Les balises fonctionnent de la même manière:
git Push Origin refs/tags/release-1.0:refs/tags/release-1.0
Ce qui peut aussi être réduit à:
git Push Origin release-1.0:release-1.0
En omettant la référence source (la partie située avant les deux points), vous ne poussez rien vers la destination, en supprimant la référence de l'extrémité distante.
Un moyen plus simple est
git Push --delete Origin YOUR_TAG_NAME
La syntaxe du côlon préfixant IMO est un peu étrange dans cette situation
Si vous avez une étiquette à distance v0.1.0 à supprimer et que votre télécommande est Origin, alors simplement:
git Push Origin :refs/tags/v0.1.0
Si vous devez également supprimer la balise localement:
git tag -d v0.1.0
Voir la réponse de Adam Franco == pour l'explication de la syntaxe inhabituelle de Git : pour la suppression.
Supprimez toutes les balises locales et obtenez la liste des balises distantes:
git tag -l | xargs git tag -d
git fetch
Supprimer toutes les balises distantes
git tag -l | xargs -n 1 git Push --delete Origin
Nettoyer les tags locaux
git tag -l | xargs git tag -d
Pour supprimer la balise du référentiel distant:
git Push --delete Origin TAGNAME
Vous pouvez également vouloir supprimer la balise localement:
git tag -d TAGNAME
Depuis votre terminal, procédez comme suit:
git fetch
git tags
git tag -d {tag-name}
git Push Origin :refs/tags/{tag-name}
Maintenant, allez sur Github.com et actualisez-les, ils disparaissent.
Notez simplement que si vous avez une branche distante nommée en tant que balise distante, ces commandes sont ambiguës:
git Push Origin :tagname
git Push --delete Origin tagname
Donc, vous devez utiliser cette commande pour supprimer la balise:
git Push Origin :refs/tags/<tag>
et celui-ci pour supprimer la branche:
git Push Origin :refs/heads/<branch>
Sinon, vous obtiendrez une erreur comme ceci:
error: dst refspec <tagname> matches more than one.
error: failed to Push some refs to '<repo>'
Supprimer la balise locale '12345'
git tag -d 12345
Supprimer la balise distante '12345' (par exemple; version GitHub aussi)
git Push Origin :refs/tags/12345
approche alternative
git Push --delete Origin tagName
git tag -d tagName
Méthode jusqu'à 100 fois plus rapide pour des milliers d'étiquettes distantes
Après avoir lu ces réponses tout en ayant besoin de supprimer plus de 11 000 balises, j’ai appris à utiliser ces méthodes ou xargs prend beaucoup trop de temps, à moins que vous ne disposiez de plusieurs heures.
En luttant, j'ai trouvé deux moyens beaucoup plus rapides . Pour les deux, commencez par git tag ou git ls-remote --tags pour créer la liste des balises que vous souhaitez supprimer de la télécommande. Dans les exemples ci-dessous, vous pouvez omettre ou remplacer sorting_proccessing_etc par tout type de greping, sorting, tailing ou heading ( Par exemple grep -P "my_regex" | sort | head -n -200 etc ):
Cette première méthode est de loin la plus rapide, peut-être 20 à 100 fois plus rapide que d'utiliser xargs, et fonctionne avec au moins plusieurs mille tags à la fois.
git Push Origin $(< git tag | sorting_processing_etc \
| sed -e 's/^/:/' | paste -sd " ") #note exclude "<" for zsh
Comment cela marche-t-il? La liste normale de balises séparées par des lignes est convertie en une seule ligne de balises séparées par des espaces, chacune précédée de : so. . .
tag1 becomes
tag2 ======> :tag1 :tag2 :tag3
tag3
Utiliser git Push avec cette balise de format ne pousse rien dans chaque référence distante et l’efface (le format normal pour pousser de cette façon est local_ref_path:remote_ref_path).
La deuxième méthode est séparée en réponse ailleurs sur cette même page
Après ces deux méthodes, vous voudrez probablement aussi supprimer vos balises locales. Ceci est beaucoup plus rapide, nous pouvons donc utiliser à nouveau xargs et git tag -d, ce qui est suffisant.
git tag | sorting_processing_etc | xargs -L 1 git tag -d
OU similaire à la suppression à distance:
git tag -d $(< git tag | sorting_processing_etc | paste -sd " ")
Si vous avez créé une balise appelée release01 dans un référentiel Git, vous devez la supprimer de votre référentiel en procédant comme suit:
git tag -d release01
git Push Origin :refs/tags/release01
Pour en supprimer un d'un référentiel Mercurial:
hg tag --remove featurefoo
Veuillez faire référence à https://confluence.atlassian.com/pages/viewpage.action?pageId=282175551
git tag -d your_tag_name
git Push Origin :refs/tags/your_tag_name
La première ligne supprime your_tag_name du référentiel local et la seconde le supprime du référentiel distant. Maintenant, votre_tag a été complètement supprimé, à la fois des dépôts locaux et distants, mais vous pouvez parfois avoir besoin de supprimer la balise supprimée rédigée manuellement par GitHub dans votre section de publication.
Les autres réponses indiquent comment procéder, mais vous devez garder à l'esprit les conséquences puisqu'il s'agit d'un référentiel distant.
La page de manuel git tag, dans la section On Retagging , explique bien comment informer courtoisement les autres utilisateurs du référentiel distant du changement. Ils donnent même un modèle d'annonce pratique pour communiquer aux autres utilisateurs comment obtenir vos modifications.
Si vous utilisez SourceTree - une excellente interface graphique Git -, vous pouvez facilement le faire sans la ligne de commande en procédant comme suit:
- Ouvrez votre référentiel dans SourceTree
- Sélectionnez et développez l'onglet "Tags" sur la gauche
- Faites un clic droit sur la balise que vous souhaitez supprimer
- Sélectionnez "Supprimer YOUR_TAG_NAME".
- Dans la fenêtre de vérification, sélectionnez "Supprimer la balise des télécommandes".
YOUR_TAG_NAME va maintenant être supprimé de votre référentiel local et de toutes les télécommandes - qu'il s'agisse de GitHub, de BitBucket ou de tout autre endroit que vous avez répertorié comme distant pour ce référentiel.
De même, si vous supprimez une balise localement mais pas sur les origines distantes et que vous souhaitez la supprimer partout, créez simplement une nouvelle balise portant le même nom et attachée au même commit que les origines. Ensuite, répétez les étapes ci-dessus pour supprimer partout.
Je souhaitais supprimer toutes les balises sauf celles correspondant à un motif afin de pouvoir supprimer toutes les balises de production sauf les derniers mois, voici ce que j'ai utilisé avec grand succès:
Supprimer toutes les balises distantes et exclure l'expression de la suppression
git tag -l | grep -P '^(?!Production-2017-0[89])' | xargs -n 1 git Push --delete Origin
Supprimer toutes les balises locales et exclure l'expression de la suppression
git tag -l | grep -P '^(?!Production-2017-0[89])' | xargs git tag -d
Comme @CubanX l'a suggéré, j'ai séparé cette réponse de mon original:
Voici une méthode qui est plusieurs fois plus rapide que xargs et qui peut évoluer beaucoup plus avec des modifications. Il utilise le API Github , un jeton d'accès personnel, et utilise l'utilitaire parallel .
git tag | sorting_processing_etc | parallel --jobs 2 curl -i -X DELETE \
https://api.github.com/repos/My_Account/my_repo/git/refs/tags/{} -H
\"authorization: token GIT_OAUTH_OR_PERSONAL_KEY_HERE\" \
-H \"cache-control: no-cache\"`
parallel possède de nombreux modes de fonctionnement, mais met généralement en parallèle toute commande que vous lui donnez, tout en vous permettant de définir des limites pour le nombre de processus. Vous pouvez modifier le paramètre --jobs 2 pour permettre un fonctionnement plus rapide, mais j’ai eu des problèmes avec le limites de débit de Github, qui sont actuellement à 5000/h, mais qui semble également avoir une limite non documentée à court terme. bien.
Après cela, vous voudrez probablement aussi supprimer vos balises locales. Ceci est beaucoup plus rapide, nous pouvons donc utiliser xargs et git tag -d, ce qui est suffisant.
git tag | sorting_processing_etc | xargs -L 1 git tag -d
On dirait que beaucoup de travail pour quelque chose que xargs fait déjà. En regardant en arrière à travers ce fil, je devine la lenteur avec xargs que vous avez expérimentée, c'est parce que la réponse originale utilisait xargs -n 1 alors que ce n'était pas vraiment nécessaire.
Cela équivaut à votre méthode un sauf que xargs traite automatiquement la longueur maximale de la ligne de commande:
git tag | sorting_processing_etc | xargs git Push --delete Origin
xargs peut également exécuter des processus en parallèle. Méthode 2 avec xargs:
git tag | sorting_processing_etc | xargs -P 5 -n 100 git Push --delete Origin
Ce qui précède utilise un maximum de 5 processus pour gérer un maximum de 100 arguments dans chaque processus. Vous pouvez expérimenter les arguments pour trouver ce qui convient le mieux à vos besoins.
Script simple pour supprimer une balise donnée des emplacements local et d’origine. Avec une vérification si l'étiquette existe vraiment.
if [ $(git tag -l "$1") ]; then
git tag --delete $1
git Push --delete Origin $1
echo done.
else
echo tag named "$1" was not found
fi
Comment utiliser:
- Créez un fichier script Shell (par exemple, git-tag-purge.sh) et collez le contenu.
- chmod votre fichier de script pour le rendre exécutable.
- Rendre le script disponible globalement
- cd à votre projet git
- Script d'appel (par exemple,
$> git-tag-purge.sh tag_name
)
Si vous utilisez PowerShell et que vous souhaitez en supprimer plusieurs:
# Local tags:
git tag -l | foreach { git tag -d $_ }
# Remote tags:
git tag -l | foreach { git Push --delete Origin $_ }
Bien sûr, vous pouvez aussi les filtrer avant de supprimer:
git tag -l | Where-Object { $_ -like "build-*" } | foreach { git tag -d $_ }
Si vous avez créé une balise commençant par le caractère #, par ex. #ST002, vous pourriez trouver que vous ne parvenez pas à supprimer en utilisant des modèles normaux. c'est à dire.
git tag -d #STOO2
Ne supprimera pas la balise, mais l'encapsulera dans un String Literal
git tag -d "#ST002" or git tag -d '#ST002'
Cela va le supprimer. En espérant que cela aidera quelqu'un qui a commis l'erreur d'utiliser # pour écrire les noms de balises.
Voici un test local pour le tester localement sans jouer avec une télécommande:
~/p $ mkdir gittest
~/p/git $ cd gittest/
~/p/gittest $ git init
Initialized empty Git repository in /Users/local_user/p/gittest/.git/
~/p/gittest $ touch testfile.txt
~/p/gittest $ git add testfile.txt
~/p/gittest $ git commit -m "initial commit"
[master (root-commit) 912ce0e] initial commit
1 file changed, 0 insertions(+), 0 deletions(-)
create mode 100644 testfile.txt
~/p/gittest $ git tag
~/p/gittest $ git tag -a testtag
~/p/gittest $ git tag
testtag
~/p/gittest $ git show-ref
912ce0e40635c90241fdab756dce7ea34938de57 refs/heads/master
b0a6c15cabb990e6d6c46f762891b63608d962f3 refs/tags/testtag
~/p/gittest $ cd ..
~/p $ mkdir gitbare
~/p $ cd gitbare
~/p/gitbare $ git init --bare
Initialized empty Git repository in /Users/local_user/p/gitbare/
~/p/gitbare $ cd ..
~/p $ cd gittest/
~/p/gittest $ git remote add Origin /Users/local_user/p/gitbare
~/p/gittest $ git Push -u Origin master
Counting objects: 3, done.
Writing objects: 100% (3/3), 215 bytes | 215.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To /Users/local_user/p/gitbare
* [new branch] master -> master
Branch 'master' set up to track remote branch 'master' from 'Origin'.
~/p/gittest $ git Push Origin testtag
Counting objects: 1, done.
Writing objects: 100% (1/1), 163 bytes | 163.00 KiB/s, done.
Total 1 (delta 0), reused 0 (delta 0)
To /Users/local_user/p/gitbare
* [new tag] testtag -> testtag
~/p/gittest $ git show-ref
912ce0e40635c90241fdab756dce7ea34938de57 refs/heads/master
912ce0e40635c90241fdab756dce7ea34938de57 refs/remotes/Origin/master
b0a6c15cabb990e6d6c46f762891b63608d962f3 refs/tags/testtag
~/p/gittest $ git Push -d Origin testtag
To /Users/local_user/p/gitbare
- [deleted] testtag
~/p/gittest git tag -d testtag
Deleted tag 'testtag' (was b0a6c15)
~/p/gittest $ git show-ref
912ce0e40635c90241fdab756dce7ea34938de57 refs/heads/master
912ce0e40635c90241fdab756dce7ea34938de57 refs/remotes/Origin/master
~/p/gittest
Bonjour, je voulais juste partager un alias que j'ai créé et qui fait la même chose:
Ajoutez ce qui suit à votre ~/.gitconfig
[alias]
delete-tag = "!f() { \
echo 'deleting tag' $1 'from remote/Origin ausing command: git Push --delete Origin tagName;'; \
git Push --delete Origin $1; \
echo 'deleting tag' $1 'from local using command: git tag -d tagName;'; \
git tag -d $1; \
}; f"
L'utilisation ressemble à:
-->git delete-tag v1.0-DeleteMe
deleting tag v1.0-DeleteMe from remote/Origin ausing command: git Push --delete Origin tagName;
To https://github.com/jsticha/pafs
- [deleted] v1.0-DeleteMe
deleting tag v1.0-DeleteMe from local using command: git tag -d tagName;
Deleted tag 'v1.0-DeleteMe' (was 300d3ef22)