Git desde cero: versiones, ramas y trabajo en equipo

Pensado para quien recién empieza: desde la terminal y tu primer commit hasta clonar repositorios, trabajar con ramas y resolver conflictos en un equipo de varios programadores con GitHub. Paso a paso, con diagramas y ejercicios en cada capítulo.

30 capítulos Solo terminal Modo claro / oscuro Optimizado para móvil Git 2.56 · GitHub
30
Capítulos
60
Ejercicios con solución
6
Partes del curso
0
Requisitos previos
Cómo usar este tutorial: sigue los capítulos en orden (el índice está en el menú si lees desde el móvil). Cada capítulo tiene teoría en lenguaje sencillo, sesiones de terminal reales (todas las salidas que verás las produjo Git 2.56 de verdad), diagramas, ejercicios con solución y puntos clave. Escribe cada comando en TU terminal: Git se aprende con los dedos, no solo leyendo.

1 · Por qué Git: el caos de las versiones

Básico ~12 min

Imagina que estás construyendo la web de la cafetería «Aroma y Punto». El lunes terminas la portada. El martes agregas el menú. El jueves cambias los precios… y el viernes el cliente te dice: «me gustaba más como estaba el martes». ¿Tienes guardada esa versión?

Si eres como casi todos al empezar, tu carpeta se parece a esta:

index.html
index_final.html
index_final_v2.html
index_final_v2_corregido.html
index_final_AHORA_SI.html
index_final_AHORA_SI_luis.html

Seis archivos y nadie sabe cuál es el bueno, qué cambió entre uno y otro, ni quién lo cambió. Ahora súmale un compañero, Luis, que trabaja en el mismo proyecto desde su casa y te envía sus cambios por WhatsApp. Basta un descuido para que uno de los dos pise el trabajo del otro. Ese caos tiene solución, y se llama control de versiones.

En este capítulo aprenderás a:

  • explicar qué problema resuelve un sistema de control de versiones;
  • entender la idea central de Git: guardar «fotos» del proyecto;
  • distinguir Git (la herramienta) de GitHub (el servicio en internet);
  • conocer el mapa del curso y cómo aprovecharlo.

Qué es un sistema de control de versiones

Un sistema de control de versiones es un programa que registra los cambios de tus archivos a lo largo del tiempo. Funciona como los puntos de guardado de un videojuego: cada vez que llegas a un lugar seguro, guardas. Si después algo sale mal, vuelves al último punto bueno sin perder lo anterior.

Con un sistema así puedes responder, en segundos, preguntas que hoy te quitarían horas:

  • ¿Qué cambió? Ver exactamente las líneas agregadas o borradas.
  • ¿Quién lo cambió y cuándo? Cada cambio queda firmado con nombre y fecha.
  • ¿Por qué? Cada cambio lleva un mensaje que lo explica.
  • ¿Puedo volver atrás? Sí, a cualquier punto guardado.
  • ¿Podemos trabajar dos a la vez? Sí, y luego juntar el trabajo de ambos.

La idea central de Git: fotos del proyecto

Git es el sistema de control de versiones más usado del mundo. Su idea central es sencilla: cada vez que tú se lo pides, Git toma una foto completa de tu proyecto y la guarda con un mensaje. A esa foto se le llama commit (en español, «confirmación»; en este curso diremos commit, como en cualquier equipo de desarrollo).

El historial de un proyecto como una fila de fotos portada menú precios contacto lunes martes jueves hoy
Fig. 1.1 · Cada círculo es una «foto» (commit) del proyecto completo. Puedes volver a cualquiera.

Los commits forman una fila ordenada en el tiempo: el historial. Cada uno recuerda cuál fue el anterior, así que Git puede mostrarte el camino completo del proyecto y llevarte a cualquier punto. En lugar de seis archivos index_final… tendrás un solo index.html y, detrás, toda su historia.

Un poco de historia: Git lo creó Linus Torvalds en 2005 para coordinar a los miles de programadores del núcleo Linux. Si sirve para uno de los proyectos más grandes del planeta, sirve de sobra para tu web.

Cada integrante tiene la historia completa

Git es un sistema distribuido: cada persona del equipo tiene en su computadora una copia completa del proyecto y de todo su historial. Puedes guardar commits sin internet, revisar la historia en un avión y, cuando vuelvas a conectarte, compartir tu trabajo con el resto.

Sin control de versionesCon Git
Copias con nombres como final_v2Un solo archivo con todo su historial
«¿Quién borró esto?»: nadie sabeCada cambio tiene autor, fecha y motivo
Volver atrás = buscar una copia viejaVolver atrás = un comando
Dos personas editando = alguien pierde trabajoCada uno trabaja en su rama y luego se juntan
Respaldo = USB o correoCopia completa en cada computadora y en GitHub

Git no es GitHub

Esta confusión es la más común entre quienes empiezan, así que vale la pena aclararla desde ya:

GitGitHub
¿Qué es?Un programa que instalas en tu computadoraUn sitio web que guarda repositorios de Git en internet
¿Necesita internet?NoSí
¿Para qué sirve?Guardar versiones, crear ramas, juntar cambiosCompartir el proyecto, revisar código en equipo, publicar
AnalogíaLa cámara que toma las fotosEl álbum compartido donde el equipo sube sus fotos
Alternativas— (Git es el estándar)GitLab, Bitbucket, Gitea

Primero aprenderás Git en tu propia computadora (partes I a IV) y después lo conectarás con GitHub para trabajar en equipo (parte V).

El mapa del curso

ParteQué lograrás
I · Primeros pasosInstalar Git, manejar lo básico de la terminal y crear tu primer repositorio
II · Git a solasGuardar commits, leer la historia, ver diferencias y deshacer errores
III · RamasTrabajar en varias ideas a la vez sin romper lo que ya funciona
IV · ConflictosEntender y resolver con calma los choques entre cambios
V · Trabajo en equipoClonar repositorios, sincronizar con GitHub y hacer Pull Requests
VI · Nivel profesionalRebase, herramientas de rescate y buenas prácticas
Regla de oro: Git se aprende escribiendo comandos, no leyendo sobre ellos. Desde el próximo capítulo tendrás una terminal abierta al lado del manual: escribe cada ejemplo tú mismo, aunque parezca obvio.

Practica

BásicoPara cada situación, indica si la resuelve Git, GitHub o ambos: (a) volver a la versión del martes estando sin internet; (b) que Luis descargue el proyecto desde su casa; (c) saber quién cambió el precio del café y por qué.

Ver solución 1
(a) Git: el historial completo está en tu computadora, no necesitas internet.
(b) GitHub (con Git): el repositorio compartido vive en internet y Luis lo descarga.
(c) Git: cada commit guarda autor, fecha y mensaje. GitHub solo lo muestra en la web.

Regla práctica: si funciona sin internet, es Git. GitHub agrega el lugar compartido y las herramientas de equipo.

RetoReemplaza la carpeta caótica del capítulo (index_final_v2…) por un historial: escribe los mensajes de los cuatro commits de la Fig. 1.1, uno por línea, empezando por un verbo.

Ver solución 2
Crea la portada con el logo y el lema
Agrega el menú de bebidas calientes
Actualiza los precios de julio
Agrega la sección de contacto con el mapa

Un buen mensaje responde «¿qué hace este cambio?» en una línea. En el capítulo 8 verás la convención completa.

Puntos clave

  • Un sistema de control de versiones registra qué cambió, quién, cuándo y por qué.
  • Un commit es una foto completa del proyecto con un mensaje; el historial es la fila de commits.
  • Git es distribuido: cada integrante tiene el proyecto y todo su historial.
  • Git es el programa; GitHub, el servicio en internet donde el equipo comparte sus repositorios.

2 · Instalación en Windows, Linux y macOS

Básico ~15 min

Antes de guardar tu primer commit necesitas Git instalado. En este capítulo lo instalarás en tu sistema y comprobarás que funciona. Elige solo la sección de tu sistema operativo; el resto del curso es idéntico para todos.

En este capítulo aprenderás a:

  • instalar Git en Windows, Linux o macOS;
  • elegir las opciones correctas del instalador de Windows;
  • abrir una terminal y comprobar la versión instalada.

Windows: Git for Windows

En Windows, Git se instala con el paquete oficial Git for Windows, que además trae Git Bash: una terminal que entiende los mismos comandos que Linux y macOS. Gracias a ella, todo lo que escribas en este curso funcionará igual en cualquier sistema.

  1. Entra a git-scm.com/install/windows y descarga el instalador de 64 bits.
  2. Ejecútalo y avanza con Next. En casi todas las pantallas la opción marcada ya es la correcta; estas son las que conviene revisar:
Pantalla del instaladorEligePor qué
Choosing the default editor used by GitUse the Nano editor by defaultEl valor por defecto es Vim, que confunde a quien empieza. Nano muestra sus atajos en pantalla.
Adjusting the name of the initial branch in new repositoriesOverride the default branch name… y escribe mainEs el nombre estándar actual; lo verás en el capítulo 4.
Adjusting your PATH environmentGit from the command line and also from 3rd-party software (Recommended)Permite usar Git desde Git Bash, PowerShell y otros programas.
Choosing the SSH executableUse bundled OpenSSHLo usarás para conectarte a GitHub en el capítulo 23.
Configuring the line ending conversionsCheckout Windows-style, commit Unix-style line endingsEvita problemas de saltos de línea al trabajar con compañeros en Linux o macOS.
  1. Al terminar, abre el menú Inicio, busca Git Bash y ábrelo. Esa ventana será tu terminal durante todo el curso.

Linux (Ubuntu, Debian y derivados)

Git está en los repositorios oficiales de tu distribución. Abre la aplicación Terminal y escribe:

sudo apt update
sudo apt install -y git

Ubuntu 24.04 instala así la versión 2.43, suficiente para todo el curso. Si quieres la más reciente, usa el repositorio oficial de los mantenedores de Git:

sudo add-apt-repository ppa:git-core/ppa
sudo apt update
sudo apt install -y git

En Fedora el comando es sudo dnf install git.

macOS

La forma recomendada es Homebrew, el gestor de paquetes de macOS. Abre la aplicación Terminal y escribe:

brew install git

Si no usas Homebrew, macOS te ofrecerá instalar las Command Line Tools la primera vez que escribas git; esa versión de Apple funciona, aunque suele ser más antigua.

Comprueba que Git responde

En tu terminal (Git Bash en Windows), escribe este comando y presiona Enter:

git --version
git version 2.56.0

Si ves git version seguido de un número, Git está listo. Tu número puede ser distinto (por ejemplo, Git for Windows agrega .windows.1 al final): todo el curso funciona desde la versión 2.40.

¿Dice «command not found» o «no se reconoce»? Cierra la terminal y ábrela de nuevo: la instalación actualiza el PATH, y las ventanas que ya estaban abiertas no se enteran. Si sigue fallando en Windows, vuelve a instalar y revisa la pantalla Adjusting your PATH environment.

¿Por qué la terminal y no un programa con botones?

Existen programas visuales para Git, pero en este curso trabajarás solo con la terminal. Es la forma universal: funciona igual en tu computadora, en la de tu equipo y en un servidor sin pantalla; todas las guías y respuestas de internet usan comandos; y cuando algo se complica, entender los comandos es lo que te permite resolverlo. En el próximo capítulo aprenderás lo justo de la terminal para moverte con soltura.

Regla de oro: instala siempre desde la fuente oficial (git-scm.com, el repositorio de tu distribución o Homebrew). Un instalador descargado de una página cualquiera puede traer software no deseado.

Practica

BásicoComprueba que Git está instalado mostrando su versión.

Ver solución 1
git --version
git version 2.56.0

Si tu número es distinto no pasa nada: todo el curso funciona desde Git 2.40.

RetoEstás sin internet y no recuerdas qué opciones tiene un comando. Pídele a Git la ayuda resumida de git init sin abrir el navegador.

Ver solución 2
git init -h
usage: git init [-q | --quiet] [--bare] [--template=<template-directory>] [--separate-git-dir <git-dir>] [--object-format=<format>] [--ref-format=<format>] [-b <branch-name> | --initial-branch=<branch-name>] [--shared[=<permissions>]] [<directory>] --[no-]template <template-directory> directory from which templates will be used --[no-]bare create a bare repository --shared[=<permissions>] specify that the git repository is to be shared amongst several users -q, --[no-]quiet be quiet --[no-]separate-git-dir <gitdir> separate git dir from working tree -b, --[no-]initial-branch <name> override the name of the initial branch --[no-]object-format <hash> specify the hash algorithm to use --[no-]ref-format <format> specify the reference format to use

-h muestra la ayuda corta en la misma terminal; git help init abre el manual completo.

Puntos clave

  • Windows: Git for Windows, que incluye Git Bash; elige Nano como editor y main como rama inicial.
  • Linux: sudo apt install git; el PPA git-core trae la versión más reciente.
  • macOS: brew install git.
  • git --version confirma la instalación; si no responde, abre una terminal nueva.

3 · La terminal mínima para usar Git

Básico ~18 min

La terminal es una ventana donde le das órdenes a la computadora escribiendo, en lugar de hacer clic. Al principio intimida, pero para usar Git solo necesitas una docena de comandos. En este capítulo aprenderás exactamente esos, con un proyecto de práctica.

En este capítulo aprenderás a:

  • saber en qué carpeta estás y qué contiene;
  • crear carpetas y archivos, y moverte entre ellos;
  • entender las rutas y la carpeta personal ~;
  • ver archivos ocultos (así vive Git) y usar los atajos que ahorran tiempo.

Abre tu terminal: Git Bash en Windows o Terminal en Linux y macOS. Verás una línea que termina en $: es el prompt, la terminal esperando una orden. Escribes el comando, presionas Enter y aparece la respuesta.

¿Quieres dominar la terminal? Este capítulo enseña lo justo para usar Git. Si quieres ir más allá (tuberías, búsquedas, permisos, scripts), sigue el curso La terminal desde cero.
Cómo leer este manual: los bloques oscuros contienen lo que TÚ escribes (cópialo con el botón de la esquina); el bloque verde que sigue muestra lo que responde la terminal. Todas estas respuestas se obtuvieron ejecutando los comandos de verdad.

¿Dónde estoy? pwd y ls

pwd (print working directory) te dice en qué carpeta estás, y ls (list) muestra lo que hay dentro. Al abrir la terminal empiezas en tu carpeta personal, que aún está vacía en este ejemplo:

pwd
/home/ana
ls
Árbol de carpetas de Ana 📁 /home/ana 📁 proyectos 📁 aroma 📄 index.html 📁 css 📄 estilos.css 📁 Descargas
Fig. 3.1 · Las carpetas forman un árbol. Tu «carpeta personal» (~) es /home/ana; en Git Bash de Windows se ve como /c/Users/ana.

Crear carpetas y entrar en ellas: mkdir y cd

mkdir (make directory) crea una carpeta y cd (change directory) te lleva a ella. Crearemos la carpeta del proyecto con el que trabajarás todo el curso:

mkdir proyectos
cd proyectos
mkdir aroma
cd aroma
pwd
/home/ana/proyectos/aroma

Fíjate que mkdir y cd no responden nada cuando todo sale bien. En la terminal, el silencio significa éxito.

Crear y leer archivos

Para crear archivos sin salir de la terminal tienes dos formas rápidas: echo "texto" > archivo crea el archivo con ese contenido, y touch archivo lo crea vacío. Con cat lees su contenido:

cd proyectos/aroma
echo "<h1>Aroma y Punto</h1>" > index.html
mkdir css
touch css/estilos.css
ls
css index.html
cat index.html
<h1>Aroma y Punto</h1>
Cuidado con el símbolo >: echo "texto" > archivo REEMPLAZA todo el contenido del archivo. Para agregar una línea al final sin borrar lo anterior se usa >>.

Los archivos ocultos

En Linux, macOS y Git Bash, los nombres que empiezan con punto son ocultos: ls no los muestra. Para verlos agrega la opción -a (all). Es importante porque Git guarda todo su trabajo en una carpeta oculta llamada .git, que conocerás en el capítulo 5:

cd proyectos/aroma
ls
css index.html
ls -a
. .. .oculto css index.html

Las entradas . y .. aparecen en toda carpeta: el punto es «esta carpeta» y los dos puntos, «la carpeta de arriba».

Moverse con rutas

Una ruta es la dirección de una carpeta o archivo dentro del árbol. Las hay de dos tipos:

TipoEjemploSe lee como
Relativa (desde donde estás)css/estilos.css«la carpeta css que está aquí»
Subir un nivel..«la carpeta de arriba»
Absoluta (desde la raíz)/home/ana/proyectos«esta dirección exacta, esté donde esté»
Carpeta personal~«mi carpeta de usuario» (/home/ana)
cd proyectos/aroma/css
pwd
/home/ana/proyectos/aroma/css
cd ..
pwd
/home/ana/proyectos/aroma
cd ../..
pwd
/home/ana
cd ~/proyectos/aroma
pwd
/home/ana/proyectos/aroma

Atajos que te ahorrarán horas

AtajoQué hace
TabCompleta nombres de carpetas, archivos y comandos. Escribe cd pro + Tab.
↑ / ↓Recorre los comandos que ya escribiste.
Ctrl + CCancela el comando que se está ejecutando.
clear o Ctrl + LLimpia la pantalla.
qSale de una lista larga (Git la usará para mostrarte el historial).

Nano: el editor dentro de la terminal

A veces Git abrirá un editor de texto dentro de la terminal (por ejemplo, para escribir un mensaje largo). Si elegiste Nano, verás los atajos en la parte inferior; ^ significa Ctrl. Pruébalo:

nano notas.txt

Escribe algo, guarda con Ctrl + O y Enter, y sal con Ctrl + X.

ComandoPara quéEjemplo
pwdVer la carpeta actualpwd
ls / ls -aListar (incluidos ocultos)ls -a
cdCambiar de carpetacd proyectos/aroma
mkdirCrear una carpetamkdir css
touchCrear un archivo vacíotouch app.js
echo … >Crear un archivo con textoecho hola > a.txt
catVer el contenido de un archivocat index.html
nanoEditar un archivonano index.html
Regla de oro: antes de cualquier comando de Git, mira en qué carpeta estás con pwd. La mayoría de los errores de principiante («not a git repository») ocurren por estar en la carpeta equivocada.

Practica

BásicoDesde tu carpeta personal, crea la estructura proyectos/tienda con un index.html que diga «Hola», una carpeta js con un app.js vacío, y lista el resultado.

Ver solución 1
mkdir -p proyectos/tienda/js
cd proyectos/tienda
echo "Hola" > index.html
touch js/app.js
ls
ls js
index.html js app.js

mkdir -p crea de una vez las carpetas intermedias que falten.

RetoEstás en ~/proyectos/aroma/css. Llega a ~/Descargas de dos formas: con una ruta relativa y con una que funcione desde cualquier lugar. Comprueba cada llegada con pwd.

Ver solución 2
cd ../../../Descargas
pwd
cd ~/proyectos/aroma/css
cd ~/Descargas
pwd
/home/ana/Descargas /home/ana/Descargas

Cada .. sube un nivel: de css a aroma, a proyectos y a tu carpeta personal. La ruta con ~ no depende de dónde estés.

Puntos clave

  • pwd dice dónde estás; ls -a muestra todo, incluidos los ocultos.
  • cd se mueve; .. sube un nivel y ~ es tu carpeta personal.
  • En la terminal, el silencio significa éxito.
  • Tab autocompleta y ↑ repite comandos: úsalos siempre.

4 · Configuración inicial: identidad, editor y rama main

Básico ~14 min

Cada commit que guardes llevará tu firma: nombre, correo y fecha. Por eso, antes del primer commit hay que presentarse ante Git. Se hace una sola vez por computadora y toma dos minutos.

En este capítulo aprenderás a:

  • configurar tu nombre y correo, que firmarán cada commit;
  • elegir main como nombre de la rama inicial y Nano como editor;
  • consultar tu configuración y saber dónde se guarda;
  • ajustar los saltos de línea según tu sistema operativo.

El aviso que verás si no configuras nada

Mira lo que responde Git 2.56 al crear un repositorio sin haber configurado nada (no te preocupes por git init: lo verás a fondo en el próximo capítulo):

git init prueba
hint: Using 'master' as the name for the initial branch. This default branch name hint: will change to "main" in Git 3.0. To configure the initial branch name hint: to use in all of your new repositories, which will suppress this warning, hint: call: hint: hint: git config --global init.defaultBranch <name> hint: hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and hint: 'development'. The just-created branch can be renamed via this command: hint: hint: git branch -m <name> hint: hint: Disable this message with "git config set advice.defaultBranchName false" Initialized empty Git repository in /home/ana/prueba/.git/

Git te está avisando, en inglés, que usó el nombre master para la rama inicial, que ese nombre cambiará a main en Git 3.0 y que puedes elegir el tuyo con git config --global init.defaultBranch. Hoy casi todos los equipos y GitHub usan main, así que lo configurarás desde ya.

Git habla inglés. Sus mensajes vienen en inglés en Windows y en la mayoría de sistemas. En este curso los verás tal cual y te explicaremos qué dicen: aprender a leerlos es parte del oficio.

Preséntate: nombre, correo, rama y editor

Escribe estos cuatro comandos con tus datos. La opción --global significa «para todos los repositorios de esta computadora»:

git config --global user.name "Ana Torres"
git config --global user.email "ana@aromaypunto.pe"
git config --global init.defaultBranch main
git config --global core.editor "nano"
git config user.name
Ana Torres
git config --global --list
user.name=Ana Torres user.email=ana@aromaypunto.pe init.defaultbranch=main core.editor=nano
ClavePara qué sirve
user.nameTu nombre tal como aparecerá en cada commit.
user.emailTu correo. Usa el mismo de tu cuenta de GitHub para que tus commits se vinculen a tu perfil.
init.defaultBranchNombre de la primera rama de cada repositorio nuevo.
core.editorEl editor que Git abrirá cuando necesite que escribas un texto largo.
¿Te preocupa la privacidad de tu correo? Tus commits son públicos si subes el proyecto a GitHub. GitHub te ofrece una dirección privada del tipo …@users.noreply.github.com (en la configuración de correo de tu cuenta) que puedes usar en user.email.

¿Dónde se guarda todo esto?

La configuración global vive en un archivo de texto en tu carpeta personal. La opción --show-origin te dice de qué archivo sale cada valor:

git config --global --list --show-origin
file:/home/ana/.gitconfig user.name=Ana Torres file:/home/ana/.gitconfig user.email=ana@aromaypunto.pe

Existen tres niveles, y el más específico gana:

NivelOpciónAlcanceArchivo
Sistema--systemTodos los usuarios de la computadoradepende del sistema
Global--globalTodos TUS repositorios~/.gitconfig
Local--local (o nada)Solo el repositorio actual.git/config

Así puedes, por ejemplo, firmar con tu correo personal en general y con el de la empresa solo en los repositorios del trabajo (configurándolo en nivel local dentro de ellos).

Saltos de línea: Windows frente a Linux y macOS

Windows termina cada línea de texto con dos caracteres invisibles (CRLF) y Linux y macOS con uno (LF). Si el equipo mezcla sistemas, Git puede mostrar archivos «cambiados» en los que nadie tocó nada. La opción core.autocrlf lo evita:

# En Windows (el instalador ya lo dejó así si elegiste la opción recomendada):
git config --global core.autocrlf true

# En Linux y macOS:
git config --global core.autocrlf input

Comprueba el resultado

Con la configuración hecha, el mismo git init del inicio ya no muestra el aviso:

git init prueba
Initialized empty Git repository in /home/ana/prueba/.git/
Sintaxis nueva, mismo resultado: desde Git 2.46 también existen git config set, git config get y git config list (el aviso de arriba la usa). En este curso usamos la forma clásica git config --global clave valor porque funciona en cualquier versión.
Regla de oro: configura tu nombre y correo ANTES del primer commit. Corregir la firma de commits ya compartidos con el equipo es complicado; configurarla bien desde el inicio cuesta dos comandos.

Practica

BásicoConfigura a Luis Ramos (luis@aromaypunto.pe) con main como rama inicial, y lee después su nombre y su correo.

Ver solución 1
git config --global user.name "Luis Ramos"
git config --global user.email "luis@aromaypunto.pe"
git config --global init.defaultBranch main
git config user.name
git config user.email
Luis Ramos luis@aromaypunto.pe

Sin valor al final, git config clave LEE en vez de escribir.

RetoAna firma con su correo personal en todos sus proyectos, pero en el repositorio ~/trabajo debe usar ana.torres@empresa.pe. Configúralo solo para ese repositorio y comprueba qué correo usa cada lugar.

Ver solución 2
cd ~/trabajo
git config user.email "ana.torres@empresa.pe"
git config user.email
cd ~
git config user.email
ana.torres@empresa.pe ana@aromaypunto.pe

Sin --global, la configuración se guarda en .git/config del repositorio actual y tiene prioridad sobre la global.

Puntos clave

  • user.name y user.email firman cada commit; usa el correo de tu cuenta de GitHub.
  • init.defaultBranch main: el estándar actual, que Git 3.0 traerá por defecto.
  • --global vale para todos tus repositorios; la configuración local de un repo tiene prioridad.
  • core.autocrlf: true en Windows, input en Linux y macOS.

5 · Tu primer repositorio: git init y la carpeta .git

Básico ~12 min

Hasta ahora aroma es una carpeta común. Para que Git empiece a cuidarla hay que convertirla en un repositorio (o «repo»): una carpeta cuyo historial Git registra. Se hace con un solo comando.

En este capítulo aprenderás a:

  • crear un repositorio con git init;
  • entender qué es la carpeta oculta .git y por qué no se toca;
  • leer tu primer git status;
  • evitar los dos errores clásicos: el repo en el lugar equivocado y el repo dentro de otro repo.

git init: de carpeta a repositorio

Entra a la carpeta del proyecto y ejecuta git init (initialize):

mkdir aroma && cd aroma
git init
Initialized empty Git repository in /home/ana/aroma/.git/

Git responde: «Repositorio de Git vacío creado en /home/ana/aroma/.git/». Gracias a la configuración del capítulo 4, ya no aparece el aviso sobre master.

La carpeta .git: el cerebro del repositorio

Aparentemente nada cambió, pero ls -a revela una carpeta oculta nueva:

ls -a
. .. .git
ls .git
HEAD config description hooks info objects refs
cat .git/HEAD
ref: refs/heads/main
Un repositorio por dentro 📁 aroma 📁 .git 📄 HEAD 📄 config 📁 objects 📁 refs 📄 index.html 📁 css
Fig. 5.1 · Un repositorio es tu carpeta de siempre más la carpeta oculta .git, donde Git guarda todo el historial.

Dentro de .git está todo: los commits, las ramas y la configuración local. Tus archivos de trabajo (index.html, css/…) viven fuera, como siempre. El archivo HEAD dice «estás en la rama main»: lo entenderás a fondo en el capítulo 13.

Dentro de .gitQué guarda
objects/El contenido de cada versión de cada archivo y cada commit, comprimidos.
refs/Las ramas y etiquetas: punteros a commits.
HEADEn qué rama estás trabajando ahora.
configLa configuración de ESTE repositorio (nivel local).
No borres ni edites .git a mano. Si eliminas esa carpeta, pierdes todo el historial: los archivos actuales quedan, pero vuelven a ser una carpeta común. Todo lo que necesites hacer con el historial se hace con comandos de Git.

Tu primer git status

git status es el comando que más usarás: describe la situación del repositorio. Úsalo antes y después de cada paso, como quien mira el retrovisor:

git status
On branch main No commits yet nothing to commit (create/copy files and use "git add" to track)

Traducido: «Estás en la rama main. Todavía no hay commits. No hay nada que guardar (crea o copia archivos y usa git add para que Git los siga)». Git siempre sugiere el siguiente paso: aprende a leer sus pistas.

Error 1: estar en el lugar equivocado

Si ejecutas un comando de Git fuera de un repositorio, Git no sabe qué historial usar y lo dice así:

pwd
/home/ana
git status
fatal: not a git repository (or any of the parent directories): .git

«fatal: no es un repositorio de git (ni ninguna de las carpetas superiores): .git». La solución casi siempre es un cd a la carpeta correcta. Por eso la regla del capítulo 3: mira con pwd dónde estás.

Error 2: un repositorio en tu carpeta personal

Un descuido frecuente es ejecutar git init en ~ en lugar de dentro del proyecto. Entonces todo lo que hay en tu carpeta personal pasa a ser parte de un repositorio gigante, y cada git status lista cientos de archivos. Si te pasa, deshazlo borrando solo esa carpeta .git (no hay historial que perder):

cd ~
ls -a                # confirma que ves .git aquí, donde NO debería estar
rm -rf .git          # elimina SOLO el repositorio accidental

Por la misma razón, no crees un repositorio dentro de otro: un proyecto, un repositorio, en su propia carpeta.

Regla de oro: un proyecto = una carpeta = un repositorio. Ejecuta git init una sola vez, dentro de la carpeta del proyecto, y nunca en tu carpeta personal ni dentro de otro repositorio.

Practica

BásicoCrea la carpeta blog-cafe, conviértela en repositorio y comprueba que existe la carpeta .git y en qué rama estás.

Ver solución 1
mkdir blog-cafe
cd blog-cafe
git init
ls -a
git status
Initialized empty Git repository in /home/ana/blog-cafe/.git/ . .. .git On branch main No commits yet nothing to commit (create/copy files and use "git add" to track)

git init solo crea .git: tus archivos no cambian. La rama es main gracias a la configuración del capítulo 4.

RetoAna ejecutó git init por error en su carpeta personal (~). Compruébalo, deshazlo sin tocar ningún otro archivo y verifica que ~ ya no es un repositorio.

Ver solución 2
cd ~
ls -a
rm -rf .git
git status
. .. .git .gitconfig fatal: not a git repository (or any of the parent directories): .git

Borrar .git elimina SOLO el repositorio accidental (que no tenía historial). El último git status confirma con «not a git repository» que todo volvió a la normalidad.

Puntos clave

  • git init convierte la carpeta actual en un repositorio.
  • Todo el historial vive en la carpeta oculta .git: no se borra ni se edita a mano.
  • git status describe la situación y sugiere el siguiente paso.
  • «not a git repository» = estás fuera del proyecto: revisa con pwd.

6 · Las tres zonas: trabajo, preparación y repositorio

Básico ~15 min

Este es el capítulo más importante de la parte II. Si entiendes las tres zonas por las que pasa un cambio, todos los comandos de Git que vienen después tendrán sentido; si no, parecerán magia.

En este capítulo aprenderás a:

  • nombrar las tres zonas de Git y qué vive en cada una;
  • seguir un cambio desde que editas un archivo hasta que queda en el historial;
  • reconocer los estados de un archivo: sin seguimiento, preparado, guardado y modificado.

Una analogía: la sesión de fotos

Piensa en un fotógrafo de eventos. Las personas se mueven libremente por el salón (eso es tu directorio de trabajo: tus archivos, que editas como quieras). Cuando va a tomar una foto, el fotógrafo elige a quiénes coloca frente a la cámara: eso es el área de preparación. Al disparar, la foto queda para siempre en el álbum: el repositorio.

Las tres zonas de Git Directorio de trabajo tus archivos Área de preparación staging / index Repositorio (.git) historial de commits git add git commit git restore
Fig. 6.1 · Los cambios viajan de izquierda a derecha: editas en el directorio de trabajo, eliges qué guardar con git add y lo guardas en el historial con git commit.
ZonaTambién se llamaQué hay ahíComando que la alimenta
Directorio de trabajoworking directoryTus archivos tal como los ves y editastu editor
Área de preparaciónstaging area o indexLos cambios elegidos para el próximo commitgit add
Repositoriorepository (.git)Todos los commits: el historialgit commit

¿Para qué sirve una zona intermedia?

Podría parecer más simple guardar todo de una vez, pero la preparación te da control. Imagina que en una tarde arreglaste un error en el menú y, además, empezaste un rediseño que aún no funciona. Con el área de preparación guardas SOLO el arreglo en un commit limpio y dejas el rediseño para después. Cada commit cuenta una sola historia, y eso hace el historial fácil de leer y de deshacer.

El viaje completo de un cambio

Sigue el recorrido de index.html en un repositorio recién creado, mirando git status en cada paso:

echo "<h1>Aroma y Punto</h1>" > index.html
git status
On branch main No commits yet Untracked files: (use "git add <file>..." to include in what will be committed) index.html nothing added to commit but untracked files present (use "git add" to track)
git add index.html
git status
On branch main No commits yet Changes to be committed: (use "git rm --cached <file>..." to unstage) new file: index.html
git commit -m "Crea la portada"
[main (root-commit) d077686] Crea la portada 1 file changed, 1 insertion(+) create mode 100644 index.html
git status
On branch main nothing to commit, working tree clean

Lee los mensajes en orden: primero el archivo es Untracked (Git lo ve, pero no lo sigue); después de git add aparece en Changes to be committed (preparado para la foto); tras el commit, working tree clean: el directorio de trabajo coincide con el último commit.

Los estados de un archivo

EstadoQué significaCómo sale de ahí
Sin seguimiento (untracked)Archivo nuevo que Git aún no vigilagit add → preparado
Preparado (staged)Su versión actual irá en el próximo commitgit commit → guardado
Guardado (unmodified)Idéntico a como está en el último commitlo editas → modificado
Modificado (modified)Cambió desde el último commit, pero no está preparadogit add → preparado

El ciclo se repite durante toda la vida del proyecto: editar → preparar → guardar. En los próximos dos capítulos verás cada paso con detalle.

Un detalle que confunde al principio: git add prepara el archivo TAL COMO ESTÁ en ese momento. Si después vuelves a editarlo, el cambio nuevo no entra en el commit hasta que hagas git add otra vez. Lo comprobarás en el capítulo 7.
Regla de oro: nada llega al historial sin pasar por el área de preparación. Antes de cada commit, revisa con git status qué hay en «Changes to be committed»: eso, y solo eso, es lo que guardarás.

Practica

BásicoCrea contacto.html y obsérvalo pasar por los tres estados: sin seguimiento, preparado y guardado. Usa git status -s en cada paso.

Ver solución 1
echo "<h2>Contacto</h2>" > contacto.html
git status -s
git add contacto.html
git status -s
git commit -m "Agrega la página de contacto"
git status -s
?? contacto.html A contacto.html [main (root-commit) 5de0df9] Agrega la página de contacto 1 file changed, 1 insertion(+) create mode 100644 contacto.html

La última orden no imprime nada: con el directorio de trabajo limpio, la forma corta no tiene nada que mostrar.

RetoEn una tarde arreglaste el título de la portada y empezaste galeria.html, que aún no está lista. Guarda SOLO el arreglo en un commit y deja la galería fuera.

Ver solución 2
echo "<h1>Aroma y Punto · Café de origen</h1>" > index.html
echo "<h2>Galería (en construcción)</h2>" > galeria.html
git add index.html
git commit -m "Agrega el lema al título de la portada"
git status -s
[main 1188385] Agrega el lema al título de la portada 1 file changed, 1 insertion(+), 1 deletion(-) ?? galeria.html

Gracias al área de preparación, el commit cuenta una sola historia. La galería sigue como ??, esperando su propio commit.

Puntos clave

  • Tres zonas: directorio de trabajo (editas), área de preparación (eliges) y repositorio (guardas).
  • git add lleva cambios a preparación; git commit los guarda en el historial.
  • Estados: sin seguimiento, preparado, guardado y modificado.
  • La preparación permite commits pequeños que cuentan una sola historia.

7 · git status y git add: preparar los cambios

Básico ~15 min

En el capítulo anterior viste el viaje de un cambio. Ahora aprenderás a dominar los dos comandos del primer tramo: git status, para saber siempre qué está pasando, y git add, para elegir con precisión qué irá en el próximo commit.

En este capítulo aprenderás a:

  • leer git status en su forma larga y en la forma corta -s;
  • preparar un archivo, una carpeta o todo el proyecto con git add;
  • entender que git add prepara una «foto» del archivo en ese instante;
  • conocer git add -p para preparar solo parte de un archivo.

git status, versión larga

Partimos de un repositorio con un commit. Agregamos una línea a la portada y creamos una hoja de estilos:

echo "<p>Café de origen</p>" >> index.html
mkdir css && echo "h1 { color: brown; }" > css/estilos.css
git status
On branch main Changes not staged for commit: (use "git add <file>..." to update what will be committed) (use "git restore <file>..." to discard changes in working directory) modified: index.html Untracked files: (use "git add <file>..." to include in what will be committed) css/ no changes added to commit (use "git add" and/or "git commit -a")

Git separa la información en bloques, y cada uno sugiere qué hacer:

BloqueSignificado
Changes to be committedPreparado: irá en el próximo commit.
Changes not staged for commitModificado, pero todavía no preparado.
Untracked filesArchivos nuevos que Git aún no sigue (aquí, la carpeta css/ completa).

git status -s: la vista de un vistazo

Cuando ya entiendes los bloques, la forma corta es más rápida. Cada línea lleva un código de dos columnas: la izquierda es el área de preparación y la derecha, el directorio de trabajo.

git status -s
M index.html ?? css/
git add css
git status -s
A css/estilos.css M index.html
git add .
git status -s
A css/estilos.css M index.html
CódigoSignificado
??Sin seguimiento: archivo nuevo.
A Archivo nuevo, ya preparado (added).
 MModificado, sin preparar (la M está a la derecha).
M Modificado y preparado (la M pasó a la izquierda).
MMPreparado, y vuelto a modificar después.
 D / D Borrado, sin preparar / preparado.

Las formas de git add

ComandoQué prepara
git add index.htmlUn archivo.
git add cssUna carpeta con todo su contenido.
git add index.html css/estilos.cssVarios archivos a la vez.
git add .Todo lo que cambió en la carpeta actual y sus subcarpetas.
git add -ATodo lo que cambió en el repositorio entero, incluidos los borrados.
git add . es cómodo, pero ciego: prepara TODO, incluido lo que no querías (un archivo de pruebas, una contraseña en un archivo de configuración). Úsalo solo después de mirar git status. En el capítulo 12 aprenderás a que Git ignore para siempre ciertos archivos.

git add prepara una foto del momento

Este es el detalle que anunciamos en el capítulo 6. Preparas el precio, luego cambias de opinión y agregas otra línea. Observa el código MM:

echo "<p>Precio: S/ 25</p>" >> index.html
git add index.html
git status -s
M index.html
echo "<p>Precio: S/ 28</p>" >> index.html
git status -s
MM index.html
git add index.html
git status -s
M index.html

Con MM, Git te avisa que tiene preparada la versión anterior del archivo y que hay cambios más nuevos sin preparar. Si hicieras commit en ese momento, la segunda línea NO entraría. Por eso, después de editar, vuelve a hacer git add.

Preparar solo una parte: git add -p

A veces un mismo archivo tiene dos cambios que pertenecen a commits distintos. Con -p (patch), Git te muestra cada bloque de cambios y te pregunta si lo preparas:

git add -p index.html
TeclaRespuesta
ysí, prepara este bloque
nno, déjalo para después
sdivide el bloque en partes más pequeñas
qsalir
?ayuda con todas las opciones
Regla de oro: git status antes de git add, y git status otra vez antes de git commit. Dos segundos de revisión evitan commits con archivos equivocados.

Practica

BásicoModifica index.html, crea js/app.js y explica cada código de git status -s. Luego prepáralo todo de una vez y vuelve a mirar.

Ver solución 1
echo "<footer>Lima</footer>" >> index.html
mkdir js && echo "console.log('hola')" > js/app.js
git status -s
git add .
git status -s
M index.html ?? js/ M index.html A js/app.js

Antes:  M (modificado sin preparar) y ?? (nuevo). Después: M  y A : la letra pasó a la columna izquierda, la de preparación.

RetoPrepara un cambio en index.html, vuelve a editarlo y demuestra con git status -s que el commit solo llevaría la primera versión. Corrígelo y haz el commit.

Ver solución 2
echo "<p>Envíos a Lima</p>" >> index.html
git add index.html
echo "<p>Envíos a todo el Perú</p>" >> index.html
git status -s
git add index.html
git status -s
git commit -m "Agrega la información de envíos"
MM index.html M index.html [main 4a763f1] Agrega la información de envíos 1 file changed, 2 insertions(+)

MM = hay una versión preparada y cambios más nuevos sin preparar. El segundo git add actualiza la foto.

Puntos clave

  • En git status -s, la columna izquierda es preparación y la derecha, el directorio de trabajo.
  • git add acepta archivos, carpetas, . (todo aquí) y -A (todo el repo).
  • git add prepara el archivo tal como está AHORA; si lo editas otra vez, repite el add.
  • git add -p prepara solo los bloques que elijas.

8 · git commit: guardar fotos con mensaje

Básico ~16 min

Con los cambios preparados, toca tomar la foto. Un commit guarda en el historial todo lo que está en el área de preparación, junto con tu firma, la fecha y un mensaje que explica el cambio.

En este capítulo aprenderás a:

  • crear commits con git commit -m e interpretar lo que responde Git;
  • escribir mensajes claros, con título y descripción;
  • usar el editor para mensajes largos y el atajo -a con sus límites;
  • decidir qué cabe en un commit: un cambio, una idea.

Tu primer commit

git commit -m "Crea la portada"
[main (root-commit) d077686] Crea la portada 1 file changed, 1 insertion(+) create mode 100644 index.html

Cada parte de la respuesta tiene significado:

FragmentoSignificado
mainLa rama donde quedó el commit.
root-commitEs el primer commit del repositorio (no tiene padre).
d077686Los primeros caracteres del hash: el identificador único del commit.
1 file changed, 1 insertion(+)Resumen: un archivo cambió y se agregó una línea.
create mode 100644 index.htmlEl archivo es nuevo en el historial (100644 = archivo normal).
¿Por qué tu hash será distinto? El hash se calcula a partir del contenido, el autor, la fecha y el commit anterior. Como tu nombre y tu hora no son los de Ana, tus hashes no coincidirán con los del manual, y está bien.
Tres commits en la rama main d077686 … … main HEAD portada menú precios
Fig. 8.1 · Cada commit apunta al anterior. La etiqueta main marca el más reciente y HEAD indica dónde estás. Al hacer un commit nuevo, main avanza sola.

Mensajes que se entienden meses después

El mensaje es para tu equipo y para tu «yo» del futuro. Debe decir qué hace el cambio y, si no es obvio, por qué. Con -m dos veces escribes título y descripción:

git add menu.html
git commit -m "Agrega el menú de bebidas" -m "Incluye solo el espresso; los precios de julio llegan con el pedido del proveedor."
[main a18134a] Agrega el menú de bebidas 1 file changed, 1 insertion(+) create mode 100644 menu.html
git log -1
commit a18134afbf6633ba7efce7cdf8b350a9555b280c (HEAD -> main) Author: Ana Torres <ana@aromaypunto.pe> Date: Wed Jul 15 09:02:00 2026 -0500 Agrega el menú de bebidas Incluye solo el espresso; los precios de julio llegan con el pedido del proveedor.
Mal mensajeBuen mensaje
cambiosCorrige el precio del capuchino en el menú
arreglé cosasEvita que el formulario se envíe con el correo vacío
wipAgrega la galería de fotos de la cafetería
final finalReemplaza el logo por la versión en SVG

La convención más usada: título de hasta unos 50 caracteres, que empieza con un verbo (Agrega, Corrige, Elimina, Actualiza), sin punto final; luego una línea en blanco y, si hace falta, el detalle.

Mensajes largos con el editor

Si escribes git commit sin -m, Git abre el editor que configuraste (Nano). Escribe el título en la primera línea, deja una línea en blanco y luego la descripción. Guarda con Ctrl+O y Enter, y sal con Ctrl+X: en ese momento se crea el commit.

git commit
¿Te arrepentiste? Si sales del editor sin escribir nada, Git cancela el commit («Aborting commit due to empty commit message»). No se pierde nada: tus cambios siguen preparados.

El atajo -a y su trampa

git commit -a prepara y guarda en un solo paso todos los archivos que Git ya seguía. Observa qué pasa con un archivo nuevo:

echo "<p>Abierto de 8:00 a 20:00</p>" >> index.html
echo "Notas internas" > pendientes.txt
git commit -a -m "Agrega el horario de atención"
[main 88e21cf] Agrega el horario de atención 1 file changed, 1 insertion(+)
git status -s
?? pendientes.txt

El horario entró en el commit, pero pendientes.txt sigue con ??: -a nunca incluye archivos nuevos. Úsalo con cuidado y solo cuando sepas qué cambió.

Cuando no hay nada que guardar

git commit -m "Intento sin cambios"
On branch main nothing to commit, working tree clean

Si no preparaste nada, Git no crea un commit vacío y te recuerda en qué estado estás.

¿Qué tamaño debe tener un commit?

Un commit debe contener un cambio con sentido propio: «agrega el menú», «corrige el precio». Si para describirlo necesitas la palabra «y» («agrega el menú y cambia los colores y arregla el pie»), probablemente son tres commits. Los commits pequeños se revisan, se entienden y se deshacen con facilidad.

Regla de oro: un commit = una idea. Si el mensaje necesita un «y», divídelo en varios commits usando el área de preparación.

Practica

BásicoCrea nosotros.html y guárdalo con un commit que tenga título y descripción. Comprueba el resultado con git log -1.

Ver solución 1
echo "<h2>Nuestra historia</h2>" > nosotros.html
git add nosotros.html
git commit -m "Agrega la página Nosotros" -m "Cuenta el origen de la cafetería; las fotos llegarán en otro commit."
git log -1
[main 445dbd2] Agrega la página Nosotros 1 file changed, 1 insertion(+) create mode 100644 nosotros.html commit 445dbd2714a32608a02eec23ec367c8a2f0d91cf (HEAD -> main) Author: Ana Torres <ana@aromaypunto.pe> Date: Wed Jul 15 09:02:00 2026 -0500 Agrega la página Nosotros Cuenta el origen de la cafetería; las fotos llegarán en otro commit.

Cada -m es un párrafo: el primero es el título y el segundo, la descripción.

RetoModificaste index.html y creaste precios.html. Un compañero hizo git commit -a y dice que guardó todo. Demuéstrale qué quedó fuera y guárdalo en un segundo commit.

Ver solución 2
echo "<p>Nuevo horario</p>" >> index.html
echo "<h2>Precios</h2>" > precios.html
git commit -a -m "Actualiza el horario"
git status -s
git add precios.html
git commit -m "Agrega la página de precios"
[main 9e7f67b] Actualiza el horario 1 file changed, 1 insertion(+) ?? precios.html [main 2896f35] Agrega la página de precios 1 file changed, 1 insertion(+) create mode 100644 precios.html

-a solo incluye archivos que Git ya seguía. Los nuevos siempre necesitan un git add explícito.

Puntos clave

  • git commit -m "mensaje" guarda lo preparado; la respuesta muestra rama, hash y resumen.
  • Buen mensaje: verbo al inicio, qué hace el cambio y, si hace falta, por qué.
  • Sin -m se abre el editor; un mensaje vacío cancela el commit.
  • -a incluye lo modificado ya seguido, nunca los archivos nuevos.

9 · Leer la historia: git log y git show

Básico ~16 min

Ya tienes varios commits. Ahora aprenderás a leer el historial como un libro: qué se hizo, quién lo hizo, cuándo y qué cambió exactamente. Es la habilidad que te salvará cuando el cliente pregunte «¿desde cuándo el espresso cuesta 8 soles?».

En este capítulo aprenderás a:

  • listar el historial con git log y sus vistas compactas;
  • filtrar commits por archivo, por palabra del mensaje o por cantidad;
  • ver el detalle de un commit con git show;
  • nombrar commits con HEAD, HEAD~1, HEAD~2…

git log: el historial completo

En el repositorio de práctica hay cuatro commits. git log los muestra del más reciente al más antiguo:

git log
commit 3471a29f8292e88e3bffcf4fdb25129a19188c24 (HEAD -> main) Author: Ana Torres <ana@aromaypunto.pe> Date: Wed Jul 15 09:04:00 2026 -0500 Actualiza el precio del espresso commit 8a4c569ed7064e6ec4e4ed500c735461e9bc7179 Author: Ana Torres <ana@aromaypunto.pe> Date: Wed Jul 15 09:03:00 2026 -0500 Agrega la hoja de estilos commit dda32febd9ef239b3b4c75817ca5c7e681015fb3 Author: Ana Torres <ana@aromaypunto.pe> Date: Wed Jul 15 09:02:00 2026 -0500 Agrega el menú de bebidas commit d077686e0d3d4616ab5d86904e314473cf265a8e Author: Ana Torres <ana@aromaypunto.pe> Date: Wed Jul 15 09:01:00 2026 -0500 Crea la portada

Cada bloque es un commit: el hash completo (40 caracteres), el autor, la fecha y el mensaje. (HEAD -> main) señala dónde estás: en la rama main, en su último commit.

Si el historial es largo, Git lo muestra página por página. Avanza con Espacio, retrocede con b y sal con q (lo viste en el capítulo 3).

Vistas compactas

Casi siempre basta una línea por commit: los 7 primeros caracteres del hash, que lo identifican, y el título.

git log --oneline
3471a29 (HEAD -> main) Actualiza el precio del espresso 8a4c569 Agrega la hoja de estilos dda32fe Agrega el menú de bebidas d077686 Crea la portada
git log --oneline -2
3471a29 (HEAD -> main) Actualiza el precio del espresso 8a4c569 Agrega la hoja de estilos

Con --stat además ves qué archivos tocó cada commit:

git log --oneline --stat -2
3471a29 (HEAD -> main) Actualiza el precio del espresso menu.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 8a4c569 Agrega la hoja de estilos css/estilos.css | 1 + 1 file changed, 1 insertion(+)
Nombres relativos de los commits d077686 dda32fe 8a4c569 3471a29 main HEAD HEAD~3 HEAD~2 HEAD~1 HEAD
Fig. 9.1 · HEAD es el commit donde estás; HEAD~1, el anterior; HEAD~2, dos atrás. Así nombras commits sin copiar su hash.

Buscar en el historial

git log --oneline -- menu.html
3471a29 (HEAD -> main) Actualiza el precio del espresso dda32fe Agrega el menú de bebidas
git log --oneline --grep="precio"
3471a29 (HEAD -> main) Actualiza el precio del espresso
git log --format="%h · %an · %ad · %s" --date=short -2
3471a29 · Ana Torres · 2026-07-15 · Actualiza el precio del espresso 8a4c569 · Ana Torres · 2026-07-15 · Agrega la hoja de estilos
OpciónMuestra
-n (por ejemplo -2)Solo los n commits más recientes
-- archivoSolo los commits que tocaron ese archivo
--grep="texto"Los commits cuyo mensaje contiene el texto
--author="Ana"Los commits de una persona
--since="2 weeks ago"Los commits de un periodo
--format="%h %an %ad %s"Tu propio formato: hash, autor, fecha y título
--date=shortFechas cortas (2026-07-15); --date=relative dice «hace 3 días»

En --format, cada % es un dato: %h hash corto, %an autor, %ad fecha y %s título.

git show: el detalle de un commit

git show muestra la información del commit y las líneas exactas que cambió: con - lo que se quitó y con + lo que se agregó. Sin argumentos muestra HEAD:

git show HEAD
commit 3471a29f8292e88e3bffcf4fdb25129a19188c24 (HEAD -> main) Author: Ana Torres <ana@aromaypunto.pe> Date: Wed Jul 15 09:04:00 2026 -0500 Actualiza el precio del espresso diff --git a/menu.html b/menu.html index 3326199..0cd3e17 100644 --- a/menu.html +++ b/menu.html @@ -1 +1 @@ -<ul><li>Espresso S/ 7</li></ul> +<ul><li>Espresso S/ 8</li></ul>
git show --stat --oneline HEAD~2
dda32fe Agrega el menú de bebidas menu.html | 1 + 1 file changed, 1 insertion(+)

En el próximo capítulo aprenderás a leer este formato de diferencias con calma.

Regla de oro: cuando algo «se rompió», no adivines: git log --oneline -- archivo te dice qué commits lo tocaron y git show te enseña qué cambió cada uno.

Practica

BásicoMuestra los últimos 3 commits en una línea cada uno y, después, solo los que tocaron menu.html.

Ver solución 1
git log --oneline -3
git log --oneline -- menu.html
361068e (HEAD -> main) Agrega la página de contacto 3471a29 Actualiza el precio del espresso 8a4c569 Agrega la hoja de estilos 3471a29 Actualiza el precio del espresso dda32fe Agrega el menú de bebidas

-- archivo va siempre al final: separa las opciones de los nombres de archivo.

RetoEl cliente pregunta: «¿desde cuándo el espresso cuesta 8 soles y quién lo cambió?». Encuentra el commit buscando «precio» en los mensajes y muestra su autor, su fecha y la línea exacta que cambió.

Ver solución 2
git log --oneline --grep="precio"
git show HEAD~1
3471a29 Actualiza el precio del espresso commit 3471a29f8292e88e3bffcf4fdb25129a19188c24 Author: Ana Torres <ana@aromaypunto.pe> Date: Wed Jul 15 09:04:00 2026 -0500 Actualiza el precio del espresso diff --git a/menu.html b/menu.html index 3326199..0cd3e17 100644 --- a/menu.html +++ b/menu.html @@ -1 +1 @@ -<ul><li>Espresso S/ 7</li></ul> +<ul><li>Espresso S/ 8</li></ul>

Primero ubicas el commit con --grep y luego lo abres con git show. Como es el penúltimo, también puedes nombrarlo HEAD~1 o con su hash.

Puntos clave

  • git log lista los commits del más reciente al más antiguo; --oneline los resume.
  • (HEAD -> main) indica en qué rama y commit estás.
  • Filtra con -n, -- archivo, --grep y --author.
  • git show muestra un commit con sus cambios; HEAD~1 es el commit anterior.

10 · ¿Qué cambió? git diff en sus tres sabores

Básico ~16 min

Antes de guardar un commit conviene revisar exactamente qué cambiaste. Un espacio de más, una línea borrada por accidente o una contraseña olvidada se detectan en segundos con git diff.

En este capítulo aprenderás a:

  • leer el formato de diferencias de Git (- y +);
  • ver lo que aún no preparaste, lo que ya preparaste y lo que cambió entre commits;
  • resumir cambios con --stat y verlos por palabras con --word-diff.

Sabor 1 · git diff: lo que cambiaste y aún no preparaste

Cambiamos el lema de la portada. git status solo dice que el archivo cambió; git diff dice qué cambió:

git status -s
M index.html
git diff
diff --git a/index.html b/index.html index c6b5590..a9d7f8f 100644 --- a/index.html +++ b/index.html @@ -1,2 +1,2 @@ <h1>Aroma y Punto</h1> -<p>Café de origen</p> +<p>Café de especialidad</p>

Así se lee:

LíneaSignificado
diff --git a/index.html b/index.htmlSe compara la versión «a» (antes) con la «b» (después) de index.html.
--- a/… / +++ b/…Las marcas que usará cada versión: - antes, + después.
@@ -1,2 +1,2 @@Ubicación: desde la línea 1, 2 líneas antes y 2 líneas después.
línea con espacio inicialContexto: no cambió, se muestra para ubicarte.
línea con -Se quitó.
línea con +Se agregó.

Git no «edita» líneas: una línea cambiada aparece como una que se quitó (-) y otra que se agregó (+).

Qué compara cada git diff Directorio de trabajo tus archivos Área de preparación staging / index Repositorio (.git) historial de commits diff diff --staged
Fig. 10.1 · git diff compara el directorio de trabajo con la preparación; git diff --staged, la preparación con el último commit.

Sabor 2 · git diff --staged: lo que irá en el commit

Al preparar el archivo, git diff queda vacío: ya no hay diferencia entre el directorio de trabajo y la preparación. Para ver lo que guardará el próximo commit se usa --staged:

git add index.html
git diff
git diff --staged
diff --git a/index.html b/index.html index c6b5590..a9d7f8f 100644 --- a/index.html +++ b/index.html @@ -1,2 +1,2 @@ <h1>Aroma y Punto</h1> -<p>Café de origen</p> +<p>Café de especialidad</p>
¿--staged o --cached? Son sinónimos: verás ambos en internet. --staged se entiende mejor.

Sabor 3 · diferencias entre commits

Con dos nombres de commit comparas cualquier par de fotos del historial. --stat resume y --word-diff marca solo las palabras que cambiaron (útil en textos largos):

git diff HEAD~1 HEAD
diff --git a/index.html b/index.html index c6b5590..a9d7f8f 100644 --- a/index.html +++ b/index.html @@ -1,2 +1,2 @@ <h1>Aroma y Punto</h1> -<p>Café de origen</p> +<p>Café de especialidad</p>
git diff HEAD~2 HEAD --stat
index.html | 2 +- menu.html | 1 + 2 files changed, 2 insertions(+), 1 deletion(-)
git diff --word-diff HEAD~1 HEAD
diff --git a/index.html b/index.html index c6b5590..a9d7f8f 100644 --- a/index.html +++ b/index.html @@ -1,2 +1,2 @@ <h1>Aroma y Punto</h1> <p>Café de [-origen</p>-]{+especialidad</p>+}

En --word-diff, lo que está entre [-…-] se quitó y lo que está entre {+…+} se agregó.

Quieres ver…Comando
Lo que cambiaste y no preparastegit diff
Lo que ya preparaste (irá al commit)git diff --staged
Todo lo que cambió desde el último commitgit diff HEAD
Lo que hizo un commitgit show <commit> o git diff HEAD~1 HEAD
Solo un archivoagrega -- archivo al final
Regla de oro: antes de cada commit, lee git diff --staged de principio a fin. Es tu última oportunidad de ver lo que tus compañeros verán.

Practica

BásicoCambia el color del título en css/estilos.css a darkred y revisa el cambio antes y después de prepararlo.

Ver solución 1
sed -i "s/brown/darkred/" css/estilos.css
git diff
git add css/estilos.css
git diff
git diff --staged
diff --git a/css/estilos.css b/css/estilos.css index 5be04d5..c98e83a 100644 --- a/css/estilos.css +++ b/css/estilos.css @@ -1 +1 @@ -h1 { color: brown; } +h1 { color: darkred; } diff --git a/css/estilos.css b/css/estilos.css index 5be04d5..c98e83a 100644 --- a/css/estilos.css +++ b/css/estilos.css @@ -1 +1 @@ -h1 { color: brown; } +h1 { color: darkred; }

Después del git add, git diff queda vacío: el cambio ya está en la preparación, y solo --staged lo muestra.

RetoMuestra un resumen de todo lo que cambió entre el primer commit y el último (archivos y líneas), sin ver el detalle.

Ver solución 2
git diff HEAD~4 HEAD --stat
contacto.html | 1 + css/estilos.css | 1 + menu.html | 1 + 3 files changed, 3 insertions(+)

Hay 5 commits: el primero es HEAD~4. También podrías usar su hash. --stat es ideal para revisar rápido qué tocó una entrega completa.

Puntos clave

  • - se quitó, + se agregó; las demás líneas son contexto.
  • git diff: trabajo vs. preparación. git diff --staged: preparación vs. último commit.
  • git diff A B compara dos commits; --stat resume y --word-diff marca palabras.

11 · Deshacer sin miedo: restore y commit --amend

Intermedio ~18 min

Equivocarse es parte del trabajo. Lo bueno de Git es que casi todo error tiene vuelta atrás. En este capítulo aprenderás a deshacer los errores más comunes del día a día, antes de compartir tu trabajo con el equipo.

En este capítulo aprenderás a:

  • descartar cambios de un archivo con git restore;
  • sacar un archivo del área de preparación con git restore --staged;
  • recuperar la versión de un archivo de cualquier commit anterior;
  • corregir el último commit con git commit --amend.

Descartar cambios que no quieres

Pegaste texto por error en menu.html y quieres que vuelva a estar como en el último commit. git restore lo devuelve (fíjate que git status ya lo sugería):

echo "texto pegado por error" >> menu.html
git status -s
M menu.html
git restore menu.html
git status -s
cat menu.html
<ul><li>Espresso S/ 7</li></ul>
Esto no tiene vuelta atrás. git restore archivo borra los cambios que no guardaste en ningún commit. Git nunca los vio, así que no puede recuperarlos. Mira git diff archivo antes de descartar.

Sacar un archivo de la preparación

Preparaste un cambio que todavía no debía ir en el commit. --staged lo devuelve al directorio de trabajo sin perderlo:

echo "<p>Promoción secreta</p>" >> index.html
git add index.html
git status -s
M index.html
git restore --staged index.html
git status -s
M index.html

La M pasó de la columna izquierda (preparado) a la derecha (modificado): el cambio sigue ahí, solo que ya no irá en el commit.

Volver a la versión de cualquier día

¿Recuerdas al cliente del capítulo 1 que prefería la versión del martes? Con --source traes un archivo tal como estaba en cualquier commit. Aquí recuperamos el precio anterior del espresso:

git log --oneline
6f131fb (HEAD -> main) Sube el precio del espresso adcd552 Agrega el menú de bebidas a12acca Crea la portada
cat menu.html
<ul><li>Espresso S/ 9</li></ul>
git restore --source=HEAD~1 menu.html
cat menu.html
<ul><li>Espresso S/ 7</li></ul>
git status -s
M menu.html

El historial no se tocó: el archivo recuperado aparece como modificado y decides si guardarlo con un commit nuevo.

Corregir el último commit: --amend

Te faltó una palabra en el mensaje. --amend reemplaza el último commit por uno corregido:

git commit -am "Cambia el lema"
[main d2f3c70] Cambia el lema 1 file changed, 1 insertion(+), 1 deletion(-)
git commit --amend -m "Cambia el lema de la portada"
[main e2d8054] Cambia el lema de la portada Date: Wed Jul 15 09:03:00 2026 -0500 1 file changed, 1 insertion(+), 1 deletion(-)
git log --oneline
e2d8054 (HEAD -> main) Cambia el lema de la portada adcd552 Agrega el menú de bebidas a12acca Crea la portada

Observa que el hash cambió: --amend no edita el commit, crea uno nuevo que toma su lugar. También sirve para agregar un archivo olvidado sin cambiar el mensaje:

echo "Jr. Unión 120" > contacto.html
git add contacto.html
git commit --amend --no-edit
[main 5d0efd9] Cambia el lema de la portada Date: Wed Jul 15 09:03:00 2026 -0500 2 files changed, 2 insertions(+), 1 deletion(-) create mode 100644 contacto.html
git log --oneline --stat -1
5d0efd9 (HEAD -> main) Cambia el lema de la portada contacto.html | 1 + index.html | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-)
Solo con commits que no compartiste. Como --amend reemplaza el commit, si ya lo subiste a GitHub tus compañeros tendrán una versión distinta de la historia. Para commits compartidos existe git revert (capítulo 30).

¿Qué quiero deshacer?

SituaciónComando¿Se pierde algo?
Cambios que no preparé ni guardégit restore archivoSí: esos cambios
Preparé algo por errorgit restore --staged archivoNo
Quiero el archivo como en un commit anteriorgit restore --source=HEAD~1 archivoLos cambios sin guardar de ese archivo
El mensaje del último commit está malgit commit --amend -m "…"No
Olvidé un archivo en el último commitgit add archivo + git commit --amend --no-editNo
Un commit ya compartido estaba malgit revert (capítulo 30)No
¿Y git checkout? En tutoriales antiguos verás git checkout -- archivo para descartar cambios. Funciona, pero desde Git 2.23 existe git restore, que hace solo eso y es más difícil de confundir.
Regla de oro: antes de deshacer, pregúntate «¿esto ya lo compartí?». Si no, restore y --amend son seguros; si sí, no reescribas la historia: agrega un commit que corrija.

Practica

BásicoBorraste por accidente todo el contenido de contacto.html. Recupéralo tal como estaba en el último commit.

Ver solución 1
echo "" > contacto.html
git diff --stat
git restore contacto.html
cat contacto.html
contacto.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) <p>Jr. Unión 120</p>

Como el contenido original estaba guardado en un commit, git restore lo trae de vuelta.

RetoHiciste un commit de nosotros.html con el mensaje «nosotros» y olvidaste la foto equipo.txt. Corrige el último commit para que incluya la foto y tenga un mensaje claro, sin crear un commit extra.

Ver solución 2
echo "<h2>Nosotros</h2>" > nosotros.html
git add nosotros.html && git commit -m "nosotros"
echo "foto del equipo" > equipo.txt
git add equipo.txt
git commit --amend -m "Agrega la página Nosotros con la foto del equipo"
git log --oneline -2 --stat
[main fb584a0] nosotros 1 file changed, 1 insertion(+) create mode 100644 nosotros.html [main 35d3b8e] Agrega la página Nosotros con la foto del equipo Date: Wed Jul 15 09:06:00 2026 -0500 2 files changed, 2 insertions(+) create mode 100644 equipo.txt create mode 100644 nosotros.html 35d3b8e (HEAD -> main) Agrega la página Nosotros con la foto del equipo equipo.txt | 1 + nosotros.html | 1 + 2 files changed, 2 insertions(+) 361068e Agrega la página de contacto contacto.html | 1 + 1 file changed, 1 insertion(+)

Un solo --amend agrega el archivo y cambia el mensaje. Es seguro porque el commit aún no se compartió.

Puntos clave

  • git restore archivo descarta cambios no guardados (sin vuelta atrás).
  • git restore --staged archivo saca un archivo de la preparación sin perder el cambio.
  • git restore --source=<commit> archivo trae la versión de cualquier commit.
  • git commit --amend reemplaza el último commit: úsalo solo si no lo compartiste.

12 · .gitignore: lo que nunca debe entrar

Básico ~16 min

No todo lo que hay en la carpeta del proyecto debe guardarse en el historial. Las librerías descargadas, los registros de errores, los archivos del sistema y, sobre todo, las contraseñas deben quedar fuera. El archivo .gitignore le dice a Git qué ignorar.

En este capítulo aprenderás a:

  • escribir un .gitignore con nombres, carpetas y comodines;
  • hacer excepciones con ! y comprobar reglas con git check-ignore;
  • dejar de seguir un archivo que ya estaba en el historial;
  • evitar el error más caro: subir una contraseña.

El problema: ruido y secretos

En un proyecto real aparecen archivos que nadie escribió a mano. Mira cuántos nuevos ve Git:

git status -s
?? .DS_Store ?? .env ?? debug.log ?? logs/ ?? node_modules/

De todo eso, solo tu código merece estar en el historial. node_modules/ puede pesar cientos de megas y cualquiera lo reinstala con un comando; los .log cambian a cada rato; .DS_Store es basura de macOS; y .env tiene una contraseña.

Escribir el .gitignore

Es un archivo de texto en la raíz del proyecto, con una regla por línea; las que empiezan con # son comentarios. Puedes crearlo con nano .gitignore; aquí lo creamos con cat > archivo << 'FIN', que escribe todas las líneas hasta la palabra FIN:

cat > .gitignore << 'FIN'
# Dependencias (se instalan con npm)
node_modules/

# Secretos
.env

# Registros
*.log
logs/

# Archivos del sistema
.DS_Store
FIN
cat .gitignore
# Dependencias (se instalan con npm) node_modules/ # Secretos .env # Registros *.log logs/ # Archivos del sistema .DS_Store
git status -s
?? .gitignore

Ahora Git solo muestra el propio .gitignore, que sí se guarda en el repositorio para que todo el equipo use las mismas reglas.

ReglaIgnora
.envel archivo .env, en cualquier carpeta
node_modules/esa carpeta completa (la barra final indica carpeta)
*.logtodo archivo que termine en .log
/notas.txtsolo el notas.txt de la raíz del proyecto
docs/*.pdflos PDF dentro de docs (no los de subcarpetas)
!importante.logexcepción: NO ignorar este archivo

Excepciones y comprobación

Es buena práctica compartir un .env.ejemplo con los nombres de las variables (sin valores reales) para que el equipo sepa qué configurar. Ignoramos .env* y hacemos una excepción con !. git check-ignore -v dice qué regla ignora cada archivo:

echo "DB_CLAVE=" > .env.ejemplo
echo '!.env.ejemplo' >> .gitignore
sed -i 's/^.env$/.env*/' .gitignore
cat .gitignore
node_modules/ .env* *.log logs/ .DS_Store !.env.ejemplo
git status -s
?? .env.ejemplo ?? .gitignore
git check-ignore -v .env debug.log
.gitignore:2:.env* .env .gitignore:3:*.log debug.log

La salida indica archivo de reglas, número de línea, regla y archivo ignorado: por ejemplo, .env lo ignora la línea 2 (.env*).

Llegaste tarde: el archivo ya estaba en el historial

.gitignore solo afecta a archivos que Git todavía no sigue. Si un archivo ya entró en un commit, agregarlo después al .gitignore no sirve: Git lo sigue vigilando. git rm --cached lo saca del repositorio pero lo deja en tu disco:

echo "config.local" > .gitignore
echo "API_KEY=xyz789" > config.local
git status -s
M config.local ?? .gitignore
git rm --cached config.local
rm 'config.local'
git add .gitignore
git status -s
A .gitignore D config.local
git commit -m "Deja de seguir config.local y lo ignora"
[main ef0a496] Deja de seguir config.local y lo ignora 2 files changed, 1 insertion(+), 1 deletion(-) create mode 100644 .gitignore delete mode 100644 config.local
git status -s
Si lo que subiste era una contraseña, cámbiala. Dejar de seguir el archivo no lo borra de los commits anteriores: cualquiera con acceso al historial puede leerla. Si el repositorio llegó a GitHub, considera esa clave comprometida y genera otra.

Plantillas y reglas globales

No tienes que inventar las reglas: GitHub mantiene plantillas para cada lenguaje en github.com/github/gitignore (Node, Python, Laravel…). Y lo que es de TU computadora (como .DS_Store o Thumbs.db) puede ir en un .gitignore global, que aplica a todos tus repositorios:

echo ".DS_Store" >> ~/.gitignore_global
echo "Thumbs.db" >> ~/.gitignore_global
git config --global core.excludesFile ~/.gitignore_global
Regla de oro: crea el .gitignore en el primer commit del proyecto, antes de que exista cualquier secreto. Las contraseñas viven en .env, y .env nunca entra al repositorio.

Practica

BásicoEl proyecto ahora tiene vendor/ (librerías de PHP), secretos.txt y archivos .tmp. Escribe un .gitignore que los ignore y comprueba que Git solo vea el .gitignore.

Ver solución 1
git status -s
cat > .gitignore << 'FIN'
vendor/
secretos.txt
*.tmp
FIN
git status -s
?? cache.tmp ?? secretos.txt ?? vendor/ ?? .gitignore

Fíjate en que vendor/ se ignora completa gracias a la barra final.

RetoUn compañero subió token.txt al repositorio. Haz que Git deje de seguirlo sin borrarlo de tu disco, que lo ignore en adelante y comprueba qué regla lo ignora.

Ver solución 2
echo "token.txt" >> .gitignore
git rm --cached token.txt
git add .gitignore
git commit -m "Deja de seguir token.txt y lo ignora"
ls
git check-ignore -v token.txt
rm 'token.txt' [main aadabd6] Deja de seguir token.txt y lo ignora 2 files changed, 1 insertion(+), 1 deletion(-) create mode 100644 .gitignore delete mode 100644 token.txt contacto.html css index.html menu.html token.txt .gitignore:1:token.txt token.txt

El archivo sigue en tu disco (ls), pero ya no en los commits nuevos. El token sigue legible en commits antiguos: si el repo se compartió, hay que generar uno nuevo.

Puntos clave

  • .gitignore lista lo que Git no debe seguir; él mismo sí se guarda en el repositorio.
  • Reglas: nombres, carpetas con / final, comodines * y excepciones con !.
  • git check-ignore -v archivo dice qué regla lo ignora.
  • Si el archivo ya estaba seguido: git rm --cached archivo (y cambia la clave si era un secreto).

13 · Qué es una rama de verdad: punteros y HEAD

Intermedio ~15 min

Las ramas son la característica que hace a Git tan útil en equipo: permiten trabajar en una idea nueva sin tocar lo que ya funciona. Antes de usarlas, en este capítulo entenderás qué son de verdad. Spoiler: son mucho más simples de lo que parecen.

En este capítulo aprenderás a:

  • entender que una rama es solo una etiqueta móvil que apunta a un commit;
  • saber qué es HEAD y cómo indica dónde estás;
  • listar y crear ramas con git branch.

Para qué sirven las ramas

Imagina que la web de «Aroma y Punto» está publicada y funciona. El cliente pide una carta de postres, que te tomará varios días. Si la construyes directamente en main, la versión publicada queda a medias hasta que termines. Con una rama, haces la carta en una línea de trabajo paralela; main sigue intacta y, cuando la carta esté lista, juntas ambas líneas.

Ya estabas en una rama

Desde tu primer commit trabajas en la rama main. git branch lista las ramas y marca con * la actual:

git branch
* main
git log --oneline
8a4c569 (HEAD -> main) Agrega la hoja de estilos dda32fe Agrega el menú de bebidas d077686 Crea la portada
La rama main es un puntero al último commit d077686 dda32fe 8a4c569 main HEAD
Fig. 13.1 · main no «contiene» commits: es una etiqueta que apunta a uno. HEAD apunta a la rama en la que estás.

Una rama es un puntero

Este es el secreto: una rama no es una copia de tus archivos. Es un archivo diminuto que guarda el hash de un commit. Míralo tú mismo:

cat .git/HEAD
ref: refs/heads/main
cat .git/refs/heads/main
8a4c569ed7064e6ec4e4ed500c735461e9bc7179

HEAD dice «estoy en la rama main» y el archivo de la rama main contiene el hash 8a4c569…, su último commit. Cada vez que haces un commit, Git mueve la etiqueta de la rama actual al commit nuevo. Por eso crear una rama es instantáneo, aunque el proyecto tenga miles de archivos.

ConceptoQué esAnalogía
CommitUna foto del proyectoUna parada del camino
RamaUna etiqueta móvil que apunta a un commitEl marcador de una línea de bus: avanza con cada parada
HEADLa rama (o commit) donde estás ahoraEl cartel «usted está aquí» de un mapa

Crear una rama

git branch nombre crea una etiqueta nueva sobre el commit actual:

git branch postres
git branch
* main postres
git log --oneline -1
8a4c569 (HEAD -> main, postres) Agrega la hoja de estilos
Crear una rama agrega otra etiqueta d077686 dda32fe 8a4c569 main postres HEAD
Fig. 13.2 · Tras git branch postres hay dos etiquetas sobre el mismo commit. HEAD sigue en main: crear una rama no te mueve a ella.

Lee la decoración de git log: (HEAD -> main, postres) significa que HEAD apunta a main y que postres está en el mismo commit. La rama existe, pero todavía estás en main: en el próximo capítulo aprenderás a moverte.

¿Y si HEAD no apunta a una rama? Puede apuntar directamente a un commit (se llama «HEAD separado» o detached HEAD). Pasa, por ejemplo, al revisar un commit antiguo. Lo importante: los commits que hagas ahí no pertenecen a ninguna rama. Si ves ese aviso, vuelve con git switch main.
Regla de oro: una rama no copia archivos ni ocupa espacio: es una etiqueta. Crea todas las ramas que necesites, una por idea.

Practica

BásicoCrea la rama fix/precio y comprueba, con git branch y la decoración de git log, que existe pero que sigues en main.

Ver solución 1
git branch fix/precio
git branch
git log --oneline -1
fix/precio * main 8a4c569 (HEAD -> main, fix/precio) Agrega la hoja de estilos

(HEAD -> main, fix/precio): dos etiquetas sobre el mismo commit, y HEAD en main.

RetoDemuestra que una rama es solo un puntero: muestra el contenido de los archivos de main y fix/precio dentro de .git, y el hash completo del último commit.

Ver solución 2
cat .git/refs/heads/main
cat .git/refs/heads/fix/precio
git log -1 --format=%H
8a4c569ed7064e6ec4e4ed500c735461e9bc7179 8a4c569ed7064e6ec4e4ed500c735461e9bc7179 8a4c569ed7064e6ec4e4ed500c735461e9bc7179

Los tres valores son el mismo hash: dos ramas que apuntan al mismo commit. La barra del nombre fix/precio crea una subcarpeta.

Puntos clave

  • Una rama es un archivo con el hash de un commit: una etiqueta que avanza con cada commit.
  • HEAD indica en qué rama estás.
  • git branch lista las ramas; git branch nombre crea una sin moverte a ella.

14 · Crear y cambiar de rama: branch y switch

Intermedio ~18 min

Ya sabes que una rama es una etiqueta. Ahora vas a usarlas: cambiarás de rama, harás commits en ella y verás algo que sorprende la primera vez: tus archivos cambian según la rama en la que estés.

En este capítulo aprenderás a:

  • cambiar de rama con git switch y crear y cambiar en un solo paso con -c;
  • ver cómo avanza solo la rama actual al hacer commits;
  • leer el grafo de ramas con git log --graph --all;
  • entender qué pasa con tus cambios sin guardar al cambiar de rama.

git switch: moverse a otra rama

Con la rama postres creada (capítulo 13), cámbiate a ella:

git switch postres
Switched to branch 'postres'
git branch
main * postres
cat .git/HEAD
ref: refs/heads/postres

El asterisco y HEAD ahora indican postres.

Los commits hacen avanzar a la rama actual

echo "<ul><li>Torta de chocolate S/ 12</li></ul>" > postres.html
git add postres.html
git commit -m "Agrega la carta de postres"
[postres c8760e4] Agrega la carta de postres 1 file changed, 1 insertion(+) create mode 100644 postres.html
git log --oneline --graph --all
* c8760e4 (HEAD -> postres) Agrega la carta de postres * 8a4c569 (main) Agrega la hoja de estilos * dda32fe Agrega el menú de bebidas * d077686 Crea la portada
La rama actual avanza con cada commit d077686 dda32fe 8a4c569 c8760e4 main postres HEAD
Fig. 14.1 · Estás en postres (HEAD apunta a ella). El commit nuevo hace avanzar solo a postres; main se queda donde estaba.

En el grafo de texto, (HEAD -> postres) está en el commit nuevo y (main) se quedó un paso atrás. La opción --all hace que git log muestre todas las ramas, no solo la actual.

Tus archivos cambian con la rama

Al cambiar de rama, Git deja el directorio de trabajo tal como está en el commit al que apunta esa rama. postres.html solo existe en postres:

ls
css index.html menu.html postres.html
git switch main
Switched to branch 'main'
ls
css index.html menu.html
git switch postres
Switched to branch 'postres'
ls
css index.html menu.html postres.html

No se perdió nada: el archivo está guardado en el commit de postres y vuelve cuando regresas.

Crear y cambiar de un solo paso

Lo más común es crear una rama y empezar a trabajar en ella de inmediato. -c (create) hace ambas cosas:

git switch -c contacto
Switched to a new branch 'contacto'
git branch
* contacto main

Cuando las líneas se separan

Mientras alguien trabaja en postres, en main también hay avances, por ejemplo el horario de atención. Mira cómo se dibuja el grafo:

echo "<p>Abierto de 8:00 a 20:00</p>" >> index.html
git commit -am "Agrega el horario"
[main f3c7f61] Agrega el horario 1 file changed, 1 insertion(+)
git log --oneline --graph --all
* f3c7f61 (HEAD -> main) Agrega el horario | * c8760e4 (postres) Agrega la carta de postres |/ * 8a4c569 Agrega la hoja de estilos * dda32fe Agrega el menú de bebidas * d077686 Crea la portada
Dos líneas de trabajo que se separan d077686 dda32fe 8a4c569 c8760e4 f3c7f61 main postres HEAD
Fig. 14.2 · De vuelta en main se hizo otro commit: ahora la historia tiene dos líneas que parten de 8a4c569. En el capítulo 16 las juntarás.

Las líneas verticales (|) y la barra (/) muestran que la historia se bifurcó en 8a4c569: cada rama tiene un commit que la otra no tiene.

Cambios sin guardar al cambiar de rama

Si tienes cambios sin commit en un archivo que es distinto en la otra rama, Git se niega a cambiar para no pisar tu trabajo:

echo "<li>Alfajor S/ 4</li>" >> postres.html
git switch main
error: Your local changes to the following files would be overwritten by checkout: postres.html Please commit your changes or stash them before you switch branches. Aborting

«Tus cambios locales en postres.html se sobrescribirían. Haz commit o guárdalos aparte (stash) antes de cambiar de rama». Tienes tres salidas: hacer commit, descartar con git restore o guardarlos temporalmente con git stash (capítulo 29). Si el archivo no cambia entre ramas, Git sí te deja cambiar y tus cambios viajan contigo.

ComandoQué hace
git switch ramaTe mueve a una rama existente
git switch -c ramaCrea la rama y te mueve a ella
git switch -Vuelve a la rama anterior (como el botón «atrás»)
git log --oneline --graph --allDibuja todas las ramas
¿git checkout? Antes de Git 2.23 se usaba git checkout rama y git checkout -b rama. Siguen funcionando y los verás en tutoriales antiguos, pero checkout hace demasiadas cosas a la vez; switch solo cambia de rama.
Regla de oro: antes de cambiar de rama, deja el directorio de trabajo limpio (git status sin cambios): haz commit o guarda tus cambios aparte. Así nunca mezclarás trabajo de dos ramas.

Practica

BásicoCrea y entra a la rama feature/promociones, agrega promos.html con un commit y dibuja el grafo de todas las ramas.

Ver solución 1
git switch -c feature/promociones
echo "<h2>2x1 los lunes</h2>" > promos.html
git add promos.html
git commit -m "Agrega la página de promociones"
git log --oneline --graph --all
Switched to a new branch 'feature/promociones' [feature/promociones bad32a3] Agrega la página de promociones 1 file changed, 1 insertion(+) create mode 100644 promos.html * bad32a3 (HEAD -> feature/promociones) Agrega la página de promociones * 8a4c569 (main) Agrega la hoja de estilos * dda32fe Agrega el menú de bebidas * d077686 Crea la portada

Solo avanzó feature/promociones; main quedó en el commit anterior.

RetoComprueba que promos.html desaparece al ir a main y reaparece al volver, usando el atajo para regresar a la rama anterior.

Ver solución 2
ls
git switch main
ls
git switch -
ls
css index.html menu.html promos.html Switched to branch 'main' css index.html menu.html Switched to branch 'feature/promociones' css index.html menu.html promos.html

git switch - vuelve a la última rama en la que estuviste, como el botón «atrás» del navegador.

Puntos clave

  • git switch rama te mueve; git switch -c rama crea y te mueve.
  • Cada commit hace avanzar solo a la rama actual.
  • Al cambiar de rama, tus archivos pasan a ser los del commit de esa rama.
  • git log --oneline --graph --all muestra cómo se separan las líneas de trabajo.

15 · Fusionar I: el merge fast-forward

Intermedio ~14 min

La carta de postres está lista en su rama. Ahora toca llevarla a main: eso es fusionar (merge). Git tiene dos formas de hacerlo según cómo esté la historia. Empezamos por la más sencilla: el fast-forward («avance rápido»).

En este capítulo aprenderás a:

  • fusionar una rama con git merge;
  • reconocer cuándo el merge es un fast-forward;
  • leer la respuesta de Git después de fusionar.

Primero: ubícate en la rama que recibe

git merge otra trae los cambios de otra hacia la rama donde estás. Para llevar postres a main, primero te cambias a main. Así está la historia:

git log --oneline --graph --all
* c8760e4 (postres) Agrega la carta de postres * 8a4c569 (HEAD -> main) Agrega la hoja de estilos * dda32fe Agrega el menú de bebidas * d077686 Crea la portada
Antes del merge fast-forward d077686 dda32fe 8a4c569 c8760e4 main postres HEAD
Fig. 15.1 · main está detrás de postres en la misma línea: no hay nada que combinar, solo hay que adelantar la etiqueta.

Desde que postres salió de main, en main no hubo commits nuevos. Las dos ramas están en la misma línea, una detrás de la otra.

Fusionar: Git solo adelanta la etiqueta

git switch main
Switched to branch 'main'
git merge postres
Updating 8a4c569..c8760e4 Fast-forward postres.html | 1 + 1 file changed, 1 insertion(+) create mode 100644 postres.html
git log --oneline --graph --all
* c8760e4 (HEAD -> main, postres) Agrega la carta de postres * 8a4c569 Agrega la hoja de estilos * dda32fe Agrega el menú de bebidas * d077686 Crea la portada
ls
css index.html menu.html postres.html

Lee la respuesta: «Actualizando 8a4c569..c8760e4 · Fast-forward». Como no había nada que combinar, Git simplemente movió la etiqueta main hacia adelante. Ahora ambas ramas apuntan al mismo commit y postres.html ya está en main.

Después del merge fast-forward d077686 dda32fe 8a4c569 c8760e4 main postres HEAD
Fig. 15.2 · git merge postres movió la etiqueta main hasta c8760e4. No se creó ningún commit nuevo.
SituaciónTipo de mergeResultado
La rama que recibe NO tiene commits nuevosFast-forwardLa etiqueta avanza; no hay commit nuevo
Ambas ramas tienen commits nuevosMerge de tres vías (capítulo 16)Se crea un commit de merge
El fast-forward no puede fallar por conflictos. Como no hay dos versiones distintas que combinar, nunca aparecen conflictos. Los conflictos solo pueden aparecer en el merge de tres vías (parte IV).
Regla de oro: para fusionar, primero muévete a la rama que RECIBE los cambios (normalmente main) y, desde ahí, ejecuta git merge rama-con-los-cambios.

Practica

BásicoLa rama postres está lista y main no avanzó. Fusiónala en main y comprueba que fue un fast-forward.

Ver solución 1
git switch main
git merge postres
git log --oneline --graph --all
Switched to branch 'main' Updating 8a4c569..2aa6155 Fast-forward postres.html | 1 + 1 file changed, 1 insertion(+) create mode 100644 postres.html * 2aa6155 (HEAD -> main, postres) Agrega la carta de postres * 8a4c569 Agrega la hoja de estilos * dda32fe Agrega el menú de bebidas * d077686 Crea la portada

«Fast-forward»: main solo adelantó su etiqueta hasta el commit de postres.

RetoTu equipo usa git merge --ff-only para fusionar solo si no hace falta un commit de merge. Pruébalo con postres, sabiendo que main ya tiene un commit propio. ¿Qué responde Git y por qué?

Ver solución 2
git log --oneline --graph --all
git merge --ff-only postres
* f3c7f61 (HEAD -> main) Agrega el horario | * c8760e4 (postres) Agrega la carta de postres |/ * 8a4c569 Agrega la hoja de estilos * dda32fe Agrega el menú de bebidas * d077686 Crea la portada hint: Diverging branches can't be fast-forwarded, you need to either: hint: hint: git merge --no-ff hint: hint: or: hint: hint: git rebase hint: hint: Disable this message with "git config set advice.diverging false" fatal: Not possible to fast-forward, aborting.

Git se niega («Not possible to fast-forward»): las ramas divergieron y solo un merge de tres vías (o un rebase, capítulo 28) puede juntarlas.

Puntos clave

  • git merge otra trae los commits de otra a la rama actual.
  • Fast-forward: si la rama actual no avanzó, Git solo mueve su etiqueta hacia adelante.
  • Un fast-forward no crea commits ni puede tener conflictos.

16 · Fusionar II: merge de tres vías

Intermedio ~18 min

En el capítulo anterior, main no había avanzado y bastó con mover la etiqueta. Pero en un equipo real lo normal es que las dos ramas avancen al mismo tiempo. Entonces Git tiene que combinar dos historias distintas y crea un commit de merge.

En este capítulo aprenderás a:

  • reconocer cuándo un merge necesita combinar dos historias;
  • entender qué es la base común y por qué el merge es «de tres vías»;
  • crear y leer un commit de merge con sus dos padres;
  • forzar un commit de merge con --no-ff cuando el equipo lo prefiera.

Dos ramas que avanzaron

Retomamos la situación del capítulo 14: postres tiene la carta y main, el horario. Cada rama tiene un commit que la otra no tiene:

git log --oneline --graph --all
* f3c7f61 (HEAD -> main) Agrega el horario | * c8760e4 (postres) Agrega la carta de postres |/ * 8a4c569 Agrega la hoja de estilos * dda32fe Agrega el menú de bebidas * d077686 Crea la portada
Las tres versiones que compara Git dda32fe 8a4c569 c8760e4 f3c7f61 main postres HEAD base común
Fig. 16.1 · Git compara tres commits: la base común (8a4c569, donde se separaron) y la punta de cada rama. Por eso se llama «de tres vías».

El merge de tres vías

Para combinar, Git busca el último commit que ambas ramas comparten (la base común) y compara qué cambió cada rama desde ahí. Si los cambios tocan partes distintas, como aquí (uno agregó un archivo y el otro una línea en index.html), Git los junta solo. Desde main:

git merge postres --no-edit
Merge made by the 'ort' strategy. postres.html | 1 + 1 file changed, 1 insertion(+) create mode 100644 postres.html
git log --oneline --graph --all
* 42683e6 (HEAD -> main) Merge branch 'postres' |\ | * c8760e4 (postres) Agrega la carta de postres * | f3c7f61 Agrega el horario |/ * 8a4c569 Agrega la hoja de estilos * dda32fe Agrega el menú de bebidas * d077686 Crea la portada

«Merge hecho con la estrategia ort» (el algoritmo de fusión que usa Git por defecto). En el grafo, la línea de postres vuelve a unirse a main en el commit Merge branch 'postres'.

El commit de merge tiene dos padres dda32fe 8a4c569 c8760e4 f3c7f61 42683e6 main postres HEAD
Fig. 16.2 · El merge crea un commit nuevo (42683e6) con DOS padres: la punta de main y la de postres. Así la historia recuerda que las dos líneas se juntaron.

Un commit con dos padres

El commit de merge es especial: la línea Merge: muestra sus dos padres.

git show --stat HEAD
commit 42683e6b8af40da6c1c5ce37aeda27b0f3334161 (HEAD -> main) Merge: f3c7f61 c8760e4 Author: Ana Torres <ana@aromaypunto.pe> Date: Wed Jul 15 09:06:00 2026 -0500 Merge branch 'postres' postres.html | 1 + 1 file changed, 1 insertion(+)
¿Por qué --no-edit? Sin esa opción, Git abre el editor con el mensaje propuesto «Merge branch 'postres'» para que lo confirmes o lo cambies. Guarda y cierra (en Nano, Ctrl+O, Enter, Ctrl+X) y el merge se completa. --no-edit acepta el mensaje tal cual.

Forzar un commit de merge: --no-ff

Algunos equipos quieren que cada funcionalidad deje su commit de merge, aunque un fast-forward fuera posible, para ver en la historia dónde empezó y terminó. Con --no-ff (y un mensaje propio) se consigue:

git merge --no-ff postres -m "Integra la carta de postres"
Merge made by the 'ort' strategy. postres.html | 1 + 1 file changed, 1 insertion(+) create mode 100644 postres.html
git log --oneline --graph --all -4
* f4f330d (HEAD -> main) Integra la carta de postres |\ | * c8760e4 (postres) Agrega la carta de postres |/ * 8a4c569 Agrega la hoja de estilos * dda32fe Agrega el menú de bebidas
OpciónCuándo usarla
git merge ramaLo habitual: fast-forward si se puede; si no, commit de merge.
git merge --no-ff ramaSiempre un commit de merge, para dejar visible la integración.
git merge --ff-only ramaSolo si es fast-forward; si no, falla en lugar de crear un merge.
git merge --abortCancela un merge a medias (lo usarás con los conflictos).

¿Y si las dos ramas tocaron la misma línea?

Entonces Git no puede decidir solo qué versión es la correcta y se detiene para preguntarte: eso es un conflicto. No es un error ni una catástrofe; es Git pidiendo tu criterio. La parte IV del curso está dedicada a resolverlos con calma.

Regla de oro: antes de fusionar, deja limpio el directorio de trabajo y revisa con git log --oneline --graph --all qué vas a juntar. Un merge sin sorpresas empieza mirando el grafo.

Practica

BásicoFusiona postres en main aceptando el mensaje propuesto y muestra los dos padres del commit de merge.

Ver solución 1
git merge postres --no-edit
git log -1 --format="%h tiene como padres: %p"
Merge made by the 'ort' strategy. postres.html | 1 + 1 file changed, 1 insertion(+) create mode 100644 postres.html 42683e6 tiene como padres: f3c7f61 c8760e4

%p lista los hashes cortos de los padres. Un commit normal tiene uno; un merge, dos.

RetoEl equipo quiere que cada funcionalidad deje un commit de merge visible. Integra feature/galeria con un mensaje propio aunque sea posible un fast-forward, y dibuja el grafo.

Ver solución 2
git merge --no-ff feature/galeria -m "Integra la galería de fotos"
git log --oneline --graph --all
Merge made by the 'ort' strategy. galeria.html | 1 + 1 file changed, 1 insertion(+) create mode 100644 galeria.html * c6220f7 (HEAD -> main) Integra la galería de fotos |\ | * aa2b2fc (feature/galeria) Agrega la galería |/ * 8a4c569 Agrega la hoja de estilos * dda32fe Agrega el menú de bebidas * d077686 Crea la portada

Con --no-ff el grafo muestra la «burbuja» de la funcionalidad, aunque main no hubiera avanzado.

Puntos clave

  • Si ambas ramas avanzaron, el merge combina las historias y crea un commit de merge.
  • Git compara tres versiones: la base común y la punta de cada rama.
  • El commit de merge tiene dos padres (línea Merge: en git show).
  • --no-ff fuerza el commit de merge; --ff-only lo prohíbe.

17 · Ordenar las ramas: listar, renombrar y borrar

Intermedio ~14 min

En un proyecto activo se crean ramas todo el tiempo: una por funcionalidad, una por arreglo. Si no las ordenas, en pocas semanas tendrás treinta ramas y nadie sabrá cuáles siguen vivas. Este capítulo cierra la parte III con la «limpieza de la casa».

En este capítulo aprenderás a:

  • listar ramas con su último commit y saber cuáles ya se fusionaron;
  • borrar ramas con seguridad (-d) y forzar el borrado cuando corresponde (-D);
  • renombrar ramas y elegir buenos nombres.

Listar con detalle

El repositorio de práctica tiene main (con postres ya fusionada) y una rama galeria sin terminar. -v agrega el último commit de cada rama:

git branch
galeria * main postres
git branch -v
galeria f269583 Empieza la galería * main 42683e6 Merge branch 'postres' postres c8760e4 Agrega la carta de postres

¿Cuáles ya están fusionadas?

Estas dos opciones responden la pregunta clave antes de borrar, siempre desde la rama principal:

git branch --merged
* main postres
git branch --no-merged
galeria

postres aparece en --merged: todo su trabajo ya está en main. galeria aparece en --no-merged: tiene commits que main aún no tiene.

Borrar ramas: -d, el borrado seguro

git branch -d postres
Deleted branch postres (was c8760e4).
git log --oneline --graph -4
* 42683e6 (HEAD -> main) Merge branch 'postres' |\ | * c8760e4 Agrega la carta de postres * | f3c7f61 Agrega el horario |/ * 8a4c569 Agrega la hoja de estilos
git branch -d galeria
error: the branch 'galeria' is not fully merged hint: If you are sure you want to delete it, run 'git branch -D galeria' hint: Disable this message with "git config set advice.forceDeleteBranch false"

postres se borró sin problema y su commit sigue en el grafo. Con galeria, Git se niega: «la rama no está completamente fusionada» y, si estás seguro, sugiere usar -D. Es una red de seguridad que evita perder trabajo.

Borrar una rama fusionada no borra sus commits 8a4c569 c8760e4 f3c7f61 42683e6 main HEAD
Fig. 17.1 · Tras git branch -d postres solo desaparece la etiqueta. El commit c8760e4 sigue en la historia porque el merge lo une a main.

Borrado forzado: -D

Si decidiste abandonar una idea, -D borra la rama aunque no esté fusionada:

git branch -D galeria
Deleted branch galeria (was f269583).
git branch
* main postres
Con -D los commits quedan huérfanos. Ninguna etiqueta apunta ya a ellos y Git los eliminará más adelante. Si te arrepientes pronto, todavía se pueden rescatar con git reflog (capítulo 30).

Renombrar y nombrar bien

git branch -m galeria feature/galeria
git branch
feature/galeria * main postres

Los equipos suelen usar prefijos que dicen qué tipo de trabajo contiene la rama:

PrefijoPara quéEjemplo
feature/Funcionalidad nuevafeature/carta-postres
fix/Corrección de un errorfix/precio-espresso
docs/Solo documentacióndocs/manual-instalacion
hotfix/Arreglo urgente en producciónhotfix/formulario-caido

Usa minúsculas, guiones en lugar de espacios y nombres que se entiendan solos. Evita prueba2 o rama-luis.

ComandoQué hace
git branch -vLista las ramas con su último commit
git branch --mergedRamas cuyo trabajo ya está en la actual (se pueden borrar)
git branch --no-mergedRamas con trabajo pendiente de fusionar
git branch -d ramaBorra solo si está fusionada
git branch -D ramaBorra aunque no esté fusionada
git branch -m viejo nuevoRenombra
Regla de oro: cuando una rama se fusiona, bórrala con -d. Su historia queda en main; la etiqueta ya no hace falta.

Practica

BásicoDescubre qué ramas ya están fusionadas en main y borra con seguridad las que sobran.

Ver solución 1
git branch --merged
git branch --no-merged
git branch -d postres
git branch
* main postres borrador Deleted branch postres (was c8760e4). borrador * main

postres se borró porque su trabajo ya está en main; borrador sigue, porque tiene commits sin fusionar.

RetoHay dos ramas mal nombradas: galeriaa (error de tipeo, sin trabajo propio) y prueba2 (una idea que el equipo descartó). Renombra la primera a feature/galeria y elimina la segunda.

Ver solución 2
git branch -v
git branch -m galeriaa feature/galeria
git branch -D prueba2
git branch
galeriaa 8a4c569 Agrega la hoja de estilos * main 8a4c569 Agrega la hoja de estilos prueba2 3fbaa0c Idea descartada Deleted branch prueba2 (was 3fbaa0c). feature/galeria * main

-D es necesario porque prueba2 no está fusionada: borras a propósito un trabajo que no se usará.

Puntos clave

  • Borrar una rama elimina la etiqueta, no los commits fusionados.
  • --merged y --no-merged dicen qué ramas se pueden borrar.
  • -d protege el trabajo sin fusionar; -D lo descarta a propósito.
  • Nombres con prefijo (feature/, fix/) y en minúsculas con guiones.

18 · Por qué ocurren los conflictos

Intermedio ~14 min

La palabra «conflicto» asusta a quien empieza, pero no es un error ni significa que algo se rompió. Un conflicto es Git diciendo, con honestidad: «dos personas cambiaron lo mismo de forma distinta y no me corresponde a mí decidir cuál vale». En esta parte aprenderás a entenderlos y resolverlos con calma.

En este capítulo aprenderás a:

  • explicar cuándo Git combina solo y cuándo necesita tu ayuda;
  • reconocer el mensaje CONFLICT y el estado de un merge interrumpido;
  • conocer los tipos de conflicto más comunes.

Git combina solo… casi siempre

Recuerda el merge de tres vías: Git compara la base común con lo que hizo cada rama. Si las ramas cambiaron líneas distintas, junta ambos cambios sin preguntar. Aquí una rama subió el americano y la otra cambió el lema:

git merge precios --no-edit
Auto-merging index.html Merge made by the 'ort' strategy. index.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
cat index.html
<h1>Aroma y Punto</h1> <p>Café de especialidad</p> <ul> <li>Espresso S/ 7</li> <li>Americano S/ 9</li> </ul>

El archivo final tiene los dos cambios. Esta es la situación más frecuente en un equipo bien organizado.

Cuando dos ramas tocan la misma línea

Ahora Luis, en la rama precios, subió el espresso a S/ 8, mientras Ana, en main, lo ajustó a S/ 7.50:

La misma línea cambiada en dos ramas base comúnEspresso S/ 7 main (tu rama)Espresso S/ 7.50 precios (la otra rama)Espresso S/ 8 ¿Cuál de las dos queda? → conflicto
Fig. 18.1 · Las dos ramas partieron de la misma línea y cada una la cambió distinto. Git no puede saber cuál precio es el correcto: necesita que tú decidas.
git log --oneline --graph --all
* e7dbc13 (HEAD -> main) Ajusta el espresso a S/ 7.50 | * 3812247 (precios) Sube el espresso a S/ 8 |/ * 2e7626a Crea la portada con el menú
git merge precios
Auto-merging index.html CONFLICT (content): Merge conflict in index.html Automatic merge failed; fix conflicts and then commit the result.

Lee el mensaje: «Combinando index.html… CONFLICTO (contenido): conflicto de fusión en index.html. La fusión automática falló; arregla los conflictos y luego haz commit del resultado».

Un merge a medio camino

El merge no terminó: quedó en pausa, esperándote. git status lo explica:

git status
On branch main You have unmerged paths. (fix conflicts and run "git commit") (use "git merge --abort" to abort the merge) Unmerged paths: (use "git add <file>..." to mark resolution) both modified: index.html no changes added to commit (use "git add" and/or "git commit -a")

«Tienes rutas sin fusionar» y both modified: index.html (ambos lo modificaron). Git te da las dos salidas: arreglar y hacer commit, o cancelar con git merge --abort. Las verás en los capítulos 19 y 20.

Los tipos de conflicto que verás

SituaciónMensaje de GitQué decides
Las dos ramas cambiaron la misma líneaCONFLICT (content)Qué texto queda (una versión, la otra o una mezcla)
Una rama editó un archivo y la otra lo borróCONFLICT (modify/delete)Si el archivo se queda o se va
Las dos ramas crearon un archivo con el mismo nombreCONFLICT (add/add)Cómo combinar los dos contenidos

El primero es, por lejos, el más común. Los tres se resuelven con la misma idea: tú decides y se lo dices a Git.

Los conflictos se previenen más de lo que se sufren. Commits pequeños, ramas que viven pocos días y fusionar seguido con main reducen muchísimo los choques. Y, sobre todo, conversar: si dos personas van a tocar el mismo archivo, que lo sepan.
Regla de oro: ante un conflicto, no entres en pánico ni borres el repositorio: Git no perdió nada. Lee git status; siempre te dice dónde estás y cuáles son tus opciones.

Practica

BásicoLas ramas main y precios cambiaron el precio del americano. Intenta fusionar precios y comprueba en qué estado queda el repositorio.

Ver solución 1
git merge precios
git status -s
Auto-merging index.html CONFLICT (content): Merge conflict in index.html Automatic merge failed; fix conflicts and then commit the result. UU index.html

UU: el merge quedó en pausa con index.html sin fusionar. No se perdió nada.

RetoHay tres ramas: lema y americano cambian líneas distintas; lema2 cambia la misma línea que lema. Fusiónalas en ese orden y explica por qué solo la última da conflicto.

Ver solución 2
git merge lema
git merge americano --no-edit
git merge lema2
Updating 2e7626a..08f71af Fast-forward index.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) Auto-merging index.html Merge made by the 'ort' strategy. index.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) Auto-merging index.html CONFLICT (content): Merge conflict in index.html Automatic merge failed; fix conflicts and then commit the result.

La primera es fast-forward, la segunda combina líneas distintas sin preguntar y la tercera choca: main ya tiene «Café de especialidad» en la misma línea que lema2 quiere cambiar a «Café peruano».

Puntos clave

  • Si las ramas cambian líneas distintas, Git combina solo.
  • Hay conflicto cuando las dos ramas cambian la MISMA parte de forma distinta.
  • Un merge con conflictos queda en pausa: git status muestra «Unmerged paths».
  • Tipos: content, modify/delete y add/add.

19 · Anatomía de un conflicto: los marcadores

Intermedio ~15 min

Cuando hay un conflicto, Git no elige: escribe las dos versiones dentro del archivo, separadas por unas marcas especiales, y espera a que tú lo arregles. Aprender a leer esas marcas es todo el secreto.

En este capítulo aprenderás a:

  • leer los marcadores <<<<<<<, ======= y >>>>>>>;
  • saber qué versión es «la tuya» y cuál «la otra»;
  • activar el estilo zdiff3 para ver también la versión original;
  • identificar los commits que provocaron el conflicto.

El archivo con el conflicto

Seguimos con el conflicto del espresso. UU en git status -s significa «sin fusionar, modificado por ambos» (unmerged, both updated). Abramos el archivo:

git status -s
UU index.html
cat index.html
<h1>Aroma y Punto</h1> <p>Café de origen</p> <ul> <<<<<<< HEAD <li>Espresso S/ 7.50</li> ======= <li>Espresso S/ 8</li> >>>>>>> precios <li>Americano S/ 8</li> </ul>
Anatomía de un bloque de conflicto <ul> <<<<<<< HEAD ← inicio: tu versión <li>Espresso S/ 7.50</li> ======= ← separador <li>Espresso S/ 8</li> >>>>>>> precios ← fin: la otra versión <li>Americano S/ 8</li>
Fig. 19.1 · Verde: tu versión (la rama donde estás, HEAD). Azul: la versión de la rama que traes (precios). Las líneas sin color no tienen conflicto.
MarcaSignificado
<<<<<<< HEADEmpieza el conflicto. Lo que sigue es TU versión: la de la rama donde estás (aquí, main).
=======Separa las dos versiones.
>>>>>>> preciosTermina el conflicto. Lo anterior (hasta =======) es la versión de la rama que estás fusionando.

Todo lo que está fuera de las marcas (el <h1>, el americano) no tiene conflicto: Git ya lo resolvió. Un archivo puede tener varios bloques de conflicto; cada uno se lee igual.

El archivo, tal como está, no funciona. Las marcas son texto que Git escribió dentro de tu código: si abres la página o ejecutas el programa ahora, verás esas líneas o un error. Resolver el conflicto incluye BORRARLAS.

Ver también la versión original: zdiff3

Con dos versiones a veces no queda claro qué hizo cada uno. El estilo zdiff3 agrega la versión de la base común, entre ||||||| y =======. Actívalo una vez y queda para siempre:

git config --global merge.conflictStyle zdiff3
git merge precios
Auto-merging index.html CONFLICT (content): Merge conflict in index.html Automatic merge failed; fix conflicts and then commit the result.
cat index.html
<h1>Aroma y Punto</h1> <p>Café de origen</p> <ul> <<<<<<< HEAD <li>Espresso S/ 7.50</li> ||||||| 2e7626a <li>Espresso S/ 7</li> ======= <li>Espresso S/ 8</li> >>>>>>> precios <li>Americano S/ 8</li> </ul>
El mismo conflicto con el estilo zdiff3 <<<<<<< HEAD ← inicio: tu versión <li>Espresso S/ 7.50</li> ||||||| 2e7626a ← versión base (zdiff3) <li>Espresso S/ 7</li> ======= ← separador <li>Espresso S/ 8</li> >>>>>>> precios ← fin: la otra versión
Fig. 19.2 · Con zdiff3 aparece también, en gris, cómo era la línea ANTES de que las ramas se separaran (la base común 2e7626a). Ahora se entiende: los dos subieron el precio, pero no en la misma cantidad.

Ahora el panorama es completo: originalmente costaba S/ 7; Ana lo subió a S/ 7.50 y Luis, a S/ 8. Los dos querían subirlo, pero no en la misma cantidad. Con esa información es mucho más fácil decidir (o saber a quién preguntar).

¿Quién y por qué?

Para decidir bien, conviene saber qué commits chocaron. Durante un merge, git log --merge lista los commits de ambas ramas que tocaron los archivos en conflicto:

git log --merge --oneline
e7dbc13 (HEAD -> main) Ajusta el espresso a S/ 7.50 3812247 (precios) Sube el espresso a S/ 8

Con los mensajes (y git show de cada uno) entiendes la intención de cada cambio. Y si tienes dudas, pregunta a quien hizo el otro commit: resolver un conflicto es una decisión de equipo.

Regla de oro: activa git config --global merge.conflictStyle zdiff3 hoy mismo. Ver la versión original convierte una adivinanza en una decisión informada.

Practica

BásicoCon el estilo clásico de marcas, muestra el archivo en conflicto. ¿Qué precio propone tu rama y cuál la otra?

Ver solución 1
git diff --name-only --diff-filter=U
cat index.html
index.html <h1>Aroma y Punto</h1> <p>Café de origen</p> <ul> <li>Espresso S/ 7</li> <<<<<<< HEAD <li>Americano S/ 8.50</li> ======= <li>Americano S/ 9</li> >>>>>>> precios </ul>

Entre <<<<<<< HEAD y ======= está TU versión (S/ 8.50, de main); entre ======= y >>>>>>> precios, la de la otra rama (S/ 9).

RetoEstás en medio de un conflicto con el estilo clásico y no sabes cuál era el precio original. Cancela el merge, activa zdiff3 y vuelve a fusionar para ver también la base común.

Ver solución 2
git merge --abort
git config --global merge.conflictStyle zdiff3
git merge precios
cat index.html
Auto-merging index.html CONFLICT (content): Merge conflict in index.html Automatic merge failed; fix conflicts and then commit the result. <h1>Aroma y Punto</h1> <p>Café de origen</p> <ul> <li>Espresso S/ 7</li> <<<<<<< HEAD <li>Americano S/ 8.50</li> ||||||| 2e7626a <li>Americano S/ 8</li> ======= <li>Americano S/ 9</li> >>>>>>> precios </ul>

Ahora el bloque entre ||||||| y ======= muestra el precio original (S/ 8): los dos lo subieron.

Puntos clave

  • Entre <<<<<<< HEAD y ======= está TU versión; después, la de la otra rama.
  • Fuera de las marcas no hay conflicto: Git ya combinó esas partes.
  • Con zdiff3 también ves la base común, entre ||||||| y =======.
  • git log --merge muestra los commits que chocaron.

20 · Resolver un conflicto paso a paso

Intermedio ~18 min

Ya sabes por qué ocurren los conflictos y cómo leerlos. Ahora vas a resolver uno de principio a fin con un método de cinco pasos que sirve para cualquier conflicto, sea de una línea o de veinte archivos.

En este capítulo aprenderás a:

  • resolver un conflicto con el método de cinco pasos;
  • comprobar que no quedaron marcadores olvidados;
  • cancelar un merge que se complicó con git merge --abort;
  • quedarte con una versión completa con git restore --ours o --theirs.

Partimos del conflicto del espresso, con el estilo zdiff3 activado (capítulo 19). Tras conversar con Luis, el equipo decide que el precio correcto es S/ 8.

Paso 1 · Mira el panorama

¿Qué archivos tienen conflicto? En un merge grande puede haber varios:

git status -s
UU index.html
git diff --name-only --diff-filter=U
index.html

Paso 2 · Edita el archivo y decide

Abre el archivo con tu editor (nano index.html), busca los bloques con marcas y deja el texto como debe quedar: una versión, la otra o una mezcla de ambas. Luego borra las tres o cuatro líneas de marcas. En el manual escribimos el resultado con cat para que puedas reproducirlo, pero en la vida real lo editas en Nano:

cat > index.html << 'FIN'
<h1>Aroma y Punto</h1>
<p>Café de origen</p>
<ul>
  <li>Espresso S/ 8</li>
  <li>Americano S/ 8</li>
</ul>
FIN
cat index.html
<h1>Aroma y Punto</h1> <p>Café de origen</p> <ul> <li>Espresso S/ 8</li> <li>Americano S/ 8</li> </ul>
«Resolver» no siempre es elegir un lado. A veces lo correcto es combinar: por ejemplo, si una rama cambió el precio y la otra agregó una descripción en la misma línea, la línea final lleva las dos cosas.

Paso 3 · Comprueba que no quedan marcas

Un olvido común es dejar un ======= perdido. git diff --check lo detecta: con el conflicto sin resolver avisa de cada marca y, después de editar, ya no dice nada:

git diff --check
index.html:4: leftover conflict marker index.html:6: leftover conflict marker index.html:8: leftover conflict marker index.html:10: leftover conflict marker
cat > index.html << 'FIN'
<h1>Aroma y Punto</h1>
<p>Café de origen</p>
<ul>
  <li>Espresso S/ 8</li>
  <li>Americano S/ 8</li>
</ul>
FIN
git diff --check

Paso 4 · Marca el archivo como resuelto con git add

Durante un conflicto, git add significa «ya resolví este archivo»:

git add index.html
git status
On branch main All conflicts fixed but you are still merging. (use "git commit" to conclude merge) Changes to be committed: modified: index.html

«Todos los conflictos están resueltos, pero sigues en medio del merge (usa git commit para terminarlo)».

Paso 5 · Termina el merge con un commit

git commit --no-edit
[main f93de0d] Merge branch 'precios'
git log --oneline --graph
* f93de0d (HEAD -> main) Merge branch 'precios' |\ | * 3812247 (precios) Sube el espresso a S/ 8 * | e7dbc13 Ajusta el espresso a S/ 7.50 |/ * 2e7626a Crea la portada con el menú
El conflicto resuelto queda en el commit de merge 2e7626a 3812247 e7dbc13 merge main precios HEAD
Fig. 20.1 · Resolver un conflicto termina en un commit de merge normal: la decisión que tomaste queda registrada en la historia, con tu firma.

Plan B: cancelar el merge

Si el conflicto es más grande de lo que esperabas, o necesitas hablar con tu equipo antes de decidir, puedes dar marcha atrás. git merge --abort deja todo exactamente como estaba antes del merge:

git merge --abort
git status
On branch main nothing to commit, working tree clean
git log --oneline -1
e7dbc13 (HEAD -> main) Ajusta el espresso a S/ 7.50

Quedarte con una versión completa

Si ya sabes que una de las dos versiones del archivo es la buena entera, no tienes que editar a mano: --ours toma tu versión (la de HEAD) y --theirs, la de la rama que fusionas. --merge vuelve a poner el archivo en conflicto si te equivocaste:

git restore --theirs index.html
grep Espresso index.html
<li>Espresso S/ 8</li>
git restore --ours index.html
grep Espresso index.html
<li>Espresso S/ 7.50</li>
git restore --merge index.html
git status -s
UU index.html

Después de elegir, el paso 4 (git add) y el 5 (git commit) son los mismos.

PasoComandoPara qué
1git statusVer qué archivos tienen conflicto
2nano archivoDecidir el contenido y borrar las marcas
3git diff --checkConfirmar que no quedan marcas
4git add archivoMarcarlo como resuelto
5git commitTerminar el merge
—git merge --abortCancelar todo y volver al estado previo
Regla de oro: antes del git add, vuelve a abrir el archivo y pruébalo (abre la página, ejecuta el programa). Un conflicto «resuelto» que deja el código roto es peor que el conflicto.

Practica

BásicoResuelve el conflicto del americano con los cinco pasos: el equipo decidió S/ 9. Escribe el archivo final, comprueba que no quedan marcas, márcalo como resuelto y termina el merge.

Ver solución 1
git status -s
cat > index.html << 'FIN'
<h1>Aroma y Punto</h1>
<p>Café de origen</p>
<ul>
  <li>Espresso S/ 7</li>
  <li>Americano S/ 9</li>
</ul>
FIN
git diff --check
git add index.html
git commit --no-edit
git log --oneline --graph
UU index.html [main 3f39c0e] Merge branch 'precios' * 3f39c0e (HEAD -> main) Merge branch 'precios' |\ | * 8ed36c4 (precios) Sube el americano a S/ 9 * | 33a4eb8 Ajusta el americano a S/ 8.50 |/ * 2e7626a Crea la portada con el menú

En tu computadora, el paso de escribir el archivo lo haces con nano index.html, borrando las marcas a mano.

RetoDespués de revisarlo, el equipo decide quedarse con la versión de main completa (S/ 8.50). Resuélvelo sin editar el archivo a mano y deja un mensaje de merge que explique la decisión.

Ver solución 2
git restore --ours index.html
grep Americano index.html
git add index.html
git commit -m "Integra precios: se mantiene el americano a S/ 8.50"
<li>Americano S/ 8.50</li> [main 532e6c1] Integra precios: se mantiene el americano a S/ 8.50

--ours toma la versión de la rama donde estás (HEAD). Un buen mensaje de merge evita la pregunta «¿por qué se perdió el S/ 9?».

Puntos clave

  • Método: git status → editar y borrar marcas → git diff --check → git add → git commit.
  • Durante un conflicto, git add significa «este archivo ya está resuelto».
  • git merge --abort cancela el merge sin perder nada.
  • git restore --ours / --theirs eligen una versión completa del archivo.

21 · Laboratorio de conflictos: tres casos reales

Avanzado ~25 min

Llegó la práctica de verdad. Vas a resolver tres conflictos tal como aparecen en los equipos reales, cada uno con una decisión distinta. Reprodúcelos en tu terminal: crea un repositorio nuevo para cada caso, copia los comandos de preparación y aplica el método del capítulo 20.

En este capítulo aprenderás a:

  • combinar dos cambios de la misma línea en uno solo;
  • resolver un conflicto de archivo borrado frente a archivo editado;
  • manejar varios conflictos a la vez en archivos distintos, eligiendo la estrategia de cada uno.

Caso 1 · La misma línea, y los dos tienen razón

Situación: Luis, en la rama descripciones, agregó «doble carga» al espresso. Ana, en main, subió su precio a S/ 8. Los dos cambios son correctos, pero tocan la misma línea:

git merge descripciones
Auto-merging menu.html CONFLICT (content): Merge conflict in menu.html Automatic merge failed; fix conflicts and then commit the result.
cat menu.html
<ul> <<<<<<< HEAD <li>Espresso S/ 8</li> ||||||| 2dd34fc <li>Espresso S/ 7</li> ======= <li>Espresso S/ 7 · doble carga</li> >>>>>>> descripciones <li>Americano S/ 8</li> </ul>

Decisión: no se elige un lado; la línea final lleva el precio de Ana Y la descripción de Luis.

cat > menu.html << 'FIN'
<ul>
  <li>Espresso S/ 8 · doble carga</li>
  <li>Americano S/ 8</li>
</ul>
FIN
git diff --check
git add menu.html
git commit --no-edit
[main cffc288] Merge branch 'descripciones'
cat menu.html
<ul> <li>Espresso S/ 8 · doble carga</li> <li>Americano S/ 8</li> </ul>

Caso 2 · Borrado frente a editado

Situación: en main se retiró la promo de verano (se borró promo.html), pero en la rama promo-2x1 alguien la mejoró. Git no puede saber si el archivo debe existir:

git merge promo-2x1
CONFLICT (modify/delete): promo.html deleted in HEAD and modified in promo-2x1. Version promo-2x1 of promo.html left in tree. Automatic merge failed; fix conflicts and then commit the result.
git status -s
DU promo.html
ls
index.html promo.html

DU = borrado por nosotros (deleted), modificado por ellos (updated). Git dejó la versión de la rama en el disco para que la revises. Aquí no hay marcas dentro del archivo: la decisión es si se queda o se va.

Si decides…Comando
Que el archivo se quede (con los cambios de la rama)git add promo.html
Que el archivo se vayagit rm promo.html

Decisión: la gerencia confirma que la promo terminó, así que se borra:

git rm promo.html
rm 'promo.html'
git commit -m "Integra promo-2x1: la promo sigue retirada"
[main abfe725] Integra promo-2x1: la promo sigue retirada
git log --oneline --graph
* abfe725 (HEAD -> main) Integra promo-2x1: la promo sigue retirada |\ | * 7173c07 (promo-2x1) Mejora la promo con un 2x1 * | b328b21 Retira la promo de verano |/ * 44eae5c Crea la portada y la promo

Caso 3 · Varios conflictos en dos archivos

Situación: la rama rediseno cambió el lema, el horario y el color; main cambió lo mismo de otra forma. Hay conflictos en dos archivos:

git merge rediseno
Auto-merging estilos.css CONFLICT (content): Merge conflict in estilos.css Auto-merging index.html CONFLICT (content): Merge conflict in index.html Automatic merge failed; fix conflicts and then commit the result.
git status -s
UU estilos.css UU index.html
cat index.html
<h1>Aroma y Punto</h1> <<<<<<< HEAD <p>Café peruano</p> <p>Abierto de 8:00 a 22:00</p> ||||||| a12083f <p>Café de origen</p> <p>Abierto de 8:00 a 20:00</p> ======= <p>Café de especialidad</p> <p>Abierto de 7:00 a 21:00</p> >>>>>>> rediseno

El lema y el horario están en líneas vecinas, así que Git los agrupó en un solo bloque de conflicto: lo que está entre las marcas son las DOS líneas de cada versión.

Decisión, archivo por archivo: para estilos.css, el equipo de diseño manda, así que se toma la versión completa de la rama con --theirs. Para index.html se combina: «peruano de especialidad» y el horario más amplio (de 7:00 a 22:00).

git restore --theirs estilos.css
cat > index.html << 'FIN'
<h1>Aroma y Punto</h1>
<p>Café peruano de especialidad</p>
<p>Abierto de 7:00 a 22:00</p>
FIN
git diff --check
git add index.html estilos.css
git status -s
M estilos.css M index.html
git commit -m "Integra el rediseño: combina lemas y amplía el horario"
[main f204524] Integra el rediseño: combina lemas y amplía el horario
cat estilos.css
h1 { color: #6f4e37; font-family: Georgia; }
Lo que aprendiste en los tres casos: un conflicto no se «arregla» con un comando mágico, se DECIDE. Git te da las piezas (las versiones y la base común) y los comandos para registrar la decisión. Quien decide, con su equipo, eres tú.

Cómo tener menos conflictos

PrácticaPor qué ayuda
Commits pequeños y frecuentesLos conflictos son más chicos y fáciles de entender.
Ramas que viven pocos díasCuanto más se alejan dos ramas, más chocan.
Traer main a tu rama a menudoResuelves los choques de a poco, no todos al final.
Avisar al equipo qué archivos vas a tocarDos personas no editan la misma línea a la vez.
Un formato de código comúnQue nadie «cambie» líneas solo por espacios o comillas.
Regla de oro: resuelve conflictos con la cabeza fría y, si la decisión no es obvia, con el otro autor al lado. Un mal merge borra trabajo ajeno en silencio.

Practica

BásicoEn main se borró encuesta.html, pero la rama encuesta-v2 la mejoró. Esta vez el equipo decide que la encuesta se queda, con la versión mejorada.

Ver solución 1
git merge encuesta-v2
git status -s
git add encuesta.html
git commit -m "Integra encuesta-v2: la encuesta vuelve con 5 preguntas"
cat encuesta.html
CONFLICT (modify/delete): encuesta.html deleted in HEAD and modified in encuesta-v2. Version encuesta-v2 of encuesta.html left in tree. Automatic merge failed; fix conflicts and then commit the result. DU encuesta.html [main 55e2581] Integra encuesta-v2: la encuesta vuelve con 5 preguntas <p>Encuesta de satisfacción (5 preguntas)</p>

En un conflicto modify/delete, git add conserva el archivo y git rm confirma el borrado.

RetoTrabajas en feature/precios y main avanzó con un cambio que choca con el tuyo. Antes de pedir que integren tu rama, trae main a TU rama, resuelve ahí el conflicto (queda S/ 9) y comprueba que ya se puede integrar con un fast-forward.

Ver solución 2
git merge main
cat > index.html << 'FIN'
<h1>Aroma y Punto</h1>
<p>Café de origen</p>
<ul>
  <li>Espresso S/ 7</li>
  <li>Americano S/ 9</li>
</ul>
FIN
git add index.html
git commit --no-edit
git switch main
git merge --ff-only feature/precios
Auto-merging index.html CONFLICT (content): Merge conflict in index.html Automatic merge failed; fix conflicts and then commit the result. [feature/precios 8ab1757] Merge branch 'main' into feature/precios Switched to branch 'main' Updating 33a4eb8..8ab1757 Fast-forward index.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

Resolver en tu rama deja a main libre de conflictos: la integración final es un fast-forward limpio. Es la práctica habitual en equipos.

Puntos clave

  • Misma línea: puedes elegir una versión, la otra o combinarlas.
  • Borrado frente a editado (DU / UD): decides con git add (se queda) o git rm (se va).
  • Con varios archivos, resuelve uno por uno; --ours/--theirs sirven por archivo.
  • Ramas cortas y merges frecuentes previenen la mayoría de conflictos.

22 · Remotos: qué es origin

Intermedio ~16 min

Hasta ahora todo vivió en tu computadora. Para trabajar en equipo, el proyecto necesita un lugar compartido al que todos suban sus commits y del que todos bajen los de los demás. Ese lugar es un repositorio remoto, normalmente alojado en GitHub.

En este capítulo aprenderás a:

  • entender qué es un remoto y por qué se llama origin;
  • conectar un repositorio local con un remoto y subir tu rama;
  • distinguir tu rama main de la rama de seguimiento origin/main;
  • montar en tu computadora un «servidor de práctica» para la parte V.
Un repositorio remoto y los clones del equipo GitHub origin · repositorio remoto PC de Ana repositorio local PC de Luis repositorio local push ↑ pull ↓
Fig. 22.1 · El remoto (en GitHub) es el punto de encuentro. Cada integrante tiene su propio repositorio completo y lo sincroniza: push sube sus commits y pull trae los de los demás.

Qué es un remoto

Un remoto es otro repositorio de Git, en otra computadora o servidor, con el que el tuyo se sincroniza. Tu repositorio no depende de él: si GitHub se cae, sigues trabajando y haciendo commits; solo no puedes compartirlos hasta que vuelva. Un repositorio puede tener varios remotos, y cada uno tiene un nombre corto. Por convención, el principal se llama origin (origen).

Un servidor de práctica en tu propia computadora

Para que practiques el trabajo en equipo sin depender de internet, en esta parte simularemos GitHub con un repositorio especial dentro de tu carpeta personal: ~/servidor/aroma.git. Es un repositorio bare (desnudo): solo tiene la carpeta de Git, sin archivos de trabajo, exactamente como los que guarda GitHub. Ana y Luis tendrán cada uno su copia en ~/ana y ~/luis. Todo lo que hagas aquí funciona igual con GitHub: solo cambia la dirección del remoto.

git init --bare ~/servidor/aroma.git
Initialized empty Git repository in /home/ana/servidor/aroma.git/

Conectar tu repositorio con el remoto

El repositorio de Ana todavía no conoce ningún remoto:

git remote -v

Con git remote add nombre dirección se lo presentas:

git remote add origin ~/servidor/aroma.git
git remote -v
origin /home/ana/servidor/aroma.git (fetch) origin /home/ana/servidor/aroma.git (push)

Aparece dos veces porque se usa una dirección para traer (fetch) y otra para enviar (push); casi siempre son la misma. Con GitHub, el comando sería así (lo harás en el capítulo 23):

git remote add origin git@github.com:aromaypunto/aroma.git

El primer envío: git push -u

git push sube tus commits al remoto. La primera vez se indica a qué remoto y qué rama; la opción -u deja anotada esa relación para que después baste con git push a secas:

git push -u origin main
To /home/ana/servidor/aroma.git * [new branch] main -> main branch 'main' set up to track 'origin/main'.
git branch -vv
* main d077686 [origin/main] Crea la portada
git branch -a
* main remotes/origin/main
git log --oneline
d077686 (HEAD -> main, origin/main) Crea la portada

«Rama main configurada para seguir a origin/main». git branch -vv muestra esa relación entre corchetes y git branch -a lista también las ramas remotas.

La rama local y su rama de seguimiento d077686 main origin/main HEAD
Fig. 22.2 · origin/main (gris) es la última foto que tu repositorio tiene de la rama main del remoto. Git la actualiza cada vez que te comunicas con él.

main y origin/main no son lo mismo

En tu repositorio hay dos etiquetas: main, tu rama, que avanza con tus commits; y origin/main, una rama de seguimiento que recuerda dónde estaba main en el remoto la última vez que hablaste con él. No la mueves tú: la actualiza Git al hacer push, fetch o pull. Comparar ambas es lo que permite a Git decirte «vas 2 commits adelante» o «estás 1 commit atrás».

ComandoQué hace
git remote -vLista los remotos con sus direcciones
git remote add origin URLAgrega un remoto llamado origin
git remote rename viejo nuevoCambia el nombre de un remoto
git remote remove nombreQuita un remoto (no borra nada en el servidor)
git push -u origin mainSube main y deja configurado el seguimiento
git branch -vvMuestra qué rama remota sigue cada rama local
Regla de oro: un remoto es un punto de encuentro, no tu respaldo único: tu repositorio local es completo. Aun así, sube tu trabajo con frecuencia; lo que no está en el remoto, tu equipo no lo puede ver.

Practica

BásicoYa existe el servidor de práctica ~/servidor/aroma.git (vacío). Conecta el repositorio de Ana con él como origin, sube main dejando configurado el seguimiento y compruébalo.

Ver solución 1
git remote add origin ~/servidor/aroma.git
git push -u origin main
git branch -vv
To /home/ana/servidor/aroma.git * [new branch] main -> main branch 'main' set up to track 'origin/main'. * main d077686 [origin/main] Crea la portada

[origin/main] entre corchetes confirma el seguimiento: desde ahora basta git push a secas.

RetoAl agregar el remoto, Ana escribió orgin en lugar de origin. Corrige el nombre sin borrar el remoto, verifica y haz el primer envío.

Ver solución 2
git remote -v
git remote rename orgin origin
git remote -v
git push -u origin main
orgin /home/ana/servidor/aroma.git (fetch) orgin /home/ana/servidor/aroma.git (push) origin /home/ana/servidor/aroma.git (fetch) origin /home/ana/servidor/aroma.git (push) To /home/ana/servidor/aroma.git * [new branch] main -> main branch 'main' set up to track 'origin/main'.

git remote rename cambia solo el nombre corto en tu repositorio; la dirección y el servidor no se tocan.

Puntos clave

  • Un remoto es otro repositorio con el que te sincronizas; el principal se llama origin.
  • git remote add origin URL lo conecta; git push -u origin main hace el primer envío.
  • origin/main es la última foto que tienes de la rama main del remoto.
  • Un repositorio bare (como los de GitHub) guarda solo el historial, sin archivos de trabajo.

23 · Tu cuenta de GitHub y las llaves SSH

Intermedio ~18 min

Para que tu repositorio hable con GitHub, GitHub necesita saber que eres tú. Podrías escribir usuario y clave cada vez, pero la forma profesional (y más cómoda) es una llave SSH: la generas una vez por computadora, la registras en tu cuenta y desde entonces Git se conecta solo y de forma segura.

En este capítulo aprenderás a:

  • crear tu cuenta de GitHub y protegerla;
  • generar un par de llaves SSH y entender qué parte se comparte;
  • registrar la llave en GitHub y probar la conexión;
  • crear un repositorio en GitHub y conectarlo con el tuyo.

Paso 1 · Crea tu cuenta

  1. Entra a github.com/signup y regístrate con el mismo correo que configuraste en user.email (capítulo 4).
  2. Elige un nombre de usuario profesional: aparecerá en tus repositorios y en tu portafolio.
  3. Activa la autenticación de dos factores (2FA). Desde 2023, GitHub la exige a todos los que contribuyen código, y protege tu cuenta aunque alguien descubra tu clave.

Paso 2 · Genera tu par de llaves

Una llave SSH son dos archivos: uno privado, que nunca sale de tu computadora, y uno público, que entregas a GitHub. Funcionan como un candado y su llave: GitHub tiene el candado (la pública) y solo tu computadora tiene la llave que lo abre (la privada). En tu terminal:

ssh-keygen -t ed25519 -C "ana@aromaypunto.pe"

El programa te hará tres preguntas:

Pregunta (en inglés)Qué responder
Enter file in which to save the keyPresiona Enter para aceptar la ubicación por defecto.
Enter passphraseUna frase para proteger la llave privada (recomendado). Al escribirla no verás nada en pantalla: es normal.
Enter same passphrase againLa misma frase, para confirmarla.

Se crean dos archivos en la carpeta oculta ~/.ssh. El que termina en .pub es el público:

ls ~/.ssh
id_ed25519 id_ed25519.pub
cat ~/.ssh/id_ed25519.pub
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIRMqec8df0asNWgpEbCyvlPbel9KhvRSQf8UlxjI/2j ana@aromaypunto.pe
Nunca compartas id_ed25519 (sin .pub). Es tu llave privada. No la envíes por correo, no la subas a ningún repositorio y no la copies a otra computadora: si cambias de equipo, genera un par nuevo.

Paso 3 · Carga la llave en el agente

Si le pusiste frase, el agente SSH la recuerda durante tu sesión para que no la escribas en cada push:

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Paso 4 · Registra la llave pública en GitHub

  1. Muestra la llave pública con cat ~/.ssh/id_ed25519.pub y copia la línea completa (empieza con ssh-ed25519). En Git Bash de Windows también puedes copiarla directo con clip < ~/.ssh/id_ed25519.pub.
  2. En GitHub: tu foto (arriba a la derecha) → Settings → sección Access → SSH and GPG keys → New SSH key.
  3. En Title escribe un nombre que identifique la computadora («Laptop de Ana»), pega la llave en Key y guarda.

Paso 5 · Prueba la conexión

ssh -T git@github.com

La primera vez, SSH te muestra la huella del servidor y pregunta si confías en él:

The authenticity of host 'github.com (IP ADDRESS)' can't be established. ED25519 key fingerprint is SHA256:+DiY3wvvV6TuJJhbpZisF/zLDA0zPMSvHdkr4UvCOqU. Are you sure you want to continue connecting (yes/no)?

Comprueba que la huella coincida con la que publica GitHub (es la de arriba), escribe yes y presiona Enter. Si todo está bien, GitHub responde con tu nombre de usuario:

Hi USERNAME! You've successfully authenticated, but GitHub does not provide shell access.

«Te autenticaste correctamente, pero GitHub no ofrece una terminal»: es el mensaje de éxito. Tu computadora y GitHub ya se reconocen.

Estas salidas son las que documenta GitHub. A diferencia del resto del curso, aquí no podemos mostrarte una sesión ejecutada: depende de tu cuenta. Los textos provienen de la documentación oficial (docs.github.com); en tu pantalla, USERNAME será tu nombre de usuario.

Paso 6 · Crea el repositorio en GitHub y conéctalo

En GitHub, pulsa + → New repository, ponle nombre (aroma), elige si será público o privado y no marques «Add a README» (tu repositorio local ya tiene historia). GitHub te mostrará la dirección SSH; con ella haces lo mismo que en el capítulo 22:

git remote add origin git@github.com:TU-USUARIO/aroma.git
git push -u origin main

Recarga la página del repositorio en GitHub: ahí están tus archivos y tu historial. En el capítulo 26 aprenderás a crear repositorios sin salir de la terminal, con gh.

¿Y por HTTPS?

GitHub también acepta direcciones https://github.com/…. En ese caso Git pide usuario y, en lugar de la clave de tu cuenta (GitHub ya no la acepta para Git), un token de acceso personal. En Windows, Git Credential Manager (incluido en Git for Windows) abre el navegador para que inicies sesión y guarda el acceso.

SSHHTTPS
Direccióngit@github.com:usuario/repo.githttps://github.com/usuario/repo.git
Cómo te identificasLlave SSH registrada una vezToken o Git Credential Manager
VentajaSin claves que escribir ni renovarFunciona en redes que bloquean SSH
Regla de oro: la llave privada (id_ed25519) nunca sale de tu computadora; a GitHub solo va la pública (.pub). Una computadora, un par de llaves.

Practica

BásicoGenera un par de llaves Ed25519 de práctica en ~/.ssh/id_practica (sin frase, solo para este ejercicio), lista los archivos y muestra el tipo y el comentario de la llave pública.

Ver solución 1
mkdir -p ~/.ssh
ssh-keygen -q -t ed25519 -C "ana@aromaypunto.pe" -N "" -f ~/.ssh/id_practica
ls ~/.ssh
cut -d " " -f 1,3 ~/.ssh/id_practica.pub
id_practica id_practica.pub ssh-ed25519 ana@aromaypunto.pe

Solo la .pub se pega en GitHub. En tu llave real usa una frase de contraseña (no pongas -N "").

RetoEl repositorio de Ana está conectado a GitHub por HTTPS y cada push le pide un token. Cámbialo a SSH sin quitar el remoto y comprueba la nueva dirección.

Ver solución 2
git remote -v
git remote set-url origin git@github.com:aromaypunto/aroma.git
git remote -v
origin https://github.com/aromaypunto/aroma.git (fetch) origin https://github.com/aromaypunto/aroma.git (push) origin git@github.com:aromaypunto/aroma.git (fetch) origin git@github.com:aromaypunto/aroma.git (push)

git remote set-url reemplaza la dirección y conserva el nombre y el seguimiento de las ramas. No necesita red.

Puntos clave

  • Cuenta con el mismo correo de user.email y 2FA activada.
  • ssh-keygen -t ed25519 -C correo crea la llave privada y la pública (.pub).
  • La pública se registra en GitHub → Settings → SSH and GPG keys.
  • ssh -T git@github.com responde «Hi usuario!» cuando todo está bien.

24 · Clonar repositorios: git clone

Básico ~14 min

Luis se une al proyecto. No tiene que crear nada desde cero ni copiar carpetas: clona el repositorio remoto y obtiene, en un solo paso, todos los archivos, todo el historial y la conexión con el remoto ya configurada.

En este capítulo aprenderás a:

  • clonar un repositorio con git clone;
  • entender todo lo que trae un clon;
  • clonar en una carpeta con otro nombre y clonar proyectos públicos;
  • preparar el laboratorio de dos personas que usarás en los próximos capítulos.
El laboratorio de equipo en una sola computadora 📁 /home/ana 📁 servidor 📁 aroma.git 📁 ana 📁 aroma 📁 luis 📁 aroma
Fig. 24.1 · servidor/aroma.git hace de GitHub; ana/aroma y luis/aroma son los clones de cada integrante. Puedes reproducirlo tal cual en tu equipo.

git clone

En el capítulo 22, Ana subió su repositorio al servidor de práctica. Luis, en su carpeta, lo clona:

mkdir -p ~/luis && cd ~/luis
git clone ~/servidor/aroma.git
Cloning into 'aroma'... done.
cd aroma
ls
index.html
git log --oneline
d077686 (HEAD -> main, origin/main, origin/HEAD) Crea la portada

«Clonando en aroma… listo». Git creó la carpeta aroma con los archivos y el historial completo: Luis ve el commit de Ana con su autor original.

Qué trae un clon

git remote -v
origin /home/ana/servidor/aroma.git (fetch) origin /home/ana/servidor/aroma.git (push)
git branch -a
* main remotes/origin/HEAD -> origin/main remotes/origin/main
git status
On branch main Your branch is up to date with 'origin/main'. nothing to commit, working tree clean
QuéDetalle
ArchivosLa versión de la rama principal, lista para trabajar.
HistorialTodos los commits de todas las ramas (completo, no solo el último).
Remoto originYa configurado con la dirección desde la que clonaste.
Seguimientomain sigue a origin/main: git push y git pull funcionan sin argumentos.

Cada integrante con su propia identidad

En la vida real, Luis usa su propia computadora con su configuración global (capítulo 4). En el laboratorio, como Ana y Luis comparten tu computadora, configuramos la identidad de Luis solo en su clon (nivel local):

git config user.name "Luis Ramos"
git config user.email "luis@aromaypunto.pe"
git config user.name
Luis Ramos

Así, los commits que hagas dentro de ~/luis/aroma llevarán la firma de Luis, y los de ~/ana/aroma, la de Ana.

Clonar en otra carpeta

Por defecto, la carpeta toma el nombre del repositorio. Si quieres otro, agrégalo al final:

git clone ~/servidor/aroma.git web-cafeteria
Cloning into 'web-cafeteria'... done.
ls web-cafeteria
index.html

Clonar desde GitHub

Con GitHub el comando es el mismo; solo cambia la dirección. En la página del repositorio, el botón verde Code te la muestra:

# Un repositorio de tu equipo (por SSH, con tu llave del capítulo 23)
git clone git@github.com:aromaypunto/aroma.git

# Un proyecto público (por HTTPS, no necesita cuenta)
git clone https://github.com/github/gitignore.git

# Solo el último commit: más rápido en proyectos enormes
git clone --depth 1 https://github.com/github/gitignore.git
¿Y los proyectos de otras personas? Puedes clonar cualquier repositorio público, pero no subir cambios a él. Para proponer mejoras a un proyecto ajeno se hace un fork (tu copia en GitHub) y luego un Pull Request desde él: lo verás en el capítulo 26.
Regla de oro: para unirte a un proyecto que ya existe, clónalo; nunca copies la carpeta de otra persona ni descargues un ZIP. El clon trae el historial y la conexión con el remoto; un ZIP no.

Practica

BásicoComo Luis, clona el servidor de práctica dentro de ~/luis y comprueba la historia y el seguimiento de main.

Ver solución 1
mkdir -p ~/luis && cd ~/luis
git clone ~/servidor/aroma.git
cd aroma
git log --oneline
git branch -vv
Cloning into 'aroma'... done. d077686 (HEAD -> main, origin/main, origin/HEAD) Crea la portada * main d077686 [origin/main] Crea la portada

El clon trae el commit de Ana con su hash original y main ya sigue a origin/main.

RetoClona el servidor en una carpeta llamada aroma-pruebas, configura ahí la identidad de Luis, haz un commit SIN subirlo y demuestra que el repositorio de Ana no se enteró.

Ver solución 2
git clone -q ~/servidor/aroma.git aroma-pruebas
cd aroma-pruebas
git config user.name "Luis Ramos"
git config user.email "luis@aromaypunto.pe"
echo "<footer>Lima</footer>" >> index.html
git commit -q -am "Agrega el pie"
git status -sb
git -C ~/ana/aroma log --oneline
## main...origin/main [ahead 1] d077686 (HEAD -> main, origin/main) Crea la portada

Cada clon es independiente: «ahead 1» indica un commit que solo existe aquí hasta que hagas git push. git -C carpeta ejecuta Git en otra carpeta sin moverte.

Puntos clave

  • git clone URL trae archivos, historial completo y el remoto origin configurado.
  • Después de clonar, main ya sigue a origin/main.
  • git clone URL carpeta usa otro nombre de carpeta.
  • El laboratorio de equipo: ~/servidor/aroma.git (GitHub) y los clones ~/ana/aroma y ~/luis/aroma.

25 · push, fetch y pull: sincronizar sin pisarse

Intermedio ~20 min

Ana y Luis ya tienen cada uno su clon. Ahora empieza lo interesante: los dos hacen commits al mismo tiempo y necesitan intercambiarlos. Para eso hay tres comandos: push sube tus commits, fetch baja los de los demás sin tocar tu trabajo y pull baja e integra en un solo paso.

En este capítulo aprenderás a:

  • subir tus commits con git push;
  • averiguar qué hay de nuevo en el remoto con git fetch sin arriesgar nada;
  • integrar el trabajo de los demás con git pull;
  • entender por qué el servidor rechaza un push y cómo resolverlo sin perder trabajo.

git push: subir tus commits

Luis agrega el horario a la portada y lo sube. Como su main ya sigue a origin/main (lo trajo el clon), le basta con git push a secas:

echo "<p>Abierto de 8:00 a 20:00</p>" >> index.html
git commit -am "Agrega el horario"
[main 6ec06c5] Agrega el horario 1 file changed, 1 insertion(+)
git push
To /home/ana/servidor/aroma.git d077686..6ec06c5 main -> main

La última línea se lee «en el remoto, main pasó de d077686 a 6ec06c5». Con GitHub verías To github.com:aromaypunto/aroma.git; el resto es idéntico.

git status no consulta el remoto

Ana, en su computadora, revisa el estado de su repositorio:

git status
On branch main Your branch is up to date with 'origin/main'. nothing to commit, working tree clean

¡Dice que está al día, pero Luis acaba de subir un commit! No es un error: git status compara tu main con origin/main, la última foto que tu repositorio tiene del remoto (capítulo 22). Esa foto es vieja. Git nunca se conecta a internet por su cuenta: tú decides cuándo.

git fetch: mirar sin tocar

git fetch se conecta al remoto, baja los commits nuevos y actualiza origin/main. No cambia tu rama ni tus archivos, así que puedes ejecutarlo cuando quieras, incluso a mitad de un trabajo:

git fetch
From /home/ana/servidor/aroma d077686..6ec06c5 main -> origin/main
git status
On branch main Your branch is behind 'origin/main' by 1 commit, and can be fast-forwarded. (use "git pull" to update your local branch) nothing to commit, working tree clean

Ahora sí: «tu rama está 1 commit atrás de origin/main y puede avanzar con fast-forward».

Después de git fetch d077686 6ec06c5 main origin/main HEAD
Fig. 25.1 · git fetch trajo el commit de Luis (6ec06c5) y movió origin/main. Tu main y tus archivos siguen igual: estás «1 commit atrás».

Antes de integrar, puedes revisar qué trae Luis. main..origin/main significa «commits que están en origin/main y no en main». Cuando te convenza, lo integras con git merge (sin argumentos, usa la rama que sigues):

git log --oneline main..origin/main
git diff main origin/main
git merge
Already up to date.

git pull: fetch + merge en un paso

En el día a día casi nadie hace fetch y merge por separado: git pull hace las dos cosas seguidas. Partiendo del mismo punto (Ana sin el commit de Luis):

git pull
From /home/ana/servidor/aroma d077686..6ec06c5 main -> origin/main Updating d077686..6ec06c5 Fast-forward index.html | 1 + 1 file changed, 1 insertion(+)
git log --oneline
6ec06c5 (HEAD -> main, origin/main, origin/HEAD) Agrega el horario d077686 Crea la portada
ComandoQué hace¿Cambia tus archivos?
git pushSube tus commits y mueve la rama del remotoNo
git fetchBaja commits nuevos y actualiza origin/mainNo
git pullfetch + integra origin/main en tu ramaSí
git statusCompara tu rama con la última foto del remotoNo

Cuando el servidor dice que no: push rechazado

Repitamos la historia con un detalle: esta vez Ana hizo su propio commit (el menú de bebidas) antes de traer el de Luis, e intenta subirlo:

git push
To /home/ana/servidor/aroma.git ! [rejected] main -> main (fetch first) error: failed to push some refs to '/home/ana/servidor/aroma.git' hint: Updates were rejected because the remote contains work that you do not hint: have locally. This is usually caused by another repository pushing to hint: the same ref. If you want to integrate the remote changes, use hint: 'git pull' before pushing again. hint: See the 'Note about fast-forwards' in 'git push --help' for details.

«Rechazado: el remoto contiene trabajo que no tienes localmente». El servidor se niega porque aceptar el push de Ana borraría el commit de Luis de la rama. Es Git protegiendo a tu equipo, no un error tuyo. Un fetch muestra la situación:

git status
On branch main Your branch and 'origin/main' have diverged, and have 1 and 1 different commits each, respectively. (use "git pull" if you want to integrate the remote branch with yours) nothing to commit, working tree clean
Dos historias que divergen d077686 d9abbb8 6ec06c5 main origin/main HEAD
Fig. 25.2 · Ana hizo d9abbb8 y Luis subió 6ec06c5, ambos desde d077686. Ninguna rama contiene a la otra: el servidor rechaza el push de Ana.

La primera vez: decirle a git pull cómo integrar

La pista dice «usa git pull antes de volver a subir». Pero si es tu primer pull con historias divergentes, Git se detiene y te pide que elijas cómo unirlas:

git pull
From /home/ana/servidor/aroma d077686..6ec06c5 main -> origin/main hint: You have divergent branches and need to specify how to reconcile them. hint: You can do so by running one of the following commands sometime before hint: your next pull: hint: hint: git config pull.rebase false # merge hint: git config pull.rebase true # rebase hint: git config pull.ff only # fast-forward only hint: hint: You can replace "git config" with "git config --global" to set a default hint: preference for all repositories. You can also pass --rebase, --no-rebase, hint: or --ff-only on the command line to override the configured default per hint: invocation. fatal: Need to specify how to reconcile divergent branches.

Hay dos formas de unir dos historias: con un merge (lo que ya conoces del capítulo 16) o con un rebase (capítulo 28). Mientras aprendes, elige merge: no reescribe nada y deja ver claramente qué pasó. Se configura una sola vez:

git config --global pull.rebase false
git pull --no-edit
From /home/ana/servidor/aroma d077686..6ec06c5 main -> origin/main Merge made by the 'ort' strategy. index.html | 1 + 1 file changed, 1 insertion(+)
git log --oneline --graph
* fa7b7b2 (HEAD -> main) Merge branch 'main' of /home/ana/servidor/aroma |\ | * 6ec06c5 (origin/main, origin/HEAD) Agrega el horario * | d9abbb8 Agrega el menú de bebidas |/ * d077686 Crea la portada
git push
To /home/ana/servidor/aroma.git 6ec06c5..fa7b7b2 main -> main

Ese es el ciclo completo: pull creó el commit de merge «Merge branch 'main' of …» con los dos trabajos y el push ya fue aceptado, porque ahora el historial de Ana contiene el commit de Luis.

Después de git pull d077686 d9abbb8 6ec06c5 fa7b7b2 main origin/main HEAD
Fig. 25.3 · git pull = fetch + merge: el commit de merge fa7b7b2 une los dos trabajos. Al hacer git push, origin/main también saltará a él.
ConfiguraciónQué hace git pull con historias divergentes
pull.rebase falseCrea un commit de merge (la que usamos en este curso)
pull.rebase trueReaplica tus commits encima de los del remoto (capítulo 28)
pull.ff onlySe niega a integrar: solo acepta avanzar con fast-forward
¿Y si hay conflicto? Si Ana y Luis hubieran cambiado las mismas líneas, el pull se detendría en un conflicto exactamente como en la parte IV: lo resuelves, git add, git commit y luego git push. Nada nuevo que aprender.

Luis se pone al día

Finalmente, Luis trae el resultado. Para él es un fast-forward: su main solo tiene que avanzar.

git pull
From /home/ana/servidor/aroma 6ec06c5..fa7b7b2 main -> origin/main Updating 6ec06c5..fa7b7b2 Fast-forward menu.html | 1 + 1 file changed, 1 insertion(+) create mode 100644 menu.html
git log --oneline --graph
* fa7b7b2 (HEAD -> main, origin/main, origin/HEAD) Merge branch 'main' of /home/ana/servidor/aroma |\ | * 6ec06c5 Agrega el horario * | d9abbb8 Agrega el menú de bebidas |/ * d077686 Crea la portada

Los dos repositorios y el servidor quedaron idénticos. El hash fa7b7b2 es el mismo en las tres partes.

La rutina diaria

git pull                  # 1. al empezar: trae lo que subió el equipo
# ... editar, git add, git commit (las veces que haga falta) ...
git pull                  # 2. antes de subir: integra lo nuevo (y resuelve si hay conflicto)
git push                  # 3. comparte tu trabajo
Nunca uses git push --force en una rama compartida. Internet está lleno de respuestas que «arreglan» el push rechazado con --force. Lo que hace es reemplazar la rama del remoto por la tuya y borrar los commits de tus compañeros. La solución correcta siempre es pull y después push.
Regla de oro: haz pull antes de empezar y antes de cada push; haz push en cuanto termines algo que funciona. Cuanto más tiempo pases sin sincronizar, más divergen las historias y más probables son los conflictos.

Practica

BásicoLuis subió un commit. Como Ana, averigua cuántos commits te faltan sin tocar tus archivos y luego tráelos.

Ver solución 1
git fetch
git status -sb
git pull
From /home/ana/servidor/aroma d077686..6ec06c5 main -> origin/main ## main...origin/main [behind 1] Updating d077686..6ec06c5 Fast-forward index.html | 1 + 1 file changed, 1 insertion(+)

git status -sb resume el estado en una línea: [behind 1]. El pull es un fast-forward.

RetoAna hizo un commit sin traer el de Luis y su push es rechazado. Sin configurar nada de forma global, intégralo con un merge (opción --no-rebase), súbelo y muestra el grafo.

Ver solución 2
git push
git pull --no-rebase --no-edit
git push
git log --oneline --graph
To /home/ana/servidor/aroma.git ! [rejected] main -> main (fetch first) error: failed to push some refs to '/home/ana/servidor/aroma.git' hint: Updates were rejected because the remote contains work that you do not hint: have locally. This is usually caused by another repository pushing to hint: the same ref. If you want to integrate the remote changes, use hint: 'git pull' before pushing again. hint: See the 'Note about fast-forwards' in 'git push --help' for details. From /home/ana/servidor/aroma d077686..6ec06c5 main -> origin/main Merge made by the 'ort' strategy. index.html | 1 + 1 file changed, 1 insertion(+) To /home/ana/servidor/aroma.git 6ec06c5..fa7b7b2 main -> main * fa7b7b2 (HEAD -> main, origin/main, origin/HEAD) Merge branch 'main' of /home/ana/servidor/aroma |\ | * 6ec06c5 Agrega el horario * | d9abbb8 Agrega el menú de bebidas |/ * d077686 Crea la portada

El primer push falla (fetch first). --no-rebase equivale a pull.rebase false solo para esa vez; tras el merge el push ya es aceptado.

Puntos clave

  • git push sube tus commits; el remoto lo rechaza si tiene commits que tú no tienes.
  • git fetch actualiza origin/main sin tocar tu rama: siempre es seguro.
  • git status solo compara con la última foto del remoto: haz fetch para saber la verdad.
  • git pull = fetch + merge; configura pull.rebase false una vez.
  • Push rechazado ⇒ pull, resolver si hace falta, push. Nunca --force en una rama compartida.

26 · Pull Requests desde la terminal con gh

Intermedio ~22 min

En un equipo nadie sube cambios directamente a main. Cada tarea se hace en su propia rama y, cuando está lista, se propone integrarla: eso es un Pull Request (PR), una solicitud para que tu rama se fusione, con un espacio para que el equipo revise el código, comente y apruebe. Lo harás todo desde la terminal con gh, la herramienta oficial de GitHub.

En este capítulo aprenderás a:

  • instalar GitHub CLI (gh) e iniciar sesión;
  • crear un repositorio en GitHub sin salir de la terminal;
  • abrir, revisar, aprobar y fusionar un Pull Request;
  • elegir entre las tres formas de fusionar que ofrece GitHub.

El ciclo de un Pull Request

  1. Crear una rama para la tarea (capítulo 14) y hacer commits.
  2. Subir la rama al remoto con git push -u.
  3. Abrir el Pull Request: «quiero integrar feature/contacto en main».
  4. Un compañero revisa, comenta y aprueba (o pide cambios: subes más commits a la misma rama y el PR se actualiza solo).
  5. Se fusiona en GitHub y se borra la rama.
El flujo de un Pull Request d077686 e9e40be 55629d6 main feature/contacto Pull Request #1
Fig. 26.1 · Ana trabaja en feature/contacto, la sube y abre un Pull Request. Tras la revisión, GitHub la fusiona en main con un commit de merge (55629d6) y la rama se borra.

Instalar GitHub CLI

SistemaComando
Windowswinget install --id GitHub.cli --source winget
macOSbrew install gh
Ubuntu / DebianRepositorio oficial (bloque de abajo)

En Ubuntu, la documentación oficial de GitHub CLI indica agregar su repositorio de paquetes (así recibes las actualizaciones con apt):

(type -p wget >/dev/null || (sudo apt update && sudo apt install wget -y)) \
  && sudo mkdir -p -m 755 /etc/apt/keyrings \
  && out=$(mktemp) && wget -nv -O$out https://cli.github.com/packages/githubcli-archive-keyring.gpg \
  && cat $out | sudo tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null \
  && sudo chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg \
  && sudo mkdir -p -m 755 /etc/apt/sources.list.d \
  && echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null \
  && sudo apt update \
  && sudo apt install gh -y

Comprueba la instalación (en Windows, abre una ventana nueva de Git Bash):

gh --version
gh version 2.102.0 (2026-09-30) https://github.com/cli/cli/releases/tag/v2.102.0

Iniciar sesión: gh auth login

Se hace una vez por computadora. gh te hace unas preguntas que respondes con las flechas y Enter. Como en el capítulo 23 ya registraste tu llave SSH, elige SSH y omite (Skip) la subida de la llave:

gh auth login
? Where do you use GitHub? GitHub.com ? What is your preferred protocol for Git operations on this host? SSH ? Upload your SSH public key to your GitHub account? Skip ? How would you like to authenticate GitHub CLI? Login with a web browser ! First copy your one-time code: XXXX-XXXX Press Enter to open https://github.com/login/device in your browser... ✓ Authentication complete. - gh config set -h github.com git_protocol ssh ✓ Configured git protocol ✓ Logged in as USUARIO

Copia el código de un solo uso, presiona Enter, pégalo en la página que se abre y autoriza a GitHub CLI. Desde entonces gh actúa en tu nombre. gh auth status te dice en cualquier momento con qué cuenta estás conectado.

Salidas tomadas del código de gh 2.102.0. Como en el capítulo 23, esta parte depende de tu cuenta y no se puede ejecutar en el laboratorio: XXXX-XXXX será tu código y USUARIO, tu nombre de usuario.

Crear el repositorio en GitHub desde la terminal

En el capítulo 23 creaste el repositorio en la web. Con gh, desde la carpeta de tu proyecto, un solo comando lo crea, agrega el remoto origin y sube tus commits:

gh repo create aroma --private --source=. --remote=origin --push

Usa --public si quieres que cualquiera pueda verlo (por ejemplo, para tu portafolio).

Paso 1 · Trabajar en una rama

Ana recibe la tarea de crear la página de contacto. Lo primero es su rama:

git switch -c feature/contacto
Switched to a new branch 'feature/contacto'
echo "<p>Escríbenos: hola@aromaypunto.pe</p>" > contacto.html
git add contacto.html
git commit -m "Agrega la página de contacto"
[feature/contacto e9e40be] Agrega la página de contacto 1 file changed, 1 insertion(+) create mode 100644 contacto.html

Paso 2 · Subir la rama

Una rama nueva se sube igual que main en el capítulo 22: la primera vez con -u.

git push -u origin feature/contacto
To /home/ana/servidor/aroma.git * [new branch] feature/contacto -> feature/contacto branch 'feature/contacto' set up to track 'origin/feature/contacto'.

«[new branch]»: ahora la rama existe también en el remoto, y GitHub ya puede compararla con main.

Paso 3 · Abrir el Pull Request

gh pr create --base main --title "Agrega la página de contacto" --body "Nueva página con el correo de atención."
Creating pull request for feature/contacto into main in aromaypunto/aroma https://github.com/aromaypunto/aroma/pull/1

«Creando el pull request de feature/contacto hacia main». El PR recibe un número (#1) y una dirección web donde el equipo verá los cambios y los comentarios. Si escribes solo gh pr create, te pregunta el título y la descripción; con --fill los toma de tus commits.

Paso 4 · Revisar

Luis, desde su clon, ve los PR abiertos, los lee y prueba los cambios en su computadora:

gh pr list               # PR abiertos del repositorio
gh pr view 1             # título, descripción, estado y revisiones
gh pr diff 1             # los cambios, como git diff
gh pr checkout 1         # trae la rama del PR para probarla

Si todo está bien, lo aprueba; si algo falta, pide cambios con --request-changes:

gh pr review 1 --approve --body "Probado en mi equipo, todo bien."
✓ Approved pull request aromaypunto/aroma#1

Paso 5 · Fusionar y limpiar

gh pr merge 1 --merge --delete-branch
✓ Merged pull request aromaypunto/aroma#1 (Agrega la página de contacto) ✓ Deleted local branch feature/contacto and switched to branch main ✓ Deleted remote branch feature/contacto

GitHub fusionó la rama en main y gh borró la rama en GitHub y en tu computadora. Falta lo de siempre: traer el resultado. En el laboratorio simulamos lo que hizo GitHub y Ana sincroniza:

git pull
From /home/ana/servidor/aroma d077686..55629d6 main -> origin/main Updating d077686..55629d6 Fast-forward contacto.html | 1 + 1 file changed, 1 insertion(+) create mode 100644 contacto.html
git log --oneline --graph
* 55629d6 (HEAD -> main, origin/main, origin/HEAD) Merge pull request #1 from aromaypunto/feature/contacto |\ | * e9e40be (origin/feature/contacto) Agrega la página de contacto |/ * d077686 Crea la portada

El commit «Merge pull request #1 from aromaypunto/feature/contacto» es el que crea GitHub: deja en el historial qué PR integró cada cambio. ¿Y origin/feature/contacto? Es la foto vieja de una rama que ya no existe en el remoto; Git no la borra por su cuenta. En el capítulo 27 aprenderás a limpiarla.

Tres formas de fusionar

Opción de gh pr mergeEn GitHubResultado en main
--mergeCreate a merge commitTodos los commits de la rama + un commit de merge (lo que viste arriba)
--squashSquash and mergeUn solo commit nuevo con todos los cambios de la rama
--rebaseRebase and mergeLos commits de la rama, copiados uno tras otro sin commit de merge (capítulo 28)

Cada equipo elige una y la usa siempre. Si no indicas ninguna, gh pr merge te pregunta.

Proyectos ajenos: fork. Para proponer cambios a un repositorio donde no puedes subir ramas, primero haces tu copia en GitHub con gh repo fork dueño/proyecto --clone, trabajas en ella y abres el PR desde tu fork. Es la forma de contribuir al software libre.
Regla de oro: una tarea = una rama = un Pull Request. Nunca hagas commits directamente en main de un proyecto compartido: todo cambio entra por un PR revisado.

Practica

BásicoPrepara una rama feature/horario para un Pull Request: agrega el horario a la portada, haz el commit, sube la rama y comprueba que ya existe en el remoto.

Ver solución 1
git switch -c feature/horario
echo "<p>Abierto de 8:00 a 20:00</p>" >> index.html
git commit -am "Agrega el horario"
git push -u origin feature/horario
git branch -r
Switched to a new branch 'feature/horario' [feature/horario b58bde1] Agrega el horario 1 file changed, 1 insertion(+) To /home/ana/servidor/aroma.git * [new branch] feature/horario -> feature/horario branch 'feature/horario' set up to track 'origin/feature/horario'. origin/feature/horario origin/main

Con la rama en el remoto, el siguiente paso sería gh pr create --fill.

RetoAna subió feature/contacto para su PR. Como Luis, y sin gh, trae la rama a tu computadora para probarla y comprueba qué commit trae.

Ver solución 2
git fetch
git switch feature/contacto
git log --oneline -1
From /home/ana/servidor/aroma * [new branch] feature/contacto -> origin/feature/contacto Switched to a new branch 'feature/contacto' branch 'feature/contacto' set up to track 'origin/feature/contacto'. e9e40be (HEAD -> feature/contacto, origin/feature/contacto) Agrega la página de contacto

Si existe origin/feature/contacto, git switch crea la rama local que la sigue: es lo que hace gh pr checkout por ti.

Puntos clave

  • Un Pull Request propone integrar una rama y abre un espacio de revisión.
  • gh auth login conecta la terminal con tu cuenta; gh repo create crea el remoto.
  • Ciclo: rama → commits → git push -u → gh pr create → gh pr review → gh pr merge.
  • Tras fusionar, git pull en main para traer el commit de merge.
  • GitHub fusiona de tres formas: merge commit, squash o rebase.

27 · Trabajo concurrente: el día a día de un equipo

Intermedio ~22 min

Ya conoces todas las piezas: ramas, conflictos, remotos y Pull Requests. En este capítulo las juntamos en una jornada real: Ana y Luis trabajan al mismo tiempo en tareas distintas que tocan el mismo archivo. Verás qué hacer cuando el PR de tu compañero se fusiona antes que el tuyo y cómo mantener ordenado tu repositorio.

En este capítulo aprenderás a:

  • trabajar en paralelo con ramas y Pull Requests;
  • poner al día tu rama con lo último de main antes de fusionar;
  • resolver en tu rama los conflictos con el trabajo de los demás;
  • limpiar las ramas que ya se fusionaron.

Cada uno en su rama

Luis se encarga de la galería de fotos y agrega un enlace al final de la portada:

cd ~/luis/aroma && git switch -c feature/galeria
Switched to a new branch 'feature/galeria'
echo "<h1>Galería</h1>" > galeria.html
echo '<a href="galeria.html">Galería</a>' >> index.html
git add . && git commit -m "Agrega la galería de fotos"
[feature/galeria b080830] Agrega la galería de fotos 2 files changed, 2 insertions(+) create mode 100644 galeria.html
git push -u origin feature/galeria
To /home/ana/servidor/aroma.git * [new branch] feature/galeria -> feature/galeria branch 'feature/galeria' set up to track 'origin/feature/galeria'.

Al mismo tiempo, Ana hace la página de reservas y también agrega su enlace al final de la portada:

cd ~/ana/aroma && git switch -c feature/reservas
Switched to a new branch 'feature/reservas'
echo "<h1>Reservas</h1>" > reservas.html
echo '<a href="reservas.html">Reservas</a>' >> index.html
git add . && git commit -m "Agrega la página de reservas"
[feature/reservas 90521e1] Agrega la página de reservas 2 files changed, 2 insertions(+) create mode 100644 reservas.html
git push -u origin feature/reservas
To /home/ana/servidor/aroma.git * [new branch] feature/reservas -> feature/reservas branch 'feature/reservas' set up to track 'origin/feature/reservas'.
Dos tareas al mismo tiempo d077686 b080830 90521e1 main feature/galeria feature/reservas
Fig. 27.1 · Luis (galería) y Ana (reservas) parten del mismo main y trabajan en paralelo, cada uno en su rama y su Pull Request.

Ninguno sabe lo que hizo el otro, y está bien: cada uno abre su Pull Request (capítulo 26). El de Luis se revisa y se fusiona primero.

Tu rama se quedó atrás

Antes de que fusionen su PR, Ana revisa cómo está el remoto:

git fetch
From /home/ana/servidor/aroma d077686..dba3e30 main -> origin/main
git log --oneline --graph --all
* dba3e30 (origin/main, origin/HEAD) Merge pull request #2 from aromaypunto/feature/galeria |\ | * b080830 Agrega la galería de fotos |/ | * 90521e1 (HEAD -> feature/reservas, origin/feature/reservas) Agrega la página de reservas |/ * d077686 (main) Crea la portada

El grafo lo cuenta todo: origin/main ya incluye la galería (PR #2), pero feature/reservas salió de un main más antiguo. Como los dos agregaron una línea en el mismo lugar de index.html, GitHub mostrará en el PR de Ana que hay conflictos y no dejará fusionarlo.

Traer main a tu rama

La solución es integrar origin/main en tu rama y resolver el conflicto tú, en tu computadora, donde puedes probar el resultado:

git merge origin/main
Auto-merging index.html CONFLICT (content): Merge conflict in index.html Automatic merge failed; fix conflicts and then commit the result.
cat index.html
<h1>Aroma y Punto</h1> <<<<<<< HEAD <a href="reservas.html">Reservas</a> ======= <a href="galeria.html">Galería</a> >>>>>>> origin/main

Es el mismo conflicto de la parte IV. Las dos líneas deben quedar, así que Ana escribe la versión final, la marca como resuelta y sube su rama actualizada:

cat > index.html << 'FIN'
<h1>Aroma y Punto</h1>
<a href="galeria.html">Galería</a>
<a href="reservas.html">Reservas</a>
FIN
git add index.html
git commit --no-edit
[feature/reservas ae4a7ca] Merge remote-tracking branch 'origin/main' into feature/reservas
git push
To /home/ana/servidor/aroma.git 90521e1..ae4a7ca feature/reservas -> feature/reservas
Ana trae main a su rama d077686 b080830 dba3e30 90521e1 ae4a7ca origin/main feature/reservas HEAD
Fig. 27.2 · Ana integra origin/main (que ya tiene la galería) en su rama y resuelve ahí el conflicto (ae4a7ca). Su Pull Request queda listo para fusionarse sin sorpresas.

El PR de Ana se actualiza solo con el nuevo commit, ya no tiene conflictos y se puede revisar y fusionar.

¿Por qué no resolverlo directamente en main? Porque main debe estar siempre estable. Resolviendo en tu rama, el conflicto lo arregla quien conoce el cambio, se prueba antes de entrar y el revisor ve el resultado final.

Limpiar después de fusionar

Cuando GitHub fusiona un PR y borra la rama, tu copia local y su rama de seguimiento quedan huérfanas. Luis lo ve con git fetch --prune (prune = podar), que borra las ramas de seguimiento cuya rama ya no existe en el remoto:

git fetch --prune
From /home/ana/servidor/aroma - [deleted] (none) -> origin/feature/galeria * [new branch] feature/reservas -> origin/feature/reservas d077686..dba3e30 main -> origin/main
git branch -vv
* feature/galeria b080830 [origin/feature/galeria: gone] Agrega la galería de fotos main d077686 [origin/main: behind 2] Crea la portada
git switch main
Switched to branch 'main' Your branch is behind 'origin/main' by 2 commits, and can be fast-forwarded. (use "git pull" to update your local branch)
git pull
Updating d077686..dba3e30 Fast-forward galeria.html | 1 + index.html | 1 + 2 files changed, 2 insertions(+) create mode 100644 galeria.html
git branch -d feature/galeria
Deleted branch feature/galeria (was b080830).

«gone» (desaparecida) indica que la rama remota ya no existe. Luis vuelve a main, la pone al día y borra su rama local con git branch -d, que solo borra ramas ya fusionadas: si te equivocas de rama, Git se niega.

Cuando fusionan el PR de Ana, ella hace lo mismo (git pull --prune poda mientras trae):

git switch main
Switched to branch 'main' Your branch is behind 'origin/main' by 2 commits, and can be fast-forwarded. (use "git pull" to update your local branch)
git pull --prune
From /home/ana/servidor/aroma - [deleted] (none) -> origin/feature/reservas dba3e30..a9ed2c1 main -> origin/main Updating d077686..a9ed2c1 Fast-forward galeria.html | 1 + index.html | 2 ++ reservas.html | 1 + 3 files changed, 4 insertions(+) create mode 100644 galeria.html create mode 100644 reservas.html
git branch -d feature/reservas
Deleted branch feature/reservas (was ae4a7ca).
git log --oneline --graph
* a9ed2c1 (HEAD -> main, origin/main, origin/HEAD) Merge pull request #3 from aromaypunto/feature/reservas |\ | * ae4a7ca Merge remote-tracking branch 'origin/main' into feature/reservas | |\ | |/ |/| * | dba3e30 Merge pull request #2 from aromaypunto/feature/galeria |\ \ | * | b080830 Agrega la galería de fotos |/ / | * 90521e1 Agrega la página de reservas |/ * d077686 Crea la portada

Los dos PR quedaron en main, cada uno con su commit de merge. Para no tener que acordarte de podar:

git config --global fetch.prune true

La jornada de un equipo

git switch main && git pull              # 1. empezar al día
git switch -c feature/tarea               # 2. una rama por tarea
# ... commits pequeños ...
git fetch && git merge origin/main        # 3. al terminar: traer lo último y resolver
git push -u origin feature/tarea          # 4. subir la rama
gh pr create --fill                       # 5. abrir el Pull Request
# ... revisión, cambios, aprobación, gh pr merge ...
git switch main && git pull --prune       # 6. volver a main al día
git branch -d feature/tarea               # 7. borrar la rama fusionada
Buena prácticaPor qué
Ramas cortas (horas o pocos días)Cuanto menos tiempo vive una rama, menos se aleja de main y menos conflictos hay.
PR pequeñosUn PR de 50 líneas se revisa bien; uno de 2000 se aprueba sin leer.
Nombres descriptivosfeature/reservas, fix/precio-americano: se sabe qué es sin abrirla.
Traer main a menudoResolver un conflicto pequeño hoy es más fácil que uno grande al final.
Avisar al equipoSi vas a tocar un archivo central, coméntalo: muchos conflictos se evitan hablando.
Regla de oro: antes de pedir que fusionen tu rama, trae main a ella y resuelve ahí los conflictos. Tu PR debe poder fusionarse sin que nadie tenga que arreglar nada.

Practica

BásicoEl PR de Luis (feature/galeria) ya se fusionó en GitHub. Vuelve a main, ponla al día podando las ramas remotas borradas, lista las ramas ya fusionadas y borra la tuya.

Ver solución 1
git switch main
git pull --prune
git branch --merged
git branch -d feature/galeria
Switched to branch 'main' Your branch is up to date with 'origin/main'. From /home/ana/servidor/aroma - [deleted] (none) -> origin/feature/galeria d077686..dba3e30 main -> origin/main * [new branch] feature/reservas -> origin/feature/reservas Updating d077686..dba3e30 Fast-forward galeria.html | 1 + index.html | 1 + 2 files changed, 2 insertions(+) create mode 100644 galeria.html feature/galeria * main Deleted branch feature/galeria (was b080830).

git branch --merged lista las ramas cuyo trabajo ya está en la rama actual: son las que puedes borrar.

RetoAna sigue en feature/reservas y main ya tiene la galería. Trae main del remoto a su rama en un solo comando (con merge), resuelve el conflicto conservando los dos enlaces y sube la rama.

Ver solución 2
git pull --no-rebase origin main
cat > index.html << 'FIN'
<h1>Aroma y Punto</h1>
<a href="galeria.html">Galería</a>
<a href="reservas.html">Reservas</a>
FIN
git add index.html
git commit --no-edit
git push
From /home/ana/servidor/aroma * branch main -> FETCH_HEAD d077686..dba3e30 main -> origin/main Auto-merging index.html CONFLICT (content): Merge conflict in index.html Automatic merge failed; fix conflicts and then commit the result. [feature/reservas c17b1be] Merge branch 'main' of /home/ana/servidor/aroma into feature/reservas To /home/ana/servidor/aroma.git 90521e1..c17b1be feature/reservas -> feature/reservas

git pull origin main = git fetch origin main + git merge origin/main sobre tu rama actual.

Puntos clave

  • Cada tarea va en su rama y su PR; el trabajo en paralelo es lo normal.
  • Si main avanzó, git fetch + git merge origin/main pone al día tu rama.
  • Los conflictos se resuelven en tu rama, no en main.
  • git fetch --prune borra ramas de seguimiento huérfanas; git branch -vv las marca como «gone».
  • git branch -d borra una rama local solo si ya se fusionó.

28 · Rebase: historia lineal y su regla de oro

Avanzado ~24 min

Hasta ahora, para unir dos ramas usaste merge, que conserva la historia tal como ocurrió (con sus bifurcaciones y commits de merge). rebase es la alternativa: reescribe tu rama como si la hubieras empezado después, sobre lo último de main, y deja una historia en línea recta. Es muy útil, y tiene una regla que nunca debes romper.

En este capítulo aprenderás a:

  • entender qué hace git rebase y en qué se diferencia de merge;
  • actualizar tu rama con rebase y resolver conflictos durante el proceso;
  • subir una rama rebasada con --force-with-lease sin riesgo para el equipo;
  • ordenar tus commits con el rebase interactivo antes de un Pull Request.

El punto de partida

Ana tiene dos commits en feature/promo (ya subidos para su PR), pero main avanzó mientras tanto:

git log --oneline --graph --all
* 48ace4a (origin/main, main) Agrega el horario | * e5f4d1a (HEAD -> feature/promo, origin/feature/promo) Agrega el 2x1 de los lunes | * fe759e6 Agrega la página de promociones |/ * d077686 Crea la portada
Antes del rebase d077686 48ace4a fe759e6 e5f4d1a main feature/promo HEAD
Fig. 28.1 · feature/promo salió de d077686; después, main avanzó con el horario. Un merge uniría ambas con un commit extra.

git rebase main

Desde su rama, Ana le pide a Git que la «re-base»: que la mueva para que empiece en la punta actual de main.

git rebase main
Rebasing (1/2) Rebasing (2/2) Successfully rebased and updated refs/heads/feature/promo.
git log --oneline --graph --all
* fe609dc (HEAD -> feature/promo) Agrega el 2x1 de los lunes * 345047e Agrega la página de promociones * 48ace4a (origin/main, main) Agrega el horario | * e5f4d1a (origin/feature/promo) Agrega el 2x1 de los lunes | * fe759e6 Agrega la página de promociones |/ * d077686 Crea la portada

Git tomó cada commit de la rama y lo volvió a aplicar, uno por uno, encima de main (1/2, 2/2). Mira los hashes: fe759e6 ahora es 345047e y e5f4d1a es fe609dc. Mismo cambio, mismo mensaje, pero commits distintos, porque su padre cambió.

Después del rebase d077686 48ace4a 345047e fe609dc fe759e6 e5f4d1a main feature/promo origin/feature/promo HEAD
Fig. 28.2 · Git copió los dos commits encima de main: son commits nuevos (otros hashes). Los originales (tenues) quedan huérfanos; el remoto todavía apunta a ellos.

Subir una rama rebasada

Como los commits del remoto ya no están en la rama de Ana, el push normal se rechaza:

git push
To /home/ana/servidor/aroma.git ! [rejected] feature/promo -> feature/promo (non-fast-forward) error: failed to push some refs to '/home/ana/servidor/aroma.git' hint: Updates were rejected because the tip of your current branch is behind hint: its remote counterpart. If you want to integrate the remote changes, hint: use 'git pull' before pushing again. hint: See the 'Note about fast-forwards' in 'git push --help' for details.
git push --force-with-lease
To /home/ana/servidor/aroma.git + e5f4d1a...fe609dc feature/promo -> feature/promo (forced update)

--force-with-lease reemplaza la rama remota por la tuya, pero solo si nadie subió nada nuevo a ella desde tu último fetch; si alguien lo hizo, se niega y no pierdes su trabajo. Por eso se prefiere al --force a secas. Úsalo solo en tu propia rama de trabajo.

Ahora la rama está justo encima de main, así que integrarla es un fast-forward, sin commit de merge:

git switch main
Switched to branch 'main' Your branch is up to date with 'origin/main'.
git merge feature/promo
Updating 48ace4a..fe609dc Fast-forward promo.html | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 promo.html
git log --oneline
fe609dc (HEAD -> main, origin/feature/promo, feature/promo) Agrega el 2x1 de los lunes 345047e Agrega la página de promociones 48ace4a (origin/main) Agrega el horario d077686 Crea la portada

Conflictos durante un rebase

Como cada commit se vuelve a aplicar, un rebase puede detenerse en un conflicto. Supongamos que en main alguien creó promo.html con otro título:

git rebase main
Rebasing (1/2) Auto-merging promo.html CONFLICT (add/add): Merge conflict in promo.html error: could not apply fe759e6... Agrega la página de promociones hint: Resolve all conflicts manually, mark them as resolved with hint: "git add/rm <conflicted_files>", then run "git rebase --continue". hint: You can instead skip this commit: run "git rebase --skip". hint: To abort and get back to the state before "git rebase", run "git rebase --abort". hint: Disable this message with "git config set advice.mergeConflict false" Could not apply fe759e6... # Agrega la página de promociones
cat promo.html
<<<<<<< HEAD <h2>Promo de octubre</h2> ======= <h2>Promo del mes</h2> >>>>>>> fe759e6 (Agrega la página de promociones)

Lo resuelves como siempre (parte IV), pero en lugar de git commit usas git rebase --continue. Git abrirá tu editor con el mensaje del commit: guárdalo y ciérralo sin cambiarlo.

printf "<h2>Promo del mes</h2>\n" > promo.html
git add promo.html
git rebase --continue
[detached HEAD 0b74e1e] Agrega la página de promociones 1 file changed, 1 insertion(+), 1 deletion(-) Rebasing (2/2) Successfully rebased and updated refs/heads/feature/promo.
git log --oneline
80815e4 (HEAD -> feature/promo) Agrega el 2x1 de los lunes 0b74e1e Agrega la página de promociones 3b74986 (main) Crea la promo de octubre 48ace4a (origin/main) Agrega el horario d077686 Crea la portada
Durante un rebaseQué hace
git rebase --continueSigue con el siguiente commit tras resolver y hacer git add
git rebase --skipDescarta el commit que está aplicando
git rebase --abortCancela todo y deja la rama como estaba antes

git pull --rebase

En el capítulo 25, cuando la historia de Ana y la del remoto divergieron, git pull creó un commit de merge. Con --rebase, Git pone tus commits locales encima de los del remoto y la historia queda recta:

git pull --rebase
From /home/ana/servidor/aroma d077686..6ec06c5 main -> origin/main Rebasing (1/1) Successfully rebased and updated refs/heads/main.
git log --oneline --graph
* 4bbbae6 (HEAD -> main) Agrega el menú de bebidas * 6ec06c5 (origin/main, origin/HEAD) Agrega el horario * d077686 Crea la portada

Muchos equipos lo usan por defecto con git config --global pull.rebase true. Es seguro porque solo reescribe tus commits que aún no subiste.

Rebase interactivo: ordenar antes de compartir

Antes de abrir un PR, puedes limpiar tus commits: unir varios en uno, cambiar mensajes, reordenarlos o eliminar alguno. Ana tiene tres commits en su rama y quiere dejar uno solo:

git rebase -i HEAD~3

Git abre tu editor con la lista de los últimos tres commits (el más antiguo arriba):

pick 345047e # Agrega la página de promociones pick fe609dc # Agrega el 2x1 de los lunes pick e27e3ce # Agrega la vigencia # Rebase 48ace4a..e27e3ce onto 48ace4a (3 commands) # # Commands: # p, pick <commit> = use commit # r, reword <commit> = use commit, but edit the commit message # e, edit <commit> = use commit, but stop for amending # s, squash <commit> = use commit, but meld into previous commit # … (más comandos y ayuda)

Cambia pick por squash (o s) en las líneas 2 y 3: «únelos al commit anterior». Guarda y cierra. Git abre el editor otra vez con los tres mensajes para que escribas el definitivo. El resultado:

git rebase -i HEAD~3
Rebasing (2/3) Rebasing (3/3) [detached HEAD 30a7afb] Agrega la página de promociones Date: Wed Jul 15 09:02:00 2026 -0500 1 file changed, 3 insertions(+) create mode 100644 promo.html Successfully rebased and updated refs/heads/feature/promo.
git log --oneline
30a7afb (HEAD -> feature/promo) Agrega la página de promociones 48ace4a (origin/main, main) Agrega el horario d077686 Crea la portada

Tres commits convertidos en uno. reword cambia solo un mensaje y drop elimina un commit.

mergerebase
HistoriaReal, con bifurcacionesLineal, como si todo fuera en orden
Commits existentesNo los tocaLos reemplaza por copias nuevas
ConflictosUna vez, al finalUno por cada commit que choca
Seguro en ramas compartidasSiempreSolo si nadie más tiene esos commits
Regla de oro: nunca hagas rebase de commits que otras personas ya tienen (por ejemplo, main). Rebasa solo tu rama de trabajo, y si ya la habías subido, súbela con --force-with-lease, nunca con --force.

Practica

BásicoRebasa feature/promo sobre main e intégrala exigiendo que sea un fast-forward.

Ver solución 1
git rebase main
git switch main
git merge --ff-only feature/promo
git log --oneline
Rebasing (1/2) Rebasing (2/2) Successfully rebased and updated refs/heads/feature/promo. Switched to branch 'main' Your branch is up to date with 'origin/main'. Updating 48ace4a..fe609dc Fast-forward promo.html | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 promo.html fe609dc (HEAD -> main, feature/promo) Agrega el 2x1 de los lunes 345047e Agrega la página de promociones 48ace4a (origin/main) Agrega el horario d077686 Crea la portada

Tras el rebase, la rama empieza en la punta de main: --ff-only se cumple y no hay commit de merge.

RetoEmpiezas a rebasar feature/promo sobre main y aparece un conflicto que prefieres no resolver hoy. Cancela el rebase y demuestra que la rama quedó exactamente como estaba.

Ver solución 2
git rebase main
git rebase --abort
git status -s
git log --oneline --graph --all
Rebasing (1/2) Auto-merging promo.html CONFLICT (add/add): Merge conflict in promo.html error: could not apply fe759e6... Agrega la página de promociones hint: Resolve all conflicts manually, mark them as resolved with hint: "git add/rm <conflicted_files>", then run "git rebase --continue". hint: You can instead skip this commit: run "git rebase --skip". hint: To abort and get back to the state before "git rebase", run "git rebase --abort". hint: Disable this message with "git config set advice.mergeConflict false" Could not apply fe759e6... # Agrega la página de promociones * 3b74986 (main) Crea la promo de octubre * 48ace4a (origin/main) Agrega el horario | * e5f4d1a (HEAD -> feature/promo, origin/feature/promo) Agrega el 2x1 de los lunes | * fe759e6 Agrega la página de promociones |/ * d077686 Crea la portada

--abort devuelve la rama a su estado previo: mismos commits (fe759e6, e5f4d1a) y carpeta limpia.

Puntos clave

  • git rebase main vuelve a aplicar tus commits encima de main: historia lineal, hashes nuevos.
  • Un conflicto se resuelve, git add y git rebase --continue; --abort lo cancela.
  • Tras rebasar una rama ya subida: git push --force-with-lease, solo en tu rama.
  • git pull --rebase evita commits de merge al sincronizar.
  • git rebase -i une (squash), renombra (reword) o elimina (drop) commits antes de compartirlos.

29 · Caja de herramientas: stash, cherry-pick y tag

Intermedio ~20 min

Tres herramientas que no usarás todos los días, pero que te sacan de apuros: stash guarda trabajo a medias para atender una urgencia, cherry-pick copia un commit concreto de una rama a otra y tag marca las versiones importantes de tu proyecto.

En este capítulo aprenderás a:

  • guardar y recuperar cambios sin hacer commit con git stash;
  • copiar un commit de otra rama con git cherry-pick;
  • marcar versiones con etiquetas y publicarlas;
  • nombrar versiones con el versionado semántico.

git stash: guardar en el cajón

Ana está a mitad de un cambio en el menú (y empezó una página de postres) cuando le piden agregar el teléfono a la portada ya. Su trabajo no está listo para un commit. git stash lo guarda en un cajón aparte y deja la carpeta limpia:

git status -s
M menu.html ?? postres.html
git stash
Saved working directory and index state WIP on main: c50e1bb Agrega el menú
git status -s
?? postres.html

¡postres.html sigue ahí! Por defecto, stash solo guarda archivos que Git ya sigue. Para incluir los nuevos se usa -u, y con -m le pones una descripción para reconocerlo después:

git stash push -u -m "Menú y postres a medio hacer"
Saved working directory and index state On main: Menú y postres a medio hacer
git status -s
git stash list
stash@{0}: On main: Menú y postres a medio hacer

Ahora sí, la carpeta está limpia. Ana atiende la urgencia y luego recupera su trabajo con git stash pop («saca lo último del cajón»):

echo "<p>Teléfono: 01 555 1234</p>" >> index.html
git commit -am "Agrega el teléfono"
[main 63a8a0f] Agrega el teléfono 1 file changed, 1 insertion(+)
git stash pop
On branch main Your branch is ahead of 'origin/main' by 1 commit. (use "git push" to publish your local commits) Changes not staged for commit: (use "git add <file>..." to update what will be committed) (use "git restore <file>..." to discard changes in working directory) modified: menu.html Untracked files: (use "git add <file>..." to include in what will be committed) postres.html no changes added to commit (use "git add" and/or "git commit -a") Dropped refs/stash@{0} (c018e2027f85c65d0c45235e1c6382d8681debc0)

Todo volvió: el menú modificado y la página de postres, sobre el nuevo commit del teléfono.

ComandoQué hace
git stash push -u -m "nota"Guarda los cambios (también archivos nuevos) con una descripción
git stash listLista lo guardado: stash@{0} es lo más reciente
git stash popRestaura lo último y lo quita del cajón
git stash applyRestaura lo último, pero lo deja en el cajón
git stash dropBorra lo último del cajón sin restaurarlo
El cajón no es un archivo. Lo que guardas con stash vive solo en tu repositorio local: no se sube con push. Úsalo para pausas cortas; si el trabajo va a esperar días, mejor un commit en una rama.

git cherry-pick: copiar un commit

En la rama feature/temporada, Ana corrigió el precio del espresso, pero esa rama tiene más cambios que aún no deben publicarse. El precio correcto, en cambio, se necesita hoy en main:

git log --oneline main..feature/temporada
7067a3d (feature/temporada) Agrega bebidas de invierno 4aa378e Corrige el precio del espresso

Desde main, copia solo el commit de la corrección usando su hash:

git cherry-pick 4aa378e
[main 4dcd3ae] Corrige el precio del espresso Date: Wed Jul 15 09:03:00 2026 -0500 1 file changed, 1 insertion(+), 1 deletion(-)
git log --oneline --graph --all
* 4dcd3ae (HEAD -> main) Corrige el precio del espresso | * 7067a3d (feature/temporada) Agrega bebidas de invierno | * 4aa378e Corrige el precio del espresso |/ * c50e1bb (origin/main) Agrega el menú * d077686 Crea la portada
cherry-pick copia un commit c50e1bb 4aa378e 7067a3d 4dcd3ae main feature/temporada HEAD
Fig. 29.1 · 4dcd3ae es una copia de 4aa378e (el mismo cambio) puesta en main. El resto de feature/temporada sigue en su rama.

El cambio entra a main como un commit nuevo (otro hash). La línea Date recuerda la fecha del commit original. Si la copia choca con algo, se resuelve como cualquier conflicto y se sigue con git cherry-pick --continue.

Úsalo con medida. cherry-pick es para casos puntuales (una corrección urgente, un commit hecho en la rama equivocada). Para integrar una rama completa, usa merge o un Pull Request: copiar commits sueltos duplica la historia.

git tag: marcar versiones

Una etiqueta es un nombre fijo para un commit: a diferencia de una rama, nunca se mueve. Se usa para marcar versiones publicadas. La anotada (-a) guarda además quién la creó, cuándo y un mensaje:

git tag -a v1.0 -m "Primera versión publicada"
git tag
v1.0
git show --no-patch v1.0
tag v1.0 Tagger: Ana Torres <ana@aromaypunto.pe> Date: Wed Jul 15 09:03:00 2026 -0500 Primera versión publicada commit c50e1bb082a2d26c1dd398ccfd47fc39e4d1e543 (HEAD -> main, tag: v1.0, origin/main) Author: Ana Torres <ana@aromaypunto.pe> Date: Wed Jul 15 09:02:00 2026 -0500 Agrega el menú

Las etiquetas no se suben con un git push normal: hay que enviarlas explícitamente.

git push origin v1.0
To /home/ana/servidor/aroma.git * [new tag] v1.0 -> v1.0
git log --oneline
c50e1bb (HEAD -> main, tag: v1.0, origin/main) Agrega el menú d077686 Crea la portada

tag: v1.0 aparece junto al commit en el historial. En GitHub, la etiqueta se puede convertir en una release (una versión publicada con notas), también desde la terminal:

gh release create v1.0 --title "Versión 1.0" --notes "Primera versión de la web de Aroma y Punto."
ComandoQué hace
git tag -a v1.0 -m "nota"Etiqueta anotada en el commit actual
git tag v1.0-betaEtiqueta ligera: solo el nombre, sin autor ni mensaje
git tag -a v0.9 4aa378e -m "nota"Etiqueta un commit anterior
git push origin v1.0Sube una etiqueta (--tags sube todas)
git tag -d v1.0-betaBorra una etiqueta local

Versionado semántico

La convención más usada para nombrar versiones es SemVer: MAYOR.MENOR.PARCHE.

Sube…Cuando…Ejemplo
PARCHECorriges errores sin cambiar nada másv1.0.0 → v1.0.1
MENORAgregas funciones nuevas compatiblesv1.0.1 → v1.1.0
MAYORHaces cambios que rompen lo anteriorv1.1.0 → v2.0.0
Regla de oro: una etiqueta publicada no se cambia ni se reutiliza. Si la versión v1.0 tenía un error, se corrige y se publica v1.0.1: quien descargó la v1.0 debe poder confiar en que siempre es la misma.

Practica

BásicoTienes cambios a medias en el menú y un archivo nuevo. Guárdalos todos en el cajón con una nota, comprueba que la carpeta quedó limpia y recupéralos.

Ver solución 1
git stash push -u -m "Pausa para una urgencia"
git status -s
git stash list
git stash pop -q
git status -s
Saved working directory and index state On main: Pausa para una urgencia stash@{0}: On main: Pausa para una urgencia M menu.html ?? postres.html

Sin -u, postres.html (sin seguimiento) se habría quedado en la carpeta. -q evita el listado largo de pop.

RetoMarca la portada inicial (d077686) como v0.1 y el commit actual como v1.0, ambas anotadas; sube todas las etiquetas de una vez y lístalas con sus mensajes.

Ver solución 2
git tag -a v0.1 d077686 -m "Portada inicial"
git tag -a v1.0 -m "Menú publicado"
git push origin --tags
git tag -n
To /home/ana/servidor/aroma.git * [new tag] v0.1 -> v0.1 * [new tag] v1.0 -> v1.0 v0.1 Portada inicial v1.0 Menú publicado

git tag -n muestra cada etiqueta con la primera línea de su mensaje.

Puntos clave

  • git stash push -u guarda cambios a medias (incluidos archivos nuevos); git stash pop los recupera.
  • git cherry-pick HASH copia un commit concreto a la rama actual como un commit nuevo.
  • git tag -a v1.0 -m "…" marca una versión; las etiquetas se suben con git push origin v1.0.
  • Versionado semántico: MAYOR.MENOR.PARCHE.

30 · Rescate y graduación: revert, reset y reflog

Avanzado ~26 min

Todos se equivocan: un commit con un error que ya subiste, commits que no debiste hacer, una rama borrada por accidente. La buena noticia es que en Git casi nada se pierde de verdad. En este último capítulo aprenderás a deshacer con seguridad y a rescatar lo que parecía perdido. Después, tu graduación.

En este capítulo aprenderás a:

  • deshacer un commit ya compartido con git revert;
  • deshacer commits locales con git reset y sus tres modos;
  • recuperar commits y ramas «perdidos» con git reflog;
  • elegir la herramienta correcta para cada error.

La pregunta clave: ¿ya lo subiste?

Antes de deshacer algo, pregúntate si ese commit ya está en el remoto. Si ya lo está, otras personas pueden tenerlo, y reescribir la historia les causaría problemas (la regla de oro del capítulo 28). Por eso hay dos caminos:

SituaciónHerramientaQué hace
El commit ya se subiógit revertCrea un commit nuevo que deshace el cambio. No reescribe nada.
El commit solo está en tu computadoragit resetMueve la rama hacia atrás, como si el commit no se hubiera hecho.

git revert: deshacer lo que ya es público

Ana subió una actualización de precios con un cero de más: el espresso ahora cuesta S/ 70.

git log --oneline
162192d (HEAD -> main, origin/main) Actualiza precios c50e1bb Agrega el menú d077686 Crea la portada

git revert crea un commit que hace lo contrario. --no-edit acepta el mensaje automático (sin la opción, Git abre el editor para que lo revises):

git revert HEAD --no-edit
[main 10cd1d0] Revert "Actualiza precios" Date: Wed Jul 15 09:04:00 2026 -0500 1 file changed, 1 insertion(+), 1 deletion(-)
cat menu.html
<ul> <li>Espresso S/ 7</li> </ul>
git log --oneline
10cd1d0 (HEAD -> main) Revert "Actualiza precios" 162192d (origin/main) Actualiza precios c50e1bb Agrega el menú d077686 Crea la portada
git push
To /home/ana/servidor/aroma.git 162192d..10cd1d0 main -> main
revert agrega, no borra c50e1bb 162192d 10cd1d0 main HEAD S/ 7 → S/ 70 S/ 70 → S/ 7
Fig. 30.1 · 10cd1d0 hace exactamente lo contrario de 162192d. El error sigue en el historial (con su corrección al lado), y nadie del equipo tiene que reescribir nada.

Para revertir un commit más antiguo, usa su hash: git revert 162192d.

git reset: deshacer lo que aún es solo tuyo

Ana hizo un commit con una carta de vinos… en una cafetería que no vende vinos. No lo subió. git reset HEAD~1 mueve main un commit hacia atrás (HEAD~1 = «el commit anterior a HEAD»). Lo que pasa con los cambios de ese commit depende del modo:

--soft: el commit se deshace, pero los cambios quedan preparados (listos para otro commit):

git reset --soft HEAD~1
git status -s
A vinos.html

--mixed (el modo por defecto): los cambios quedan en tu carpeta, sin preparar:

git reset HEAD~1
git status -s
?? vinos.html

--hard: se descartan también los cambios. La carpeta vuelve a quedar como en el commit anterior:

git reset --hard HEAD~1
HEAD is now at d077686 Crea la portada
git status -s
git log --oneline
d077686 (HEAD -> main, origin/main) Crea la portada
reset mueve la rama hacia atrás d077686 4ff317a main HEAD sin rama, pero no borrado
Fig. 30.2 · Tras git reset HEAD~1, main vuelve a d077686. El commit 4ff317a queda sin rama que lo señale, pero sigue en el repositorio: el reflog lo recuerda.
ModoCommitÁrea de preparaciónTus archivos
--softSe deshaceConserva los cambiosConserva los cambios
--mixedSe deshaceSe vacíaConserva los cambios
--hardSe deshaceSe vacíaPierde los cambios
Cuidado con --hard. Los cambios que no estaban en ningún commit (los que solo estaban en tu carpeta) se pierden para siempre: ni el reflog puede recuperarlos. Antes de un reset --hard, revisa git status.

git reflog: el diario de HEAD

¿Y si el reset --hard fue un error y sí querías la carta de vinos? Git anota en el reflog cada movimiento de HEAD: commits, cambios de rama, merges, resets… Es tu red de seguridad local:

git reflog
d077686 (HEAD -> main, origin/main) HEAD@{0}: reset: moving to HEAD~1 4ff317a HEAD@{1}: commit: Agrega la carta de vinos d077686 (HEAD -> main, origin/main) HEAD@{2}: commit (initial): Crea la portada
git reset --hard 4ff317a
HEAD is now at 4ff317a Agrega la carta de vinos
git log --oneline
4ff317a (HEAD -> main) Agrega la carta de vinos d077686 (origin/main) Crea la portada

El reflog mostró el commit «perdido» (4ff317a) y git reset --hard a ese hash devolvió la rama a donde estaba. También puedes escribir HEAD@{1} («donde estaba HEAD hace un movimiento»).

Recuperar una rama borrada

Borrar una rama con -D (forzado) no borra sus commits: Git te dice incluso el hash al que apuntaba. Con él, la recreas:

git branch -D feature/encuesta
Deleted branch feature/encuesta (was 0c3764d).
git branch feature/encuesta 0c3764d
git log --oneline feature/encuesta
0c3764d (feature/encuesta) Agrega la encuesta 4ff317a (HEAD -> main) Agrega la carta de vinos d077686 (origin/main) Crea la portada

Si ya no tienes ese mensaje a la vista, busca el hash en git reflog.

El reflog es local y temporal. Solo existe en tu repositorio (no se sube) y Git limpia las entradas antiguas con el tiempo (por defecto, unos 90 días). Rescata pronto lo que necesites.

Mapa para deshacer

Quiero…ComandoCapítulo
Descartar cambios de un archivo sin preparargit restore archivo11
Sacar un archivo del área de preparacióngit restore --staged archivo11
Corregir el último commit (no subido)git commit --amend11
Cancelar un merge con conflictosgit merge --abort20
Cancelar un rebasegit rebase --abort28
Deshacer un commit ya subidogit revert HASH30
Deshacer commits localesgit reset [--soft|--hard] HEAD~130
Recuperar un commit o una ramagit reflog + git branch / git reset30

Graduación

Empezaste preguntándote por qué existe Git y terminas trabajando como un equipo profesional. Repasa todo lo que ya sabes hacer:

ParteLo que dominas
I · Primeros pasosInstalar y configurar Git, moverte en la terminal y crear repositorios.
II · Git a solasLas tres zonas, commits con buenos mensajes, leer la historia, comparar y deshacer, .gitignore.
III · RamasCrear, cambiar, fusionar (fast-forward y tres vías) y ordenar ramas.
IV · ConflictosEntender, leer y resolver conflictos sin miedo.
V · Equipo con GitHubRemotos, SSH, clonar, sincronizar, Pull Requests con gh y trabajo en paralelo.
VI · Nivel profesionalRebase, stash, cherry-pick, etiquetas y rescate de errores.

Tu proyecto de graduación: crea en GitHub un repositorio público con un proyecto tuyo (por ejemplo, tu web personal), trabájalo con ramas y Pull Requests aunque estés solo, publica la versión v1.0.0 con gh release create y compártelo: será la primera pieza de tu portafolio.

Para seguir aprendiendo (fuentes oficiales):

¡Felicitaciones! Ya puedes usar Git todos los días con confianza. Lo que sigue es práctica: cada proyecto, por pequeño que sea, con su repositorio desde el primer día.
Regla de oro: lo que ya subiste se deshace con revert; lo que solo está en tu computadora, con reset. Y antes de dar algo por perdido, mira el reflog: en Git, casi nada se pierde de verdad.

Practica

BásicoEl commit de precios erróneo (162192d) ya está subido y después hubo otro commit. Deshazlo sin reescribir la historia y comprueba el menú.

Ver solución 1
git revert 162192d --no-edit
cat menu.html
git log --oneline
[main de1b803] Revert "Actualiza precios" Date: Wed Jul 15 09:05:00 2026 -0500 1 file changed, 1 insertion(+), 1 deletion(-) <ul> <li>Espresso S/ 7</li> </ul> de1b803 (HEAD -> main) Revert "Actualiza precios" 77d0ac2 (origin/main) Agrega el teléfono 162192d Actualiza precios c50e1bb Agrega el menú d077686 Crea la portada

revert funciona con cualquier commit, no solo el último: el teléfono se conserva.

RetoPor error borras tus dos últimos commits con git reset --hard HEAD~2. Encuéntralos en el reflog y recupéralos.

Ver solución 2
git reset --hard HEAD~2
git reflog -3
git reset --hard HEAD@{1}
git log --oneline
HEAD is now at d077686 Crea la portada d077686 (HEAD -> main, origin/main) HEAD@{0}: reset: moving to HEAD~2 1bb7d5b HEAD@{1}: commit: Agrega las infusiones 4ff317a HEAD@{2}: commit: Agrega la carta de vinos HEAD is now at 1bb7d5b Agrega las infusiones 1bb7d5b (HEAD -> main) Agrega las infusiones 4ff317a Agrega la carta de vinos d077686 (origin/main) Crea la portada

HEAD@{1} es «donde estaba HEAD antes del último movimiento»: justo antes del reset.

Puntos clave

  • git revert HASH deshace un commit compartido creando uno nuevo; no reescribe la historia.
  • git reset HEAD~1 deshace commits locales: --soft conserva lo preparado, --mixed los archivos, --hard nada.
  • --hard borra los cambios sin commit para siempre.
  • git reflog registra cada movimiento de HEAD y permite rescatar commits y ramas.
  • Una rama borrada se recrea con git branch nombre HASH.