Quiero eliminar una sucursal tanto local como remotamente.

Intentos fallidos de eliminar una 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 remotes/origin/bugfixsucursal tanto local como remotamente?

Resumen Ejecutivo

$ git push -d <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. En tal caso, tendrá que usar el comando así.

$ git push -d origin <branch_name>

Eliminar sucursal local

Para eliminar la sucursal local , utilice uno de los siguientes:

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

Nota: La -dopción 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 combinado". [Fuente: man git-branch]

Eliminar sucursal remota [Actualizado el 8-sep-2017]

A partir de Git v1.7.0 , puede eliminar una rama remota usando

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

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 pushla -dopción 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 sucursal remota [Respuesta original del 5 de enero de 2010]

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

Eliminar ramas remotas

Supongamos que ha terminado con una rama remota; por ejemplo, usted y sus colaboradores han terminado con una función y la han fusionado en la rama maestra de su control remoto (o en cualquier rama en la que esté su 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 del servidor del servidor, ejecute lo siguiente:

$ git push origin :serverfix
To [email protected]:schacon/simplegit.git
 - [deleted]         serverfix

Auge. No más sucursales en su 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 git push [remotename] [localbranch]:[remotebranch]sintaxis que analizamos un poco antes. Si dejas la [localbranch]porción, entonces básicamente estás diciendo: "No tomes nada de mi lado y haz que sea [remotebranch]".

Emití git push origin: bugfixy funcionó muy bien. Scott Chacon tenía razón: querré escuchar esa página (o prácticamente oreja de perro respondiendo esto en Stack Overflow).

Entonces deberías ejecutar esto en otras máquinas

# Fetch changes from all remotes and locally delete 
# remote deleted branches/tags etc
# --prune will do the job :-;
git fetch --all --prune

para propagar cambios.

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

Para eliminar una sucursal local de su máquina:

git branch -d {the_local_branch}(use -Den su lugar para forzar la eliminación de la rama sin verificar el estado combinado)

Para eliminar una rama remota del servidor:

git push origin --delete {the_remote_branch}

Referencia: Git: Eliminar una rama (local o remota)

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 -d <branch>        # Shorter version (Git 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 remote-tracking branches
git fetch <remote> -p      # Shorter

La respuesta larga : ¡hay tres ramas diferentes para eliminar!

Cuando se trata de eliminar ramas tanto local como remotamente, tenga en cuenta que hay tres ramas diferentes involucradas :

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

El póster original utilizado:

git branch -rd origin/bugfix

Que solo eliminó su rama local de seguimiento remoto origin/bugfix , y no la rama remota real bugfixen origin.

Para eliminar esa rama remota real , necesita

git push origin --delete bugfix

Detalles adicionales

Las siguientes secciones describen detalles adicionales a tener en cuenta al eliminar sus sucursales remotas y de seguimiento remoto.

Presionar para eliminar ramas remotas también elimina las ramas de seguimiento remoto

Tenga en cuenta que al eliminar la rama remota Xde la línea de comando utilizando a git push también se 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 --pruneo git fetch -p. Sin embargo, no dolería si lo hicieras de todos modos.

Puede verificar que la rama de seguimiento remoto origin/Xtambié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 de la rama obsoleta local de seguimiento remoto origen / X

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

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

git fetch origin --prune
git fetch origin -p # Shorter

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

"git fetch" aprendido --all y --multipleopciones, para ejecutar fetch desde muchos repositorios, y la --pruneopción de eliminar ramas de seguimiento remotas que quedaron obsoletas. Esto hace que la "actualización remota de git" y la "poda remota de git" sean menos necesarias (sin embargo, no hay ningún plan para eliminar la "actualización remota" ni la "poda remota").

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

Alternativamente, en lugar de podar sus ramas locales de seguimiento remoto obsoletas git fetch -p, puede evitar realizar la operación de red adicional simplemente eliminando manualmente las ramas con las banderas --remoteo -r:

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

Ver también

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

Pasos para eliminar una rama:

Para eliminar la rama remota:

git push origin --delete <your_branch>

Para eliminar la sucursal local , tiene tres formas :

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

Explique: OK, ¡solo explique lo que está pasando aquí!

Simplemente haga git push origin --deletepara eliminar su rama remota solamente , agregue el nombre de la rama al final y esto lo borrará y lo enviará al control remoto al mismo tiempo ...

Además, git branch -Dque simplemente eliminan la rama local solamente ...

-Dsignifica --delete --forceque eliminará la rama incluso si no está fusionada (forzar eliminación), pero también puede usar -dqué significa--delete que arroja un error respectivo del estado de fusión de la rama ...

También creo la imagen a continuación para mostrar los pasos:

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

git push --delete origin serverfix

Que hace lo mismo que

git push origin :serverfix

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

Consejo: cuando eliminas ramas usando

git branch -d <branchname> # Deletes local branch

o

git push origin :<branchname> # Deletes remote branch

solo se eliminan las referencias. Aunque 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 son visibles cuando hacen ungit branch -a .

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

git remote prune <repository>

Esto es típicamente git remote prune origin.

Si desea eliminar una rama, primero realice el pago en la rama que no sea la rama que se va a eliminar.

git checkout other_than_branch_to_be_deleted

Eliminar la sucursal local:

git branch -D branch_to_be_deleted

Eliminar la rama remota:

git push origin --delete branch_to_be_deleted

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 rama de Git tanto local como remotamente, primero elimine la rama local con este comando:

git branch -d example

(Aquí example está el nombre de la sucursal).

Y después de eso, elimine la rama remota usando este 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 ampliamente,

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

Utilizo lo siguiente en mi configuración de Bash :

alias git-shoot="git push origin --delete"

Entonces puedes llamar:

git-shoot branchname

Eliminar localmente:

Para eliminar una sucursal local, puede usar:

git branch -d <branch_name>

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

git branch -D <branch_name>

Eliminar de forma remota:

Hay dos opciones:

git push origin :branchname

git push origin --delete branchname

Te sugiero que uses la segunda forma, ya que es más intuitiva.

Desde enero de 2013, GitHub incluyó un Delete branch botón al lado de cada sucursal en su página "Sucursales".

Publicación de blog relevante: crear y eliminar sucursales

Si desea completar estos dos pasos con un solo comando, puede crear un alias para él 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'

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

Para eliminar su sucursal local y remotamente

• Pago a la sucursal maestra - git checkout master

• Eliminar su sucursal remota git push origin --delete <branch-name>

• Eliminar su 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

Poda y elimina ramas de seguimiento remoto de una git branch -rlista.

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

Me parece que también uso los comandos publishy con trackbastante frecuencia.

Un comando de una línea para eliminar 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 ramas

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

$ git branch -d contact-form

Y para eliminar la rama remota:

git push origin --delete contact-form

Eliminar sucursal remota

git push origin :<branchname>

Eliminar sucursal local

git branch -D <branchname>

Eliminar pasos de sucursal local:

1. pago a otra sucursal
2. eliminar sucursal local

Simplemente di:

git branch -d <branch-name>
git push origin :<branch-name>

git push origin --delete <branch Name>

es más fácil de recordar que

git push origin :branchName

Ahora puedes hacerlo con la aplicación GitHub Desktop .

Después de iniciar 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", seleccione "No publicar ..." para eliminar la rama de los servidores de GitHub.

   

4. En el menú "Sucursal", seleccione "Eliminar" nombre_de_sucursal "..." para eliminar la sucursal de su máquina local (también conocida como la máquina en la que está trabajando actualmente)

   

Es muy simple:

Para eliminar la rama remota

git push -d origin <branch-name>

O

git push origin :<branch-name>

Para eliminar sucursal local

git branch -D <branch-name>

Para eliminar localmente - (normal)

git branch -d my_branch

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

Entonces, o bien debes resolver el rebase / fusión. De lo contrario, puede forzar la eliminación utilizando,

git branch -D my_branch

Para eliminar en remoto :

git push --delete origin my_branch

Puedes hacer lo mismo usando:

git push origin :my_branch   # Easy to remember both will do the same.

Representación grafica:

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 usaría:

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 lo necesite git branch -D branch_to_deletesi no está completamente fusionado some_other_branch, por ejemplo.

git checkout some_other_branch
git push origin :branch_to_delete
git branch -d branch_to_delete

La poda remota no es necesaria si eliminó la rama remota. Solo se usa para obtener los controles remotos más actualizados disponibles en un repositorio que está rastreando. He observado git fetchque agregará controles remotos, no los eliminará. Aquí hay un ejemplo de cuándogit remote prune origin realmente hará algo:

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

git fetch
git remote prune origin
git branch -r

Me cansé de buscar en Google esta respuesta, así que tomé un enfoque similar a la respuesta que crizCraig publicó anteriormente.

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 master, por ejemplo) ejecuto lo siguiente en mi terminal:

gitdelete my-branch-name

... que luego se elimina my-branch-namede originque, 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é ingresar exactamente para el <branch>valor. ( branches sensible a mayúsculas y minúsculas)

Utilizar:

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