
Mario González - Blog sobre desarrollo web
Git – Bajar todas las nuevas ramas del repositorio remoto
Cuando estamos trabajando en un equipo de desarrolladores, muchas veces necesitamos bajar alguna rama nueva del repositorio remoto, creada por otro miembro del equipo. Para no tener que estar pendiente de cuándo alguien crea una nueva rama y de cómo se llama, vamos a ver una forma cómoda de tener nuestro repositorio local siempre actualizado con las nuevas ramas del remoto.
Clonar el repositorio con todas las ramas
Si nos queremos clonar un repositorio remoto que ya tiene varias ramas, lo solemos hacer con git clone
:
git clone URL_REPOSITORIO_REMOTO
Muchos usuarios de Git piensan que al hacer un git clone
sólo nos bajamos la rama principal (generalmente master). Y es fácil pensarlo, porque si yo listo las ramas locales después de hacer un git clone
, sólo veo la rama master:

git branch
nos muestra sólo la rama master
Pero en realidad no es la única que nos ha bajado. El comando git branch
, si lo lanzamos sin parámetros, nos lista las ramas locales. Pero si le pasamos el parámetro --all
(o -a
), nos mostrará tanto las locales como las remotas:

git branch -a
nos muestra tanto las ramas locales como las remotasEn realidad, esas ramas remotas que vemos en el listado son copias locales de las ramas remotas. Como acabamos de hacer un git clone
, esas copias estarán exactamente igual que en el repositorio remoto. Si queremos crear las correspondientes ramas locales, sólo tenemos que ir a cada una de las ramas con git checkout
:

git checkout
git branch
nos muestra que ya tenemos todas las ramas en local. Esto es porque al ir a una rama que no existe en el repositorio local, Git la buscará entre las copias de las ramas remotas. Si encuentra una con el mismo nombre, crea la rama local y además la deja vinculada con la rama remota.
push
y pull
sin nombre de rama
Una vez que tenemos todas las ramas vinculadas con sus correspondientes ramas remotas, podemos usar git push
y git pull
sin tener que escribir el nombre de la rama. Git se conectará a la rama remota a la que está vinculada la actual:

git push
envía a la rama remota correspondientePuede que después de usar git push
sin el nombre de la rama, os salga un aviso muy largo explicando que en las nuevas versiones de Git el comportamiento por defecto cuando no escribimos un nombre de rama ha cambiado. Para que no os salga más, escribid:
git config --global push.default simple
Nuevas ramas remotas durante el proyecto
¿Y si ya tenemos el repositorio clonado, llevamos un tiempo trabajando en él, y un día un miembro del equipo sube una rama nueva al repositorio remoto? ¿Nos tiene que avisar? ¿Tenemos que saber cómo se llama la nueva rama? No es necesario, vamos a ver cómo tener siempre actualizadas las copias locales de las ramas remotas.
Más arriba decíamos que, una vez que las ramas locales están vinculadas con las remotas, podemos usar git push
y git pull
sin necesidad de escribir el nombre de una rama. ¿Qué ocurre cuando yo escribo git pull
a secas? Sabemos que el comando git pull
en realidad lanza dos comandos secuencialmente: primero hace git fetch
y luego git merge
. Ese primer comando es el que nos interesa: ese fetch
nos actualizará todas las copias locales de las ramas remotas, copiando las que haya nuevas. Es decir, cada vez que hacemos un git pull
sin nombre de rama, estamos sincronizando nuestras copias de las remotas con las ramas remotas reales.

git pull
nos baja las ramas remotas nuevasEn la captura anterior partíamos de un repositorio local con las ramas master, rama1, rama2, rama3 y rama4. Al hacer git pull
, lo primero que hace es actualizarnos las copias locales de las ramas remotas. Como en el repositorio remoto hay una rama nueva que no teníamos en local (rama5), nos baja la copia y ya la tenemos en el repositorio local.
Para crear la rama local correspondiente, sólo tenemos que entrar en ella, como hacíamos justo después del git clone
, y Git nos la creará a partir de la copia remota:

git checkout
nos crea la nueva ramaConclusiones
Hemos visto qué sencillo es mantener sincronizadas nuestras ramas locales con las remotas, sin tener que estar pendientes de cuándo aparecen ramas nuevas. Si estábais hasta el gorro de usar la nada intuitiva fórmula de git fetch origin nueva_rama:nueva_rama
, ya podéis olvidaros de ella y empezar a usar este método.
Gracias por esta publicación. Me ayudó muchísimo a entender.
Y si en caso de que una rama en el remoto es borrada? Se tiene que hacer de forma local en el «backup»?
Mi intención es crear una sincronización de los cambios del remoto al local ( sin tocar el local)
Ha si! Y gracias por el tutorial ^^
Hola, Daniel.
Me alegro de que el tutorial te haya resultado útil. Con Git tenemos que alejarnos de la idea de mantener una sincronización exacta y automática del repositorio local y el remoto. Git no está pensado para ser usado así. Cuando se borra una rama remota, en tu repositorio se mantienen tanto su referencia (la copia local de la rama remota borrada) como la rama local. Puedes hacer que se elimine automáticamente la primera con esto:
git config [--global] fetch.prune true
Pero eso no borrará la rama local. Esto es porque Git te permite tener una rama local que no tiene por qué estar vinculada a ninguna remota. Si quieres que también se borre la rama local, tienes que hacerlo tú a mano.
Muy bien explicado , gracias por compartir