Git Fetch | Tutorial de Git en línea de W3Docs

El comando git fetch descarga commits, archivos y referencias de un repositorio remoto a tu repositorio local, sin modificar ninguno de tus propios cambios. Es la forma segura de ver qué han estado haciendo tus compañeros de equipo: nada en tu directorio de trabajo ni en tus ramas locales se toca hasta que decides hacer la fusión.

Esta página explica qué hace git fetch, cómo actualiza las ramas de seguimiento remoto, las opciones más útiles, cómo obtener una rama específica o todo un remoto, y en qué se diferencia git fetch de git pull.

Definición

El comando git fetch se utiliza para descargar commits, objetos y referencias de un repositorio remoto al repositorio local. Se usa para ver en qué han estado trabajando los demás miembros del equipo. A diferencia de git pull, nunca fusiona el trabajo descargado en tu rama actual de forma automática.

Cómo funciona con las ramas remotas

Git almacena los commits locales y remotos, y los separa mediante el uso de referencias de ramas. Las referencias de las ramas locales se almacenan en /.git/refs/heads/. Para ver la lista de referencias de ramas locales, ejecuta el comando git branch.

git branch

git branch
* master
  crossword
  solver

Al explorar el contenido del directorio /.git/refs/heads/ se obtiene la siguiente salida:

ls ./.git/refs/heads/

ls ./.git/refs/heads/
master
crossword
solver

Las referencias de ramas remotas se almacenan en el directorio ./.git/refs/remotes/. Para ver las ramas remotas, usa la opción -r con git branch. Este es el resultado después de obtener un repositorio remoto:

git branch -r

git branch -r
  origin/master
  origin/crossword
  origin/solver
  remote-repo/master
  remote-repo/other-feature

La salida muestra las ramas remotas con el prefijo origin/. Estas son ramas de seguimiento remoto — copias locales de solo lectura que registran dónde estaba cada rama en el remoto la última vez que hiciste fetch. Puedes examinarlas con los comandos git checkout y git log. Después de revisar los cambios, puedes fusionar una rama de seguimiento remoto en tu rama local con git merge. Usa git pull para combinar fetch y merge en un solo paso.

Opciones comunes

Opción	Qué hace
`--all`	Obtiene todos los remotos configurados, no solo uno.
`-k`, `--keep`	Conserva el archivo pack descargado en lugar de desempaquetarlo.
`-p`, `--prune`	Elimina las referencias de seguimiento remoto que ya no existen en el remoto.
`--depth=<depth>`	Limita el número de commits obtenidos desde la punta de cada rama (un fetch superficial).
`--dry-run`	Muestra lo que se obtendría sin descargar nada realmente.

Para eliminar las referencias de seguimiento de ramas que ya no existen en el remoto, usa --prune:

git fetch --prune

Para obtener desde todos los remotos configurados a la vez, usa --all:

git fetch --all

Cómo hacer git fetch de una rama remota

A continuación, mostramos los pasos para obtener una rama remota y actualizar el estado de trabajo local con el contenido remoto. En el siguiente ejemplo, tenemos un repositorio central origin desde el cual se ha clonado el repositorio local con el comando git clone. Hay otro repositorio remoto llamado test_repo que contiene feature_branch, el cual debe configurarse y descargarse.

El primer paso es configurar el repositorio remoto con git remote:

git remote

git remote add test_repo git@hostname:test/test_repo.git

Usando la URL del repositorio del compañero de trabajo, hemos creado una referencia a él. Para descargar el contenido, hacemos git fetch de la feature_branch de prueba:

git fetch

git fetch test_repo feature_branch
From hostname:test/test_repo
* [new branch]      feature_branch -> test_repo/feature_branch

Esto descarga el contenido de test_repo/feature_branch en tu repositorio local como una rama de seguimiento remoto — no lo fusiona en tu rama actual. Ahora, usa el comando git checkout para inspeccionar la rama remota descargada:

git checkout test_repo/feature_branch

git checkout test_repo/feature_branch
Note: checking out 'test_repo/feature_branch'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can drop all the commits you make in this
state without influencing branches by executing another checkout.

If you want to generate a new branch for maintaining commits you create, you may
do so (now or later) if you use -b with the checkout command again. Example:

git checkout -b &lt;new-branch-name&gt;

La salida muestra que estamos en el estado de HEAD desconectado (detached HEAD), lo que significa que la referencia HEAD apunta directamente a un commit en lugar de a una rama.

Con el comando git checkout se puede crear una nueva rama local a partir de la referencia test/feature_branch:

git checkout -b local_feature_branch test_repo/feature_branch

git checkout -b local_feature_branch test_repo/feature_branch

La nueva rama local se crea actualizando HEAD para apuntar al contenido remoto más reciente.

Sincronizar origin con git fetch

El siguiente ejemplo muestra cómo sincronizar el repositorio local con la rama master del repositorio central:

git fetch origin

git fetch origin

La salida mostrará las ramas que se han descargado:

git fetch origin output

b341bc3..32a45b1  master     -> origin/master
b341bc3..7a52a22  develop    -> origin/develop
* [new branch]      some-feature -> origin/some-feature

Invoca git log usando origin/master como filtro para mostrar los commits añadidos al master principal:

git log --oneline master..origin/master

git log --oneline master..origin/master

Revisa los cambios y fusiónelos en la rama master local:

git checkout master && git log origin/master

git checkout master
git log origin/master

Ejecuta git merge origin/master para sincronizar con los desarrollos del repositorio principal:

git merge

git merge origin/master

Un escenario típico de colaboración

Aquí tienes un escenario para ayudarte a entender mejor este concepto.

Imagina un pequeño equipo de desarrollo formado por dos desarrolladores, Alice y Bob. Están trabajando en un proyecto alojado en un repositorio Git remoto llamado origin. Alice clona el repositorio en su máquina local y empieza a trabajar en la rama main, mientras que Bob trabaja en una rama separada llamada feature-branch.

1- Alice crea un nuevo archivo llamado README.md y realiza algunos cambios en él. Luego confirma y envía sus cambios a la rama main del repositorio origin:

$ git add README.md
$ git commit -m "Add README file"
$ git push origin main

2- Mientras tanto, Bob ha realizado algunos cambios en feature-branch y los ha enviado al repositorio origin:

$ git add some_file.txt
$ git commit -m "Add new feature"
$ git push origin feature-branch

3- Alice se da cuenta de que necesita incorporar los cambios de Bob en su propio trabajo, por lo que obtiene los cambios del repositorio origin:

$ git fetch origin

4- Después del fetch, Alice puede ver que hay nuevos cambios en feature-branch:

$ git branch -r
  origin/HEAD -> origin/main
  origin/main
  origin/feature-branch

5- Alice puede ahora fusionar los cambios de Bob en su rama main:

$ git merge origin/feature-branch

6- Alice resuelve los conflictos de fusión y luego envía sus cambios al repositorio origin:

$ git push origin main

7- Bob puede ahora obtener los cambios realizados por Alice:

$ git fetch origin

8- Bob puede ver que hay nuevos cambios en la rama main:

$ git branch -r
  origin/HEAD -> origin/main
  origin/main
  origin/feature-branch

9- Bob puede fusionar los cambios de Alice en su feature-branch:

$ git merge origin/main

10- Bob resuelve los conflictos de fusión y luego envía sus cambios al repositorio origin:

$ git push origin feature-branch

Y así el ciclo continúa, con Alice y Bob usando git fetch para rastrear los cambios realizados por el otro y enviar sus propios cambios al repositorio origin. Al usar git fetch, pueden mantener su repositorio local actualizado con los cambios de sus compañeros de equipo, lo que ayuda a evitar conflictos y garantiza un proceso de colaboración fluido.

Git fetch vs git pull

Tanto git fetch como git pull se usan para descargar contenido del repositorio remoto. El comando git fetch no fusiona automáticamente los cambios en tus ramas locales; simplemente actualiza tus ramas de seguimiento remoto. El contenido descargado no afecta tu directorio de trabajo local, lo que te permite revisar los commits de forma segura antes de fusionarlos. El comando git pull descarga nuevo contenido y lo fusiona automáticamente en tu rama actual. Esto puede causar conflictos de fusión, por lo que se recomienda ejecutar git pull solo cuando tu copia de trabajo esté limpia.

En resumen, git pull es aproximadamente equivalente a git fetch seguido de git merge:

git pull origin main
# is similar to:
git fetch origin
git merge origin/main

Cuándo usar git fetch

Recurre a git fetch cuando quieras:

Ver qué cambió antes de integrarlo. Haz fetch primero, luego inspecciona con git log origin/main.. o git diff main origin/main, y fusiona solo cuando estés listo.
Actualizar las ramas de seguimiento remoto sin tocar tu trabajo. Útil en medio de una tarea cuando tu directorio de trabajo tiene cambios sin confirmar que un git pull podría interrumpir.
Limpiar ramas obsoletas. git fetch --prune elimina las referencias de seguimiento remoto de ramas que fueron borradas en el remoto.
Revisar la rama de un compañero. Descárgala, compruébala para leer el código y decide si fusionarla.

Práctica

¿Cuáles de las siguientes afirmaciones sobre el comando git fetch son correctas?

git fetch descarga commits, archivos y referencias de un repositorio remoto al repositorio local.Después de usar git fetch, tus ramas locales se actualizan automáticamente para coincidir con el repositorio remoto.git fetch admite opciones como --all, --dry-run, --keep, --prune y --depth.Usar git fetch te pone en un estado de 'detached HEAD' donde puedes experimentar sin afectar las ramas locales.git fetch seguido de git merge es una forma segura de revisar e integrar cambios de un repositorio remoto.git fetch fuerza la fusión de los cambios remotos en tu rama actual.