¿Se pueden eliminar varias ramas en un comando con Git?

Me gustaría limpiar mi repositorio local, que tiene un montón de ramas viejas: por ejemplo 3.2, 3.2.1, 3.2.2, etc.

Esperaba una forma astuta de eliminar muchos de ellos a la vez. Dado que en su mayoría siguen una convención de lanzamiento de puntos, pensé que tal vez había un atajo para decir:

git branch -D 3.2.*

y mata todas las ramas 3.2.x.

Intenté ese comando y, por supuesto, no funcionó.

No con esa sintaxis. Pero puedes hacerlo así:

git branch -D 3.2 3.2.1 3.2.2

Básicamente, git branch eliminará múltiples sucursales para usted con una sola invocación. Lamentablemente, no completa el nombre de sucursal. Aunque, en bash, puedes hacer:

git branch -D `git branch | grep -E '^3\.2\..*'`

Bueno, en el peor de los casos, podrías usar:

git branch | grep '3\.2' | xargs git branch -d

git branch  | cut -c3- | egrep "^3.2" | xargs git branch -D
  ^                ^                ^         ^ 
  |                |                |         |--- create arguments
  |                |                |              from standard input
  |                |                |
  |                |                |---your regexp 
  |                |
  |                |--- skip asterisk 
  |--- list all 
       local
       branches

EDITAR:

Una versión más segura (sugerida por Jakub Narębski y Jefromi), ya que la salida de git branch no está destinada a ser utilizada en scripts:

git for-each-ref --format="%(refname:short)" refs/heads/3.2\* | xargs git branch -D

... o sin xargs:

git branch -D `git for-each-ref --format="%(refname:short)" refs/heads/3.2\*`

Puede usar git branch --list para enumerar las ramas elegibles, y usar git branch -D / -d para eliminar las ramas elegibles.

Un ejemplo de línea:

git branch -d `git branch --list '3.2.*'`

Recientemente, estaba buscando la solución del mismo problema, finalmente encontré una respuesta y está funcionando muy bien:

1. Abra la terminal, o equivalente.
2. Escriba git branch | grep "patrón" para obtener una vista previa de las ramas que se eliminarán.
3. Escriba git branch | grep "patrón" | xargs git branch -D

Esta solución es increíble y si desea una explicación completa de cada comando y cómo está funcionando, se proporciona aquí .

Utilizar

git for-each-ref --format='%(refname:short)' 'refs/heads/3.2.*' |
   xargs git branch -D

Tal vez le resulte útil:

Si desea eliminar todas las ramas que no son, por ejemplo, 'master', 'foo' y 'bar'

git branch -D `git branch | grep -vE 'master|foo|bar'`

grep -v 'algo' es un emparejador con inversión.

Puse mis iniciales y un guión (at-) como los primeros tres caracteres del nombre de la rama por esta razón exacta:

git branch -D `git branch --list 'at-*'`

Si no está limitado a usar el símbolo del sistema git, siempre puede ejecutar git guiy usar el elemento de menú Rama-> Eliminar. Seleccione todas las ramas que desea eliminar y deje que se rasgue.

Solución Powershell:

Si está ejecutando Windows, puede usar PowerShell para eliminar varias ramas a la vez ...

git branch -D ((git branch | Select-String -Pattern '^\s*3\.2\..*') | foreach{$_.ToString().Trim()})
//this will remove all branches starting with 3.2.

git branch -D ((git branch | Select-String -Pattern 'feature-*') | foreach{$_.ToString().Trim()})
// this will delete all branches that contains the word "feature-" as a substring.

También puede ajustar cómo debería funcionar la coincidencia de patrones con el comando Seleccionar cadena de Powershell. Echa un vistazo a los documentos de PowerShell .

Mantener "desarrollar" y eliminar todos los demás en local

    git branch | grep -v "develop" | xargs git branch -D 

Hice una pequeña función que podría ser útil en función de la respuesta proporcionada por @gawi (arriba).

removeBranchesWithPrefix() {
  git for-each-ref --format="%(refname:short)" refs/heads/$1\* | xargs git branch -d
}

Agregue eso a su .bash_profiley reinicie su terminal. Luego puede llamar desde la línea de comandos de esta manera:

removeBranchesWithPrefix somePrefix

Nota

Actualmente lo tengo configurado para una eliminación suave, lo que significa que no eliminará las ramas a menos que ya se hayan fusionado. Si te gusta vivir en el borde, el cambio -dde -Dy va a eliminar todo con el prefijo sin tener en cuenta!

Si realmente necesita limpiar todas sus ramas, intente

git branch -d $(git branch)

Eliminará todas sus sucursales locales fusionadas, excepto la que está registrando actualmente.

Es una buena manera de limpiar tu local

Puede que le guste este pequeño elemento ... Extrae la lista y solicita la confirmación de cada elemento antes de eliminar finalmente todas las selecciones ...

git branch -d `git for-each-ref --format="%(refname:short)" refs/heads/\* | while read -r line; do read -p "remove branch: $line (y/N)?" answer </dev/tty; case "$answer" in y|Y) echo "$line";; esac; done`

Use -D para forzar eliminaciones (como de costumbre).

Para facilitar la lectura, aquí está esa línea dividida línea por línea ...

git branch -d `git for-each-ref --format="%(refname:short)" refs/heads/\* |
    while read -r line; do 
        read -p "remove branch: $line (y/N)?" answer </dev/tty;
        case "$answer" in y|Y) echo "$line";; 
        esac; 
    done`

aquí está el enfoque xargs ...

git for-each-ref --format="%(refname:short)" refs/heads/\* |
while read -r line; do 
    read -p "remove branch: $line (y/N)?" answer </dev/tty;
    case "$answer" in 
        y|Y) echo "$line";; 
    esac; 
done | xargs git branch -D

finalmente, me gusta tener esto en mi .bashrc

alias gitselect='git for-each-ref --format="%(refname:short)" refs/heads/\* | while read -r line; do read -p "select branch: $line (y/N)?" answer </dev/tty; case "$answer" in y|Y) echo "$line";; esac; done'

De esa manera solo puedo decir

gitSelect | xargs git branch -D.

Para las almas puras que usan PowerShell aquí, el pequeño script git branch -d $(git branch --list '3.2.*' | %{$_.Trim() })

funciona correctamente para mi:

git branch | xargs git branch -d

git branch | xargs git branch -D

eliminar todas las sucursales locales

Use el siguiente comando para eliminar todas las ramas (la rama desprotegida no se eliminará).

git branch | cut -d '*' -f 1 | tr -d " \t\r" | xargs git branch -d

Editar: estoy usando un Mac Os

Si estás en Windows, puedes usar PowerShell para hacer esto:

 git branch | grep 'feature/*' |% { git branch -D $_.trim() }

reemplace feature/*con cualquier patrón que desee.

Puedes usar este comando: git branch -D $(printf "%s\n" $(git branch) | grep '3.2')

Puede usar git guipara eliminar varias ramas a la vez. Desde Símbolo del sistema / Bash -> git gui-> Remoto -> Eliminar rama ... -> seleccione ramas remotas que desea eliminar -> Eliminar.

Hoy limpié un gran conjunto de sucursales locales / remotas obsoletas.

A continuación se muestra cómo lo hice:

1. enumere todos los nombres de las ramas en un archivo de texto:

git branch -a >> BranchNames.txt

2. agregue las ramas que quiero eliminar al comando "git branch -D -r":

git branch -D -r origin / dirA / branch01 origin / dirB / branch02 origin / dirC / branch03 (... agregue cualquier nombre de rama)

3. ejecutar el cmd

Y este funciona mucho más rápido y confiable que " git push origin --delete ".

Puede que esta no sea la forma más inteligente como se enumera en otras respuestas, pero esta es bastante sencilla y fácil de usar.

Si ha instalado Git GUI, que es un complemento predeterminado para Windows, entonces es el más simple. Puede usar ctrl para elegir varias ramas y eliminarlas con un solo clic.

Si está utilizando Fish Shell, puede aprovechar las stringfunciones :

git branch -d (git branch -l "<your pattern>" | string trim)

Esto no es muy diferente de las opciones de Powershell en algunas de las otras respuestas.

Si tuviera que eliminar todas las ramas en un archivo de texto (sucursales a del.txt) (una rama por línea), podría hacer esto para eliminar todas las ramas del control remoto (origen): xargs -a branches-to-del.txt git push --delete origin

Para eliminar varias ramas en función de un patrón especificado, haga lo siguiente:

Abra el terminal o equivalente y escriba los siguientes comandos:

git branch | grep "<pattern>" (preview of the branches based on pattern)

git branch | grep "<pattern>" | xargs git branch -D (replace the <pattern> with a regular expression to match your branch names)

Elimine todas las ramas 3.2.x, debe escribir

git branch | grep "3.2" | xargs git branch -D

¡Eso es todo!

tú eres bueno para irte.

Como en Git, todas las ramas no son nada por referencias al repositorio de git, ¿por qué no eliminas las ramas que van .git/refy luego, si queda algo fuera que no sea interesante en el repositorio, automáticamente se recolectará basura para que no lo hagas? Necesito molestar.

git branch -D <branchName>

Puede eliminar todas las ramas eliminando todas las referencias innecesarias:

rm .git/refs/heads/3.2.*