¿Cómo elimino una sucursal de Git de forma local y remota?

La respuesta de Matthew es excelente para eliminar remoto ramas y también aprecio la explicación, pero para hacer una distinción simple entre los dos comandos:

Para eliminar unrama localde su máquina:

git branch -d {the_local_branch} (use -D en lugar de forzar la eliminación de la rama sin verificar el estado fusionado)

Para eliminar unrama remotadel servidor:

git Push Origin --delete {the_remote_branch}

Referencia: https://makandracards.com/makandra/621-git-delete-a-branch-local-or-remote

Las respuestas cortas

Si desea explicaciones más detalladas de los siguientes comandos, consulte las respuestas largas en la siguiente sección.

Eliminar una rama remota:

git Push Origin --delete <branch>  # Git version 1.7.0 or newer
git Push Origin :<branch>          # Git versions older than 1.7.0

Eliminar una sucursal local:

git branch --delete <branch>
git branch -d <branch> # Shorter version
git branch -D <branch> # Force delete un-merged branches

Eliminar una rama local de seguimiento remoto:

git branch --delete --remotes <remote>/<branch>
git branch -dr <remote>/<branch> # Shorter

git fetch <remote> --Prune # Delete multiple obsolete tracking branches
git fetch <remote> -p      # Shorter

La Respuesta Larga: hay 3 ramas diferentes para eliminar!

Cuando se trata de eliminar sucursales de forma local y remota, tenga en cuenta que hay 3 ramas diferentes involucradas :

1. La sucursal local X.
2. La rama de origen remota X.
3. La rama local de seguimiento remoto Origin/X que rastrea la rama remota X.

El cartel original utilizado.

git branch -rd Origin/bugfix

que solo eliminó su rama de seguimiento remoto local Origin/bugfix, y no la rama remota real bugfix en Origin.

Para eliminar esa rama remota real , necesita

git Push Origin --delete bugfix

Detalles adicionales

Las siguientes secciones describen los detalles adicionales que se deben tener en cuenta al eliminar sus sucursales remotas y de seguimiento remoto.

Al pulsar para eliminar las ramas remotas también se eliminan las ramas de seguimiento remoto

Tenga en cuenta que eliminar la rama remota X de la línea de comando con git Push también eliminará la rama local de seguimiento remoto Origin/X, por lo que no es necesario Podar la rama obsoleta de seguimiento remoto con git fetch --Prune o git fetch -p, sin embargo No te dolería si lo hicieras de todos modos.

Puede verificar que la rama de seguimiento remoto Origin/X también se eliminó ejecutando lo siguiente:

# View just remote-tracking branches
git branch --remotes
git branch -r

# View both strictly local as well as remote-tracking branches
git branch --all
git branch -a

Poda la rama local obsoleta de seguimiento remoto Origen/X

Si no eliminó su rama remota X de la línea de comando (como arriba), entonces su repositorio local todavía contendrá (una rama ya obsoleta) de seguimiento remoto Origin/X. Esto puede suceder si elimina una sucursal remota directamente a través de la interfaz web de GitHub, por ejemplo.

Una forma típica de eliminar estas ramas de seguimiento remoto obsoletas (desde Git versión 1.6.6) es simplemente ejecutar git fetch con --Prune o más corto -p. Tenga en cuenta que esto elimina todas las ramas de seguimiento remoto locales obsoletas para cualquier rama remota que ya no existe en el remoto :

git fetch Origin --Prune
git fetch Origin -p # Shorter

Aquí está la cita relevante de las notas de publicación 1.6.6 (énfasis mío):

"git fetch" aprendió --all y --multipleoptions, para ejecutar fetch desde muchos repositorios, y la opción--Prune para eliminar las ramas de seguimiento remoto que quedaron obsoletas. Esto hace que "git remote update" y "git remote Prune" sean menos necesarios (sin embargo, no hay un plan para eliminar la "actualización remota" ni "Prune remoto").

Alternativa a la poda automática anterior para las ramas de seguimiento remoto obsoletas

Alternativamente, en lugar de podar sus sucursales obsoletas de seguimiento remoto a través de git fetch -p, puede evitar realizar la operación adicional de la red simplemente eliminando manualmente las sucursales con las marcas --remote o -r:

git branch --delete --remotes Origin/X
git branch -dr Origin/X # Shorter

Ver también

• git-branch (1) Manual Page .
• git-fetch (1) Página de manual .
• Pro Git § 3.5 Git Branching - Ramas remotas .

Pasos para eliminar una rama:

Para borrar la rama remota:

git Push Origin --delete <your_branch> 

Para eliminar la rama local , tiene tres maneras :

1: git branch -D <branch_name> 

2: git branch --delete --force <branch_name>  //same as -D

3: git branch --delete  <branch_name>         //error on unmerge

Explica: OK, ¡solo explica lo que está pasando aquí!

Simplemente haga git Push Origin --delete a elimine su rama remota SOLAMENTE , agregue el nombre de la rama al final y esto se eliminará y Empújelo a control remoto al mismo tiempo ...

Además, git branch -D, que simplemente elimina la rama localSOLO! ...

-D significa --delete --force que eliminará la rama aunque no esté fusionada (forzar la eliminación), pero también puede usar -d que significa --delete que arroja un error respectivo del estado de combinación de la rama ...

También creo la imagen de abajo para mostrar los pasos:

También puede usar lo siguiente para eliminar la rama remota

git Push --delete Origin serverfix

Lo que hace lo mismo que

git Push Origin :serverfix

pero puede ser más fácil de recordar.

Si desea eliminar una rama, primero realice el proceso de pago en la rama que no sea la rama que desea eliminar.

git checkout other_than_branch_to_be_deleted

Eliminando la sucursal local:

git branch -D branch_to_be_deleted

Eliminando la rama remota:

git Push Origin --delete branch_to_be_deleted

Consejo: cuando borres ramas usando

git branch -d <branchname> # deletes local branch

o

git Push Origin :<branchname> # deletes remote branch

solo se eliminan las referencias. A pesar de que la rama se elimina realmente en el control remoto, las referencias a ella aún existen en los repositorios locales de los miembros de su equipo. Esto significa que para otros miembros del equipo, las ramas eliminadas aún están visibles cuando hacen un git branch -a.

Para resolver esto, los miembros de su equipo pueden podar las ramas eliminadas con

git remote Prune <repository>

Esto suele ser git remote Prune Origin.

git branch -D <name-of-branch>
git branch -D -r Origin/<name-of-branch>
git Push Origin :<name-of-branch>

Esto es simple: simplemente ejecute el siguiente comando:

Para eliminar una sucursal de Git local y remotamente, primero elimine la sucursal local usando el comando:

git branch -d example

(aquí example es el nombre de la rama)

Y después de eso elimine la rama remota usando el comando:

git Push Origin :example

Otro enfoque es:

git Push --Prune Origin

ADVERTENCIA: Esto eliminará todas las ramas remotas que no existen localmente. O más exhaustivamente,

git Push --mirror

efectivamente hará que el repositorio remoto se vea como la copia local del repositorio (los jefes locales, los controles remotos y las etiquetas se reflejan en el control remoto).

Uso lo siguiente en mi Bash settings:

alias git-shoot="git Push Origin --delete"

Entonces puedes llamar:

git-shoot branchname

Desde enero de 2013, GitHub incluyó una Delete branch botón al lado de cada rama en su página de "Ramas".

Publicación de blog relevante: Crear y eliminar ramas

Si desea completar estos dos pasos con un solo comando, puede crear un alias para ello agregando lo siguiente a su ~/.gitconfig:

[alias]
    rmbranch = "!f(){ git branch -d ${1} && git Push Origin --delete ${1}; };f"

Alternativamente, puede agregar esto a su configuración global desde la línea de comando usando

git config --global alias.rmbranch \
'!f(){ git branch -d ${1} && git Push Origin --delete ${1}; };f'

NOTE: Si usa -d (d minúscula), la rama solo se eliminará si se ha fusionado. Para forzar que la eliminación se realice, deberá utilizar -D (D mayúscula).

Eliminar localmente:

Para eliminar una rama local, puede utilizar:

git branch -d <branch_name> 

Para eliminar una rama por la fuerza, use -D en lugar de -d.

git branch -D <branch_name>

Eliminar de forma remota:

Hay dos opciones:

git Push Origin :branchname  

git Push Origin --delete branchname 

Le sugiero que utilice la segunda forma, ya que es más intuitivo.

Para eliminar su sucursal localmente y remotamente

• Salida a la rama maestra - git checkout master

• Elimina tu rama remota - git Push Origin --delete <branch-name>

• Elimina tu sucursal local - git branch --delete <branch-name>

También puedes hacer esto usando git remote Prune Origin

$ git remote Prune Origin
Pruning Origin
URL: [email protected]/yourrepo.git
 * [pruned] Origin/some-branchs

Se poda y elimina las ramas de seguimiento remoto de un listado de git branch -r.

Además de las otras respuestas, a menudo uso la herramienta git_remote_branch . Es una instalación adicional, pero le brinda una forma conveniente de interactuar con sucursales remotas. En este caso, para eliminar:

grb delete branch

Encuentro que también uso los comandos publish y track con bastante frecuencia

Un forro command delete tanto local como remoto :

D=branch-name; git branch -D $D; git Push Origin :$D

o agregue el alias a continuación a su ~/.gitconfig ; uso: git kill branch-name

[alias]
    kill = "!f(){ git branch -D \"$1\";  git Push Origin --delete \"$1\"; };f"

Eliminar Sucursales

Asumamos que nuestro trabajo en la rama "formulario de contacto" está terminado y ya lo hemos integrado en "maestro". Como ya no lo necesitamos, podemos eliminarlo (localmente):

$ git branch -d contact-form

Y para borrar la rama remota:

git Push Origin --delete contact-form

Eliminar rama remota

git Push Origin :<branchname>

Eliminar rama local

git branch -D <branchname>

Eliminar los pasos de la rama local:

1. salida a otra sucursal
2. eliminar rama local

Simplemente diga:

git branch -d <branch-name>
git Push Origin :<branch-name>

Ahora puedes hacerlo con la aplicación GitHub Desktop .

Después de lanzar la aplicación

1. Haga clic en el proyecto que contiene la rama.
2. Cambie a la rama que desea eliminar  
3. En el menú "Rama", selecciona "Anular publicación ..." para que la rama se elimine de los servidores de GitHub.  
4. En el menú "Sucursal", selecciona "Eliminar" nombre_social "... 'para eliminar la sucursal de tu máquina local (también conocida como la máquina en la que estás trabajando actualmente)  

git Push Origin --delete <branch Name>

es más fácil de recordar que

git Push Origin :branchName

Para eliminar localmente - (Normal),

git branch -d my_branch

Si su sucursal está en proceso de cambio de base/fusión y eso no se hizo correctamente significa que recibirá un Rebase/Merge in progress de error, por lo que, en ese caso, no podrá eliminar su sucursal.

Entonces, ya sea su necesidad de resolver rebasar/fusionar, de lo contrario puede forzar la eliminación usando,

git branch -D my_branch

Para borrar en Remoto:

git Push --delete Origin my_branch

puede hacer lo mismo usando,

git Push Origin :my_branch   # easy to remember both will do the same.

Representación gráfica,

Esto no funcionará si tiene una etiqueta con el mismo nombre que la rama en el control remoto:

$ git Push Origin :branch-or-tag-name
error: dst refspec branch-or-tag-name matches more than one.
error: failed to Push some refs to '[email protected]:SomeName/some-repo.git'

En ese caso, debe especificar que desea eliminar la rama, no la etiqueta:

git Push Origin :refs/heads/branch-or-tag-name

Del mismo modo, para eliminar la etiqueta en lugar de la rama que utilizarías:

git Push Origin :refs/tags/branch-or-tag-name

Muchas de las otras respuestas conducirán a errores/advertencias. Este enfoque es relativamente infalible, aunque es posible que aún necesite git branch -D branch_to_delete si no está completamente fusionado en some_other_branch, por ejemplo.

git checkout some_other_branch
git Push Origin :branch_to_delete
git branch -d branch_to_delete

No se necesita la poda remota si eliminó la rama remota. Solo se utiliza para obtener los controles remotos más actualizados disponibles en un repositorio que está rastreando. He observado que git fetch agregará controles remotos, no los eliminará. Aquí hay un ejemplo de cuándo git remote Prune Origin realmente hará algo:

El usuario A realiza los pasos anteriores. El usuario B ejecutaría los siguientes comandos para ver las sucursales remotas más actualizadas

git fetch
git remote Prune Origin
git branch -r

Me cansé de buscar en Google para esta respuesta, así que adopté un enfoque similar para la respuesta que publicó crizCraig antes.

Agregué lo siguiente a mi perfil de Bash:

function gitdelete(){
    git Push Origin --delete $1
    git branch -D $1
}

Luego, cada vez que termino con una rama (fusionada en master, por ejemplo) ejecuto lo siguiente en mi terminal:

gitdelete my-branch-name

... que luego elimina my-branch-name de Origin así como a nivel local.

Antes de ejecutar

git branch --delete <branch>

asegúrese de determinar primero cuál es el nombre EXACTO de la rama remota ejecutando:

git ls-remote

Esto le dirá qué debe introducir EXACTAMENTE para el valor de <branch>. (branch es sensible a mayúsculas!)

git Push Origin :bugfix  # Deletes remote branch
git branch -d bugfix     # Must delete local branch manually

Si está seguro de que desea eliminarlo, ejecute

git branch -D bugfix

Ahora, para limpiar las ramas remotas eliminadas, ejecute

git remote Prune Origin

Mashup de todas las otras respuestas. Requiere Ruby 1.9.3+, probado solo en OS X.

Llame a este archivo git-remove, conviértalo en ejecutable y póngalo en su ruta. Luego use, por ejemplo, git remove temp.

#!/usr/bin/env Ruby
require 'io/console'

if __FILE__ == $0
      branch_name = ARGV[0] if (ARGV[0])
      print "Press Y to force delete local and remote branch #{branch_name}..."
    response = STDIN.getch
    if ['Y', 'y', 'yes'].include?(response)
      puts "\nContinuing."
      `git branch -D #{branch_name}`
      `git branch -D -r Origin/#{branch_name}`
      `git Push Origin --delete #{branch_name}` 
    else
      puts "\nQuitting."
    end
end

Agregué los siguientes alias a mi archivo .gitconfig. Esto me permite eliminar sucursales con o sin especificar el nombre de la rama. El nombre de la rama se establece de manera predeterminada en la rama actual si no se pasa ningún argumento.

[alias]
    branch-name = rev-parse --abbrev-ref HEAD     

    rm-remote-branch = !"f() { branch=${1-$(git branch-name)}; git Push Origin :$branch; }; f"
    rm-local-branch = !"f() { branch=${1-$(git branch-name)}; git checkout master; git branch -d $branch; }; f"
    rm-branch-fully = !"f() { branch=${1-$(git branch-name)}; git rm-local-branch $branch; git rm-remote-branch $branch; }; f"

Una opción alternativa a la línea de comando para eliminar sucursales remotas es la página de sucursales de GitHub.

Vea por ejemplo: https://github.com/angular/angular.js/branches

Se encuentra en la página Code -> Branches de un repositorio de GitHub.

Generalmente prefiero la línea de comandos, pero esta la página de GitHub muestra mucha más información sobre las sucursales, como última fecha actualizada y usuario, y número de confirmaciones adelante y atrás. Es útil cuando se trata de un gran número de sucursales.

También tuve problemas similares, y esto parece funcionar: Esto elimina la sucursal local. git branch -d the_local_branch

Esto elimina la rama remota git Push Origin :the_remote_branch

Fuente: Makandra Cards

Hay una buena respuesta, pero, en caso de que tenga un montón de sucursales, eliminarlas una por una de forma local y remota, sería una tarea tediosa. Puede utilizar este script para automatizar estas tareas.

branch_not_delete=( "master" "develop" "our-branch-1" "our-branch-2")


for branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master`; do

    # delete prefix remotes/Origin/ from branch name
    branch_name="$(awk '{gsub("remotes/Origin/", "");print}' <<< $branch)"

    if ! [[ " ${branch_not_delete[*]} " == *" $branch_name "* ]]; then
        # delete branch remotly and locally
        git Push Origin :$branch_name
    fi
done 

• Listar las ramas que no quieres borrar
• Iterar sobre la rama de los controles remotos y si no están en nuestra "lista de conservación", eliminamos.

Fuente: remove-git-branches-at-once

Usando GitBash puedes ejecutar lo siguiente:

git branch --delete <branch>

OR

Desde la aplicación de escritorio de GitHub, cuando tiene la rama desprotegida, puede eliminar Local branch a través de la tira de menú Branch:

Si NO ESTÁ usando la aplicación de escritorio GitHub, y está usando un IDE como Visual Studio para su control de fuente local, todo lo que tiene que hacer es un par de pasos rápidos:

1. Echa un vistazo a una rama que no sea la que deseas eliminar.
2. Haga clic derecho en la rama que desea eliminar.
3. Seleccione la opción Eliminar en el menú contextual.

Luego, una vez que haya iniciado sesión en su cuenta de GitHub en línea, vaya al repositorio y haga clic en la pestañaTodas las ramas. Desde allí, simplemente haga clic en el pequeño icono de papelera a la derecha en el nombre del brach que desea eliminar.

* Tenga en cuenta que si la rama no se publica, no es necesario intentar eliminarlo de su repositorio en línea.

Creé la siguiente función conveniente en mi archivo .bash_aliases:

git-delete-branch() 
{ 
    if [[ -n $1 ]]; then
        git checkout master > /dev/null;
        branch_name="$1";
        echo "Deleting local $branch_name branch...";
        git branch -D "$branch_name";
        echo "Deleting remote $branch_name branch...";
        git Push Origin --delete "$branch_name";
        git remote Prune Origin;
        echo "Your current branches are:";
        git branch -a;
    else
        echo "Usage: git-delete-branch <branch_name>";
    fi
}

De acuerdo con el último documento utilizando terminal podemos eliminar de la siguiente manera.

eliminar en local:

git branch -D usermanagement

eliminar en una ubicación remota:

git Push --delete Origin usermanagement

Es muy sencillo

Para eliminar una rama remota

git Push -d Origin <branch-name>

OR

git Push Origin :<branch-name>

Para eliminar una rama local

git branch -D <branch-name>