Introducción

Git es un sistema de control de versiones distribuido: cada clon es un repositorio completo con su propio historial íntegro, no simplemente una copia de trabajo extraída de un servidor central. Por ello, la colaboración en Git consiste fundamentalmente en la sincronización: compartir ramas enteras entre repositorios en lugar de intercambiar conjuntos de cambios individuales.

Esta página presenta los cuatro comandos que mueven confirmaciones entre tu repositorio local y los remotos: git remote, git fetch, git push y git pull. Cada comando se trata en detalle en su propia página, pero entender cómo encajan entre sí es lo que hace que la colaboración diaria resulte predecible.

El modelo mental: local vs. remoto

Antes de hablar de los comandos individuales, conviene tener una imagen simple en mente. Cuando sincronizas intervienen tres elementos:

• Tu repositorio local — las ramas a las que confirmas cambios, por ejemplo main.
• Un remoto — un marcador con nombre (como origin) que apunta a la URL de otro repositorio.
• Ramas de seguimiento remoto — copias locales de solo lectura de las ramas del remoto, con nombres como origin/main. Registran en qué estado estaba el remoto la última vez que te comunicaste con él.

La dirección del flujo de datos indica qué comando usar:

• git fetch y git pull traen confirmaciones desde el remoto hacia abajo.
• git push envía confirmaciones hacia el remoto.
• git remote gestiona las propias conexiones.

git remote

El comando git remote está diseñado para crear, ver y eliminar conexiones a otros repositorios. Por defecto, muestra todas las conexiones remotas que se han almacenado previamente.

Cuando clonas un repositorio, Git crea automáticamente un remoto llamado origin que apunta de vuelta a la URL de origen, por lo que raramente es necesario añadir uno manualmente para tus propios proyectos. Añades remotos adicionales cuando colaboras con forks; por ejemplo, apuntando upstream al proyecto original del que hiciste el fork.

# List configured remotes
git remote
# origin

# Show their fetch/push URLs
git remote -v
# origin  https://github.com/user/repo.git (fetch)
# origin  https://github.com/user/repo.git (push)

# Add a second remote
git remote add upstream https://github.com/original/repo.git

git fetch

El comando git fetch descarga confirmaciones, archivos y referencias de un repositorio remoto a tu repositorio local, actualizando las ramas de seguimiento remoto (como origin/main). Te permite ver en qué han estado trabajando otros miembros del equipo sin tocar tu propia rama de trabajo.

Tanto git fetch como git pull descargan contenido del remoto, pero git fetch es la opción segura y no destructiva: solo avanza las ramas de seguimiento remoto y nunca modifica tus archivos de trabajo. Nada se fusiona hasta que lo solicites explícitamente.

# Download new commits from origin (does not change your working branch)
git fetch origin

# Review what arrived before integrating it
git log main..origin/main

# Integrate it yourself when ready
git merge origin/main

Este patrón de "fetch, luego revisar, luego fusionar" es el motivo por el que muchos equipos prefieren git fetch frente a git pull: puedes inspeccionar los cambios entrantes antes de que lleguen a la rama que estás editando.

git push

El comando git push sube el contenido de tu repositorio local a un repositorio remoto. Mientras que git fetch importa confirmaciones a tus ramas de seguimiento remoto locales, git push exporta tus confirmaciones locales a las ramas correspondientes del remoto, para que el resto del equipo pueda verlas.

# Push the current branch's commits to origin
git push origin main

# First push of a new branch: set up tracking with -u
git push -u origin feature-login

El push solo tiene éxito cuando puede avanzar la rama remota sin perder confirmaciones (un fast-forward). Si alguien más ha hecho push mientras tanto, Git rechaza el push y te pide que integres su trabajo primero, normalmente ejecutando git pull o git fetch y fusionando. Evita --force en ramas compartidas: puede sobrescribir las confirmaciones de tus compañeros.

git pull

El comando git pull equivale esencialmente a git fetch seguido de un paso de integración, todo en un solo comando. Descarga el contenido nuevo del remoto e inmediatamente lo integra en tu rama actual.

Por defecto, git pull combina git fetch con git merge, creando una confirmación de fusión cuando los historiales han divergido. Puedes configurarlo para usar git rebase en su lugar (git pull --rebase), lo que reaplica tus confirmaciones locales sobre las descargadas para obtener un historial lineal.

# Fetch from origin and merge into the current branch
git pull origin main

# Fetch and rebase your local commits on top instead
git pull --rebase origin main

Cuándo usar cada uno

Una guía rápida para el trabajo cotidiano:

• ¿Empiezas a trabajar por la mañana? Ejecuta git pull (o git fetch + revisar + fusionar) para obtener los últimos cambios.
• ¿Quieres ver qué cambió sin interrumpir tu trabajo? Usa git fetch y luego git log o git diff contra origin/<branch>.
• ¿Terminaste una parte del trabajo? Ejecuta git push para compartirla.
• ¿El push fue rechazado? El remoto tiene confirmaciones que tú no tienes. Haz pull (o fetch y merge/rebase), resuelve los conflictos que haya y vuelve a hacer push.

A partir de aquí, consulta las páginas dedicadas a cada comando y el capítulo flujos de trabajo de Git para ver cómo los equipos combinan estos comandos en un proceso repetible.

Práctica