¿Cómo puedo eliminar todas las twigs de Git que se han fusionado?

Tengo muchas twigs de Git. ¿Cómo elimino las sucursales que ya se han fusionado? ¿Hay alguna manera fácil de eliminarlos todos en lugar de eliminarlos uno por uno?

ACTUALIZAR:

Puede agregar otras twigs para excluir como maestro y desarrollador si su flujo de trabajo tiene esos como un posible antecesor. Por lo general, me ramifico de una label de "sprint-start" y master, dev y qa no son ancestros.

Para eliminar todas las sucursales locales que ya están fusionadas en la twig actualmente desprotegida:

 git branch --merged | egrep -v "(^\*|master|dev)" | xargs git branch -d 

Puedes ver que master y dev están excluidos en caso de que sean ancestros.


Puede eliminar una sucursal local fusionada con:

 git branch -d branchname 

Si no está combinado, use:

 git branch -D branchname 

Para eliminarlo del control remoto en las versiones anteriores de Git use:

 git push origin :branchname 

En versiones más recientes de uso de Git:

 git push --delete origin branchname 

Una vez que elimine la twig del control remoto, puede eliminar las twigs de seguimiento remoto con:

 git remote prune origin 

o podar twigs de seguimiento remoto individuales, como sugiere la otra respuesta, con:

 git branch -dr branchname 

Espero que esto ayude.

Para eliminar todas las twigs en el control remoto que ya están fusionadas:

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

En versiones más recientes de Git

 git branch -r --merged | grep -v master | sed 's/origin\///' | xargs -n 1 git push --delete origin 

Simplemente extendiendo la respuesta de Adam un poco:

Agregue esto a su configuration de Git ejecutando git config -e --global

 [alias] cleanup = "!git branch --merged | grep -v '\\*\\|master\\|develop' | xargs -n 1 git branch -d" 

Y luego puede eliminar todas las sucursales fusionadas locales realizando una simple git cleanup .

Esto también funciona para eliminar todas las twigs fusionadas, excepto el maestro.

 git branch --merged | grep -v '^* master$' | grep -v '^ master$' | xargs git branch -d 

Querrá excluir el master y develop twigs a partir de esos commands.

Local git clear:

 git branch --merged | grep -v '\*\|master\|develop' | xargs -n 1 git branch -d 

Remote git clear:

 git branch -r --merged | grep -v '\*\|master\|develop' | sed 's/origin\///' | xargs -n 1 git push --delete origin 

Sincronizar el logging local de sucursales remotas:

 git fetch -p 

Para aquellos de ustedes que están en Windows y prefieren los scripts de PowerShell, aquí hay uno que borra las twigs fusionadas locales:

 function Remove-MergedBranches { git branch --merged | ForEach-Object { $_.Trim() } | Where-Object {$_ -NotMatch "^\*"} | Where-Object {-not ( $_ -Like "*master" )} | ForEach-Object { git branch -d $_ } } 

Git Sweep hace un gran trabajo de esto.

Puede agregar el compromiso a la opción –merced. De esta forma, puede asegurarse de eliminar solo twigs fusionadas en, por ejemplo, el origen / maestro

El siguiente command eliminará las twigs fusionadas de su origen.

 git branch -r --merged origin/master | grep -v "^.*master" | sed s:origin/:: |xargs -n 1 git push origin --delete 

Puedes probar qué twigs se eliminarán reemplazando el origen de git push –delete con echo

 git branch -r --merged origin/master | grep -v "^.*master" | sed s:origin/:: |xargs -n 1 echo 

Utilizo el siguiente script de Ruby para eliminar mis twigs local y remota ya fusionadas. Si lo hago para un repository con múltiples controles remotos y solo deseo eliminar uno, simplemente agrego una statement de selección a la list de controles remotos para get solo los controles remotos que deseo.

 #!/usr/bin/env ruby current_branch = `git symbolic-ref --short HEAD`.chomp if current_branch != "master" if $?.exitstatus == 0 puts "WARNING: You are on branch #{current_branch}, NOT master." else puts "WARNING: You are not on a branch" end puts end puts "Fetching merged branches..." remote_branches= `git branch -r --merged`. split("\n"). map(&:strip). reject {|b| b =~ /\/(#{current_branch}|master)/} local_branches= `git branch --merged`. gsub(/^\* /, ''). split("\n"). map(&:strip). reject {|b| b =~ /(#{current_branch}|master)/} if remote_branches.empty? && local_branches.empty? puts "No existing branches have been merged into #{current_branch}." else puts "This will remove the following branches:" puts remote_branches.join("\n") puts local_branches.join("\n") puts "Proceed?" if gets =~ /^y/i remote_branches.each do |b| remote, branch = b.split(/\//) `git push #{remote} :#{branch}` end # Remove local branches `git branch -d #{local_branches.join(' ')}` else puts "No branches removed." end end 

Usando la versión 2.5.0 de Git:

 git branch -d `git branch --merged` 

La respuesta de kuboon olvidó borrar twigs que tienen la palabra maestra en el nombre de la twig. Lo siguiente mejora en su respuesta:

 git branch -r --merged | grep -v "origin/master$" | sed 's/\s*origin\///' | xargs -n 1 git push --delete origin 

Por supuesto, no elimina la twig "maestra" en sí 🙂

No hay ningún command en Git que haga esto por usted automáticamente. Pero puedes escribir un script que use los commands de Git para darte lo que necesitas. Esto podría hacerse de muchas maneras dependiendo de qué model de bifurcación esté utilizando.

Si necesita saber si una twig se ha fusionado en maestro, el siguiente command no producirá salida si myTopicBranch se ha fusionado (es decir, puede eliminarlo)

 $ git rev-list master | grep $(git rev-parse myTopicBranch) 

Podrías usar el command de twig de Git y analizar todas las twigs en Bash y hacer un ciclo para todas las twigs. En este ciclo, consulte con el command anterior si puede eliminar la twig o no.

git branch --merged | grep -Ev '^(. master|\*)' | xargs -n 1 git branch -d git branch --merged | grep -Ev '^(. master|\*)' | xargs -n 1 git branch -d eliminará todas las twigs locales, excepto la twig actual y / o master desprotegido.

Aquí hay un artículo útil para aquellos que buscan entender estos commands: Git Clean: Eliminar twigs ya fusionadas, por Steven Harman .

Cómo eliminar twigs fusionadas en la console de PowerShell

 git branch --merged | %{git branch -d $_.Trim()} 

Ver GitHub para Windows

Puede usar la herramienta git-del-br .

 git-del-br -a 

Puedes instalarlo a través de pip usando

 pip install git-del-br 

PD: soy el autor de la herramienta. Cualquier sugerencia / retroalimentación es bienvenida.

Versión alias de la respuesta actualizada de Adam :

 [alias] branch-cleanup = "!git branch --merged | egrep -v \"(^\\*|master|dev)\" | xargs git branch -d #" 

Además, consulte esta respuesta para get consejos útiles sobre el escape de alias complejos.

Pruebe el siguiente command:

git branch -d $(git branch --merged | grep -vw $(git rev-parse --abbrev-ref HEAD))

Al usar git rev-parse obtendrá el nombre de la sucursal actual para excluirlo. Si obtuvo el error, eso significa que no hay sucursales locales para eliminar.

Para hacer lo mismo con sucursales remotas (cambiar el origin con su nombre remoto), intente:

git push origin -vd $(git branch -r --merged | grep -vw $(git rev-parse --abbrev-ref HEAD) | cut -d/ -f2)

En caso de que tenga múltiples controles remotos, agregue el grep origin | antes de cut para filtrar solo el origin .

Si el command anterior falla, intente eliminar primero las twigs fusionadas de seguimiento remoto:

git branch -rd $(git branch -r --merged | grep -vw $(git rev-parse --abbrev-ref HEAD))

Luego, vuelve a git fetch el control remoto y usa el command anterior git push -vd nuevamente.

Si lo usa con frecuencia, considere agregar como alias en su file ~/.gitconfig .

En caso de que hayas eliminado algunas twigs por error, utiliza git reflog para encontrar las confirmaciones perdidas.

¡Sobre la base de algunas de estas respuestas hice mi propio guión de Bash para hacerlo también !

Utiliza la git branch --merged y git branch -d para eliminar las twigs que se han fusionado y le solicita cada una de las twigs antes de eliminarlas.

 merged_branches(){ local current_branch=$(git rev-parse --abbrev-ref HEAD) for branch in $(git branch --merged | cut -c3-) do echo "Branch $branch is already merged into $current_branch." echo "Would you like to delete it? [Y]es/[N]o " read REPLY if [[ $REPLY =~ ^[Yy] ]]; then git branch -d $branch fi done } 

Yo uso un esquema de nombres de esque git-flow, así que esto funciona de manera muy segura para mí:

 git branch --merged | grep -e "^\s\+\(fix\|feature\)/" | xargs git branch -d 

Básicamente busca commits fusionados que comienzan con fix/ string fix/ feature/ .

Si desea eliminar todas las sucursales locales que ya están fusionadas en la sucursal en la que se encuentra actualmente, entonces he creado un command seguro para hacerlo, en base a las respuestas anteriores:

 git branch --merged | grep -v \* | grep -v '^\s*master$' | xargs -t -n 1 git branch -d 

Este command no afectará a su twig actual o su twig principal. También le dirá lo que está haciendo antes de hacerlo, utilizando el indicador -t de xargs.

Escribe un script en el que Git verifique todas las twigs que se fusionaron para dominar.

A continuación, haga el git checkout master .

Finalmente, elimine las twigs fusionadas.

 for k in $(git branch -ra --merged | egrep -v "(^\*|master)"); do branchnew=$(echo $k | sed -e "s/origin\///" | sed -e "s/remotes\///") echo branch-name: $branchnew git checkout $branchnew done git checkout master for k in $(git branch -ra --merged | egrep -v "(^\*|master)"); do branchnew=$(echo $k | sed -e "s/origin\///" | sed -e "s/remotes\///") echo branch-name: $branchnew git push origin --delete $branchnew done 

Para evitar ejecutar accidentalmente el command desde cualquier otra twig que no sea maestra, uso el siguiente script bash. De lo contrario, ejecutando git branch --merged | grep -v "\*" | xargs -n 1 git branch -d git branch --merged | grep -v "\*" | xargs -n 1 git branch -d git branch --merged | grep -v "\*" | xargs -n 1 git branch -d de una twig que se ha fusionado de off master podría eliminar la twig principal.

 #!/bin/bash branch_name="$(git symbolic-ref HEAD 2>/dev/null)" || branch_name="(unnamed branch)" # detached HEAD branch_name=${branch_name##refs/heads/} if [[ $branch_name == 'master' ]]; then read -r -p "Are you sure? [y/N] " response if [[ $response =~ ^([yY][eE][sS]|[yY])$ ]]; then git branch --merged | grep -v "\*" | xargs -n 1 git branch -d fi else echo "Refusing to delete branches that are not merged into '$branch_name'. Checkout master first." fi 

Para borrar las twigs locales que se han fusionado con la twig maestra, estoy usando el siguiente alias ( git config -e --global ):

 cleanup = "!git branch --merged master | grep -v '^*\\|master' | xargs -n 1 git branch -D" 

Estoy usando git branch -D para evitar el error: The branch 'some-branch' is not fully merged. posts mientras mi pago actual es diferente de la twig principal.

Script de Python compatible con Windoze (porque git-sweep estranguló en el repository de Wesnoth):

 #!/usr/bin/env python # Remove merged git branches. Cross-platform way to execute: # # git branch --merged | grep -v master | xargs git branch -d # # Requires gitapi - https://bitbucket.org/haard/gitapi # License: Public Domain import gitapi repo = gitapi.Repo('.') output = repo.git_command('branch', '--merged').strip() for branch in output.split('\n'): branch = branch.strip() if branch.strip(' *') != 'master': print(repo.git_command('branch', '-d', branch).strip()) 

https://gist.github.com/techtonik/b3f0d4b9a56dbacb3afc

Si está utilizando un model de bifurcación como HubFlow o GitFlow, puede usar este command para eliminar las twigs de características fusionadas:

git branch --merged | grep feature.* | grep -v "\*" | xargs -n 1 git branch -d

Si desea eliminar las sucursales locales que se han fusionado y eliminar sus controles remotos, aquí está el delineador que prefiero:

 git branch --merged | xargs -I_br -- sh -c 'git branch -d _br; git push origin --delete _br' 
 for b in $(git branch -a | grep -v "\(master\|remotes\)"); do \ git branch -D $b; done && git fetch -p 

Digamos que tengo un control remoto llamado upstream y un origen (estilo GitHub, mi fork es origen, upstream es upstream).

No quiero eliminar NINGÚN maestro, HEAD ni nada desde el nivel superior. Tampoco quiero eliminar la twig de desarrollo, ya que es nuestra twig común de la que creamos RP.

Enumere todas las twigs remotas, filtradas por las que fueron fusionadas:

 git branch -r 

Elimine las líneas de esa list que contengan palabras que sé que están en nombres de sucursales que no quiero eliminar:

 sed '/develop\|master\|HEAD\|upstream/d' 

Elimine el nombre remoto del nombre de reference (origin / somebranch se convierte en alguna twig):

 sed 's/.*\///' 

Usa xargs para llamar a un solo liner:

 xargs git push --delete origin 

Píntalo todo, obtienes:

 git branch -r --merged | sed '/develop\|master\|HEAD\|upstream/d' | sed 's/.*\///' | xargs git push --delete origin 

Esto me dejará solo con algunas twigs en las que he trabajado, pero no me he fusionado. A continuación, puede eliminarlos uno por uno, ya que no debe haber demasiados.

Encuentra twigs que ya no quieres:

 git branch -ar 

Supongamos que encuentra branch1, branch2 y branch3 que desea eliminar:

 git push --delete origin branch1 branch2 branch3 

La contribución de My Bash script se basa libremente en la respuesta de mmrobin .

Se necesitan algunos parameters útiles para especificar inclusiones y exclusiones, o para examinar / eliminar solo las twigs locales o remotas en lugar de ambas.

 #!/bin/bash # exclude branches regex, configure as "(branch1|branch2|etc)$" excludes_default="(master|next|ag/doc-updates)$" excludes="__NOTHING__" includes= merged="--merged" local=1 remote=1 while [ $# -gt 0 ]; do case "$1" in -i) shift; includes="$includes $1" ;; -e) shift; excludes="$1" ;; --no-local) local=0 ;; --no-remote) remote=0 ;; --all) merged= ;; *) echo "Unknown argument $1"; exit 1 ;; esac shift # next option done if [ "$includes" == "" ]; then includes=".*" else includes="($(echo $includes | sed -e 's/ /|/g'))" fi current_branch=$(git branch --no-color 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/\1/') if [ "$current_branch" != "master" ]; then echo "WARNING: You are on branch $current_branch, NOT master." fi echo -e "Fetching branches...\n" git remote update --prune remote_branches=$(git branch -r $merged | grep -v "/$current_branch$" | grep -v -E "$excludes" | grep -v -E "$excludes_default" | grep -E "$includes") local_branches=$(git branch $merged | grep -v "$current_branch$" | grep -v -E "$excludes" | grep -v -E "$excludes_default" | grep -E "$includes") if [ -z "$remote_branches" ] && [ -z "$local_branches" ]; then echo "No existing branches have been merged into $current_branch." else echo "This will remove the following branches:" if [ "$remote" == 1 -a -n "$remote_branches" ]; then echo "$remote_branches" fi if [ "$local" == 1 -a -n "$local_branches" ]; then echo "$local_branches" fi read -p "Continue? (y/n): " -n 1 choice echo if [ "$choice" == "y" ] || [ "$choice" == "Y" ]; then if [ "$remote" == 1 ]; then remotes=$(git remote) # Remove remote branches for remote in $remotes do branches=$(echo "$remote_branches" | grep "$remote/" | sed "s/$remote\/\(.*\)/:\1 /g" | tr -d '\n') git push $remote $branches done fi if [ "$local" == 1 ]; then # Remove local branches locals=$(echo "$local_branches" | sed 's/origin\///g' | tr -d '\n') if [ -z "$locals" ]; then echo "No branches removed." else git branch -d $(echo "$locals" | tr -d '\n') fi fi fi fi 

Si está eliminando de su computadora local , esta es mi manera directa :

Simplemente vaya a: C:\Repo\your-project\.git\refs\heads

Cada twig es un file creado bajo esta carpeta, simplemente elimine los files que coinciden con los nombres de sus twigs.

Es difícil encontrar un método en Windows. Acabo de descubrirlo de esta manera, y me rescató en mi installation de Windows.