Supprimer plusieurs branches distantes dans git

J'ai un membre de l'équipe qui a par inadvertance transféré plus de 150 de ses succursales locales à notre repo central. Heureusement, ils ont tous le même préfixe. En utilisant ce préfixe, y a-t-il une commande git ou un petit script shell sympa que je peux utiliser qui supprimera tout cela à la fois?

Utilisez la commande suivante pour supprimer toutes les branches avec le PREFIXpréfixe sur le serveur distant.

git branch -r | awk -F/ '/\/PREFIX/{print $2}' | xargs -I {} git push origin :{}

Vous voudrez peut-être effectuer d'abord une analyse à sec pour voir si ce sont les branches que vous souhaitez supprimer:

git branch -r | awk -F/ '/\/PREFIX/{print $2}'

Si vous aimez une approche plus simple, supprimez par exemple 3 ou 4 branches:

git push origin --delete <branch1> <branch2> <branch3>

Important: fonctionne uniquement sur Git v1.7.0 et supérieur.

Merci à Neevek pour une solution géniale et élégante!

Mais j'ai quelques problèmes avec les barres obliques dans les noms de branche (j'utilise Git Flow), à cause du awkséparateur de champ /( -Foption)

Ma solution est donc basée sur celle de Neevek , mais analyse correctement les noms de branche avec /. Dans ce cas, je suppose que votre télécommande a appelé origin. Commande de suppression des branches distantes dont les noms commencent par PATTERN:

git branch -r | awk -Forigin/ '/\/PATTERN/ {print $2}' | xargs -I {} git push origin :{}

Et n'oubliez pas de vérifier ce que vous allez supprimer:

git branch -r | awk -Forigin/ '/\/PATTERN/ {print $2}'

CONSEIL UTILE: Si vos noms de branche (sans origin/préfixe) sont stockés dans un fichier texte (un nom de branche par ligne), lancez simplement:

cat your_file.txt | xargs -I {} git push origin :{}

Cela peut être une réponse en double mais ci-dessous testé et a parfaitement fonctionné pour moi.

1. Supprimer la branche locale de force

git branch -D nom-de-branche

2. Supprimer la branche distante

git push origin --delete nom-branche

3. Supprimer plus d'une succursale locale

git branch -D nom-branche1 nom-branche2

4. Supprimer plus d'une branche distante

git push origin --delete nom-branche1 nom-branche2

5. Supprimer la branche locale avec le préfixe. Par exemple, fonctionnalité / *

git branch -D $ (git branch --list 'fonctionnalité / *')

git branch -D backticks $ (git branch - list 'feature / *' backticks )

6. Répertoriez la branche distante avec le préfixe.

git branche -r | grep -Eo 'fonction /.*'

7. Supprimer la branche distante avec le préfixe

git branche -r | grep -Eo 'fonction /.*' | xargs -I {} origine git push: {}

La même chose avec grep: git branch -r | grep -Eo 'PREFIX/.*' | xargs -i git push origin :{}.

branch -rspectacles origin/prefix/branchname. Il faudra donc prefix/branchname.

La solution de Neevek est élégante, mais elle peut être meilleure: la solution proposée appelle «git push» une fois par branche, ce qui signifie un aller-retour réseau supplémentaire par branche à supprimer. Puisque vous utilisez de toute façon awk, pourquoi ne pas l'utiliser pour préfixer le ':' et ensuite xargs peut appeler 'git push' exactement une fois et supprimer toutes les branches à la fois:

Exécuter à sec pour lister les branches qui seraient supprimées:

git branch -r | awk -F/ '/\/PREFIX/{print ":" $2}'

Solution finale pour réellement pousser les suppressions:

git branch -r | awk -F/ '/\/PREFIX/{print ":" $2}' | xargs git push origin

ressource https://coderwall.com/p/eis0ba

    1 - List all your remote branches:

    $ git branch -r

    2 - Filter the branches by some regular expression. In this case I'm interested in deleting any branch with the 'feature-' prefix:

    $ git branch -r | awk -F/ '/\/feature-/{print $2}'
    3 - Pipe the last command to git push to delete them:
    # **Edit** - Removed extra colon, which is not needed
    $ git branch -r | awk -F/ '/\/feature-/{print $2}' | xargs -I {} git push origin {}
    4 - Grab a beer.

    5 - Remove any local reference to those branches:

    $ git remote prune origin

Grâce à Steve et Neevek, j'ai trouvé une solution qui fonctionnait plutôt bien pour moi et qui valait la peine d'être partagée:

La solution de Steve a fonctionné pour moi avec un ajustement mineur. Mes télécommandes ont été nommées origin/feature/some-feature-namealors j'ai coupé votre awk:

git branch -r | awk -Forigin/ '/\/feature/ {print $2 $3}' | xargs -I {} git push origin :{}

Il fait maintenant un joli petit flux de suppression:

To github.com:project/project-name.git
- [deleted]         feature/search-min-chars
To github.com:project/project-name.git
- [deleted]         feature/search-placeholder
To github.com:project/project-name.git
- [deleted]         feature/server-error-message
To github.com:project/project-name.git
- [deleted]         feature/six-point-asterisk

Je me demandais si quelqu'un avait des idées pour une solution plus élégante, cependant, qui pourrait produire quelque chose comme ceci (mon script CLI est assez pauvre, donc il me faudrait un certain temps pour comprendre cela):

git push origin :feature/search-min-chars :feature/search-placeholder :feature/server-error-message :feature/six-point-asterisk

Cela entraînerait une belle sortie unique avec une requête réseau:

To github.com:project/project-name.git
- [deleted]         feature/search-min-chars
- [deleted]         feature/search-placeholder
- [deleted]         feature/server-error-message
- [deleted]         feature/six-point-asterisk

Merci à Neevek. Cela a bien fonctionné après l'avoir reconfiguré pour mon objectif:

git branch -r | awk -Forigin/ '/\/PATTERN/ {print $2 "/" $3}' | xargs -I {} git push origin :{}

J'avais également besoin de prendre en compte la structure des dossiers. Mes branches de fonctionnalités sont dans une structure de dossiers comme origin / feature / PREFIX-FEATURENUMBER. J'ai donc dû créer mon modèle à partir de $ 2 = dossier + $ 3 = branchname.

Tout le monde utilise awk, je ne sais pas pourquoi. J'ai l'impression que c'est plus complexe. Voici ce que j'utilise pour supprimer toutes les branches distantes de ma forktélécommande:

$ git branch -r --list 'fork/*' | sed 's/fork\///' | xargs git push --delete fork

Lancez un grepentre le xargset sedsi vous avez besoin de filtrer la liste vers un sous-ensemble de branches distantes uniquement.

Je me rends compte que c'est pour la commande git, mais si vous cherchez une solution alternative pour faire le même ou le même résultat:

Vous pouvez le faire à partir d'ici (Git Remove Remote Branches):

Sélectionnez ensuite les branches souhaitées:

Assurez-vous que vous disposez des autorisations nécessaires pour supprimer les branches distantes.

Github a également une belle interface utilisateur et un mécanisme pour supprimer rapidement les branches, c'est si vous préférez utiliser une interface utilisateur

J'ai essayé de supprimer toutes les branches distantes d'origine / release / r1-1 *, donc la ligne de commande suivante fonctionnait bien.

git branch -r | awk -Forigin/ '/\/*r1-1/ {print $2}' |  xargs -I {} git push origin :{}

Je n'ai pas pu utiliser awk car nous utilisons une structure slash pour le nom de nos branches.

git branch -r | grep "origin/users/YOURNAME" | sed -r 's/^.{9}//'| xargs -i  sh -c 'git push origin --delete {}'

Cela récupère toutes les branches distantes, n'obtient que celle pour un seul utilisateur, distante la chaîne "origin /" et exécute une suppression sur chacune d'elles.

Course à sec:

git branch -r --list 'origin/your-branch-name/*' | sed "s/origin\///" | xargs -I {} echo {}

Supprimer les branches distantes:

git branch -r --list 'origin/your-branch-name/*' | sed "s/origin\///" | xargs -I {} git push origin --delete {}

Supprimer uniquement les branches distantes entièrement fusionnées:

git branch -r --merged --list 'origin/your-branch-name/*' | sed "s/origin\///" | xargs -I {} git push origin --delete {}

Explication:

sed "s/origin\///"supprimera origin/du nom de la branche. Sans enlever ça, j'ai:remote ref does not exist

Les réponses précédentes m'ont aidé à supprimer toutes les branches de version de 2018. J'ai exécuté cela sur mon invite de commande Windows 10. J'ai installé clink , donc les commandes de type Linux fonctionnent pour moi.

Exécution à sec:

git branch -a | grep -o "release-.*2018" | xargs -I {} echo {}

Si la marche à sec montre des branches qui ne sont pas à distance / d'origine. Exécutez ci-dessous la commande git prune pour corriger et vérifier à nouveau.

git remote prune origin

Supprimez une fois que vous êtes satisfait du résultat ci-dessus:

git branch -a | grep -o "release-.*2018" | xargs -I {} git push origin --delete {}

Si vous voyez: error: unable to delete 'release-...2018': remote ref does not exist. Exécutez ensuite la commande d'élagage précédente et réessayez.

Attention: cela supprimera toutes les branches distantes. Utiliser avec précaution.

Je pense que ma façon de supprimer les branches distantes est la meilleure.

git branch -r | grep -v master | sed 's/origin\//:/'| xargs git push

Attention: cela supprimera toutes les branches distantes. Utiliser avec précaution.