W3Docs

Apariencia

Español

git fetch ​

Definición ​

El comando git fetch se usa para descargar commits, objetos y referencias desde un repositorio remoto al repositorio local. Se utiliza para ver en qué han estado trabajando otros miembros del equipo.

git fetch

Cómo funciona con ramas remotas ​

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

git branch

bash
git branch
* master
  crossword
  solver

Explorar el contenido del directorio /.git/refs/heads/ mostrará la siguiente salida:

ls ./.git/refs/heads/

bash
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. Aquí está la salida después de obtener un repositorio remoto:

git branch -r

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

La salida muestra ramas remotas con el prefijo origin/. Puedes examinar las ramas remotas con los comandos git checkout y git log. Después de aprobar los cambios de la rama remota, puedes fusionarla con la rama local usando el comando git merge. Usa en su lugar el comando git pull para acortar el proceso.

Opciones comunes ​

--allObtiene todas las ramas remotas.
-k o --keepConserva el paquete descargado.
-p o --pruneElimina las referencias de seguimiento remoto que no existían en el remoto antes de la obtención.
--depth=<depth>Limita el número de commits que se obtienen desde la punta del historial de cada rama remota.

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

bash
git fetch --prune

Cómo hacer git fetch de la rama remota ​

Aquí mostraremos 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 y que debe configurarse y obtenerse.

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

git remote

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

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

git fetch

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

Esto integrará el contenido de test/feature_branch en el repositorio local. Ahora, usa el comando git checkout para hacer checkout de la rama remota descargada:

git checkout test_repo/feature_branch

bash
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 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

bash
git checkout -b local_feature_branch test_repo/feature_branch

La nueva rama local se crea actualizando HEAD para que apunte 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

bash
git fetch origin

La salida mostrará las ramas que se han descargado:

git fetch origin output

bash
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 ascendente:

git log --oneline master..origin/master

bash
git log --oneline master..origin/master

Comprueba los cambios y fusiónalos en la rama master local:

git checkout master && git log origin/master

bash
git checkout master
git log origin/master

Ejecuta git merge origin/master para sincronizar con los desarrollos ascendentes:

git merge

bash
git merge origin/master

Un ejemplo de escenario común: ​

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

Supón que hay 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 le hace algunos cambios. Luego confirma y envía sus cambios a la rama main del repositorio origin:

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

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

bash
$ 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, así que obtiene los cambios del repositorio origin:

bash
$ git fetch origin

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

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

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

bash
$ git merge origin/feature-branch

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

bash
$ git push origin main

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

bash
$ git fetch origin

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

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

9- Bob puede fusionar los cambios realizados por Alice en su rama feature-branch:

bash
$ git merge origin/main

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

bash
$ git push origin feature-branch

Y así el ciclo continúa, con Alice y Bob usando git fetch para seguir 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 realizados por sus compañeros, 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 desde el 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 obtenido no afecta a tu directorio de trabajo local, lo que te permite revisar los commits de forma segura antes de fusionarlos. El comando git pull descarga contenido nuevo 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.

Práctica ​

¿Cuáles son las afirmaciones correctas sobre el comando `git fetch` tal como se describe en el Tutorial de Git de W3Docs?

¿Te resulta útil?

Vista previa dual-run — compárala con las rutas Symfony en producción.