it-swarm-es.tech

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

Quiero eliminar una rama tanto local como remotamente.

Intentos fallidos para eliminar la rama remota:

$ git branch -d remotes/Origin/bugfix
error: branch 'remotes/Origin/bugfix' not found.

$ git branch -d Origin/bugfix
error: branch 'Origin/bugfix' not found.

$ git branch -rd Origin/bugfix
Deleted remote branch Origin/bugfix (was 2a14ef7).

$ git Push
Everything up-to-date

$ git pull
From github.com:gituser/gitproject
* [new branch] bugfix -> Origin/bugfix
Already up-to-date.

¿Qué debo hacer de manera diferente para eliminar con éxito la rama remotes/Origin/bugfix tanto de forma local como remota?

15136
Matthew Rankin

Resumen ejecutivo

$ git Push --delete <remote_name> <branch_name>
$ git branch -d <branch_name>

Tenga en cuenta que en la mayoría de los casos el nombre remoto es Origin.

Eliminar sucursal local

Para eliminar la rama local usa una de las siguientes opciones:

$ git branch -d branch_name
$ git branch -D branch_name

Nota: La opción -d es un alias para --delete, que solo elimina la rama si ya se ha fusionado completamente en su rama ascendente. También puede usar -D, que es un alias para --delete --force, que elimina la rama "independientemente de su estado fusionado". [Fuente: man git-branch]

Delete Remote Branch [Actualizado el 8-Sep-2017]

A partir de Git v1.7.0 , puede eliminar unremotorama usando

$ git Push <remote_name> --delete <branch_name>

lo que podría ser más fácil de recordar que

$ git Push <remote_name> :<branch_name>

que se agregó en Git v1.5.0 "para eliminar una rama remota o una etiqueta".

A partir de Git v2.8.0 también puede usar git Push con la opción -d como un alias para --delete.

Por lo tanto, la versión de Git que haya instalado determinará si necesita usar la sintaxis más fácil o más difícil.

Eliminar rama remota [Respuesta original del 5 de enero de 2010]

Del Capítulo 3 de Pro Git por Scott Chacon:

Eliminar sucursales remotas

Supongamos que ha terminado con una sucursal remota; digamos, usted y sus colaboradores han terminado con una función y la han fusionado en la rama maestra de su remoto (o en la rama en la que se encuentre la línea de código estable). Puede eliminar una rama remota utilizando la sintaxis bastante obtusa git Push [remotename] :[branch]. Si desea eliminar su rama de reparación de servidor del servidor, ejecute lo siguiente:

$ git Push Origin :serverfix
To [email protected]:schacon/simplegit.git
 - [deleted]         serverfix

Auge. No más sucursales en tu servidor. Es posible que desee escuchar esta página, porque necesitará ese comando y probablemente olvidará la sintaxis. Una forma de recordar este comando es recordando la sintaxis de git Push [remotename] [localbranch]:[remotebranch] que revisamos un poco antes. Si deja de lado la parte [localbranch], básicamente está diciendo: "No tome nada de mi parte y haga que sea [remotebranch]".

Emití git Push Origin :bugfix y funcionó muy bien. Scott Chacón tenía razón: querré oreja de perro esa página (o prácticamente oreja de perro al responder esto en Stack Overflow).

Entonces deberías ejecutar esto en otras máquinas.

git fetch --all --Prune

para propagar los cambios.

18919
Matthew Rankin

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

3016
Eric Brotto

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.

Visualization of 3 branches

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.

Diagram 2

Para eliminar esa rama remota real , necesita

git Push Origin --delete bugfix

Diagram 3

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

1743
user456814

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:

 delete a remote and local branch in git

1234
Alireza

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.

746
pagetribe

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
357
Praveen Hiremath

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.

352
pfrenssen
git branch -D <name-of-branch>
git branch -D -r Origin/<name-of-branch>
git Push Origin :<name-of-branch>
256
Felipe

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
220
Syeful Islam

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).

191
imanuelcostigan

Uso lo siguiente en mi Bash settings:

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

Entonces puedes llamar:

git-shoot branchname
160
crizCraig

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

128
Nacho Coloma

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).

119
Ryan Kohn

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.

118
Rahul Gupta

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>

111
mfathy00

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.

106
nickleefly

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

102
u2622

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"
92
Vinnie James

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
90
Ulysses Alves

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
86
jayxhj

Simplemente diga:

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

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  switching branch
  3. En el menú "Rama", selecciona "Anular publicación ..." para que la rama se elimine de los servidores de GitHub.  unpublish branch
  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)  delete local branch
79
Eric
git Push Origin --delete <branch Name>

es más fácil de recordar que

git Push Origin :branchName
78
Smila

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,

 enter image description here

73
Silent Spectator

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
64
Amiramix

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
50
Brandon Cook

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.

49
arthurakay

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!)

45
joey
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
44
user

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
43
Dan Rosenstark

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"
39
Jared Knipp

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.

31
Bradley Flood

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

30
Srijan Karki

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

28
levi

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:

 enter image description here

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.

 enter image description here

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

23
Uchiha Itachi

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
}
19
Vagelis Prokopiou

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
19
KARTHIKEYAN.A

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>
15
Vivek Maru