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.
1 · Por qué Git: el caos de las versiones
Básico ~12 minImagina 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.htmlSeis 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).
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.
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 versiones | Con Git |
|---|---|
Copias con nombres como final_v2 | Un solo archivo con todo su historial |
| «¿Quién borró esto?»: nadie sabe | Cada cambio tiene autor, fecha y motivo |
| Volver atrás = buscar una copia vieja | Volver atrás = un comando |
| Dos personas editando = alguien pierde trabajo | Cada uno trabaja en su rama y luego se juntan |
| Respaldo = USB o correo | Copia 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:
| Git | GitHub | |
|---|---|---|
| ¿Qué es? | Un programa que instalas en tu computadora | Un sitio web que guarda repositorios de Git en internet |
| ¿Necesita internet? | No | Sí |
| ¿Para qué sirve? | Guardar versiones, crear ramas, juntar cambios | Compartir el proyecto, revisar código en equipo, publicar |
| Analogía | La cámara que toma las fotos | El á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
| Parte | Qué lograrás |
|---|---|
| I · Primeros pasos | Instalar Git, manejar lo básico de la terminal y crear tu primer repositorio |
| II · Git a solas | Guardar commits, leer la historia, ver diferencias y deshacer errores |
| III · Ramas | Trabajar en varias ideas a la vez sin romper lo que ya funciona |
| IV · Conflictos | Entender y resolver con calma los choques entre cambios |
| V · Trabajo en equipo | Clonar repositorios, sincronizar con GitHub y hacer Pull Requests |
| VI · Nivel profesional | Rebase, herramientas de rescate y buenas prácticas |
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 mapaUn 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 minAntes 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.
- Entra a git-scm.com/install/windows y descarga el instalador de 64 bits.
- 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 instalador | Elige | Por qué |
|---|---|---|
| Choosing the default editor used by Git | Use the Nano editor by default | El 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 repositories | Override the default branch name… y escribe main | Es el nombre estándar actual; lo verás en el capítulo 4. |
| Adjusting your PATH environment | Git from the command line and also from 3rd-party software (Recommended) | Permite usar Git desde Git Bash, PowerShell y otros programas. |
| Choosing the SSH executable | Use bundled OpenSSH | Lo usarás para conectarte a GitHub en el capítulo 23. |
| Configuring the line ending conversions | Checkout Windows-style, commit Unix-style line endings | Evita problemas de saltos de línea al trabajar con compañeros en Linux o macOS. |
- 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 gitUbuntu 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 gitEn 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 gitSi 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 --versionSi 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.
¿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.
Practica
BásicoComprueba que Git está instalado mostrando su versión.
Ver solución 1
git --versionSi 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-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
maincomo rama inicial. - Linux:
sudo apt install git; el PPAgit-coretrae la versión más reciente. - macOS:
brew install git. git --versionconfirma la instalación; si no responde, abre una terminal nueva.
3 · La terminal mínima para usar Git
Básico ~18 minLa 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.
¿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:
pwdlsCrear 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
pwdFí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
lscat index.htmlecho "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
lsls -aLas 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:
| Tipo | Ejemplo | Se 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
pwdcd ..
pwdcd ../..
pwdcd ~/proyectos/aroma
pwdAtajos que te ahorrarán horas
| Atajo | Qué hace |
|---|---|
| Tab | Completa nombres de carpetas, archivos y comandos. Escribe cd pro + Tab. |
| ↑ / ↓ | Recorre los comandos que ya escribiste. |
| Ctrl + C | Cancela el comando que se está ejecutando. |
clear o Ctrl + L | Limpia la pantalla. |
| q | Sale 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.txtEscribe algo, guarda con Ctrl + O y Enter, y sal con Ctrl + X.
| Comando | Para qué | Ejemplo |
|---|---|---|
pwd | Ver la carpeta actual | pwd |
ls / ls -a | Listar (incluidos ocultos) | ls -a |
cd | Cambiar de carpeta | cd proyectos/aroma |
mkdir | Crear una carpeta | mkdir css |
touch | Crear un archivo vacío | touch app.js |
echo … > | Crear un archivo con texto | echo hola > a.txt |
cat | Ver el contenido de un archivo | cat index.html |
nano | Editar un archivo | nano index.html |
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 jsmkdir -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
pwdCada .. 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
pwddice dónde estás;ls -amuestra todo, incluidos los ocultos.cdse 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 minCada 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
maincomo 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 pruebaGit 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.
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.namegit config --global --list| Clave | Para qué sirve |
|---|---|
user.name | Tu nombre tal como aparecerá en cada commit. |
user.email | Tu correo. Usa el mismo de tu cuenta de GitHub para que tus commits se vinculen a tu perfil. |
init.defaultBranch | Nombre de la primera rama de cada repositorio nuevo. |
core.editor | El editor que Git abrirá cuando necesite que escribas un texto largo. |
…@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-originExisten tres niveles, y el más específico gana:
| Nivel | Opción | Alcance | Archivo |
|---|---|---|---|
| Sistema | --system | Todos los usuarios de la computadora | depende del sistema |
| Global | --global | Todos 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 inputComprueba el resultado
Con la configuración hecha, el mismo git init del inicio ya no muestra el aviso:
git init pruebagit 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.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.emailSin 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.emailSin --global, la configuración se guarda en .git/config del repositorio actual y tiene prioridad sobre la global.
Puntos clave
user.nameyuser.emailfirman cada commit; usa el correo de tu cuenta de GitHub.init.defaultBranch main: el estándar actual, que Git 3.0 traerá por defecto.--globalvale para todos tus repositorios; la configuración local de un repo tiene prioridad.core.autocrlf:trueen Windows,inputen Linux y macOS.
5 · Tu primer repositorio: git init y la carpeta .git
Básico ~12 minHasta 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
.gity 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 initGit 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 -als .gitcat .git/HEADDentro 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 .git | Qué guarda |
|---|---|
objects/ | El contenido de cada versión de cada archivo y cada commit, comprimidos. |
refs/ | Las ramas y etiquetas: punteros a commits. |
HEAD | En qué rama estás trabajando ahora. |
config | La configuración de ESTE repositorio (nivel local). |
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 statusTraducido: «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í:
pwdgit status«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 accidentalPor la misma razón, no crees un repositorio dentro de otro: un proyecto, un repositorio, en su propia carpeta.
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 statusgit 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 statusBorrar .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 initconvierte la carpeta actual en un repositorio.- Todo el historial vive en la carpeta oculta
.git: no se borra ni se edita a mano. git statusdescribe 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 minEste 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.
git add y lo guardas en el historial con git commit.| Zona | También se llama | Qué hay ahí | Comando que la alimenta |
|---|---|---|---|
| Directorio de trabajo | working directory | Tus archivos tal como los ves y editas | tu editor |
| Área de preparación | staging area o index | Los cambios elegidos para el próximo commit | git add |
| Repositorio | repository (.git) | Todos los commits: el historial | git 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 statusgit add index.html
git statusgit commit -m "Crea la portada"git statusLee 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
| Estado | Qué significa | Cómo sale de ahí |
|---|---|---|
| Sin seguimiento (untracked) | Archivo nuevo que Git aún no vigila | git add → preparado |
| Preparado (staged) | Su versión actual irá en el próximo commit | git commit → guardado |
| Guardado (unmodified) | Idéntico a como está en el último commit | lo editas → modificado |
| Modificado (modified) | Cambió desde el último commit, pero no está preparado | git 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.
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.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 -sLa ú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 -sGracias 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 addlleva cambios a preparación;git commitlos 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 minEn 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 statusen su forma larga y en la forma corta-s; - preparar un archivo, una carpeta o todo el proyecto con
git add; - entender que
git addprepara una «foto» del archivo en ese instante; - conocer
git add -ppara 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 statusGit separa la información en bloques, y cada uno sugiere qué hacer:
| Bloque | Significado |
|---|---|
| Changes to be committed | Preparado: irá en el próximo commit. |
| Changes not staged for commit | Modificado, pero todavía no preparado. |
| Untracked files | Archivos 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 -sgit add css
git status -sgit add .
git status -s| Código | Significado |
|---|---|
?? | Sin seguimiento: archivo nuevo. |
A | Archivo nuevo, ya preparado (added). |
M | Modificado, sin preparar (la M está a la derecha). |
M | Modificado y preparado (la M pasó a la izquierda). |
MM | Preparado, y vuelto a modificar después. |
D / D | Borrado, sin preparar / preparado. |
Las formas de git add
| Comando | Qué prepara |
|---|---|
git add index.html | Un archivo. |
git add css | Una carpeta con todo su contenido. |
git add index.html css/estilos.css | Varios archivos a la vez. |
git add . | Todo lo que cambió en la carpeta actual y sus subcarpetas. |
git add -A | Todo lo que cambió en el repositorio entero, incluidos los borrados. |
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 -secho "<p>Precio: S/ 28</p>" >> index.html
git status -sgit add index.html
git status -sCon 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| Tecla | Respuesta |
|---|---|
| y | sí, prepara este bloque |
| n | no, déjalo para después |
| s | divide el bloque en partes más pequeñas |
| q | salir |
| ? | ayuda con todas las opciones |
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 -sAntes: 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 = 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 addacepta archivos, carpetas,.(todo aquí) y-A(todo el repo).git addprepara el archivo tal como está AHORA; si lo editas otra vez, repite el add.git add -pprepara solo los bloques que elijas.
8 · git commit: guardar fotos con mensaje
Básico ~16 minCon 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 -me interpretar lo que responde Git; - escribir mensajes claros, con título y descripción;
- usar el editor para mensajes largos y el atajo
-acon sus límites; - decidir qué cabe en un commit: un cambio, una idea.
Tu primer commit
git commit -m "Crea la portada"Cada parte de la respuesta tiene significado:
| Fragmento | Significado |
|---|---|
main | La rama donde quedó el commit. |
root-commit | Es el primer commit del repositorio (no tiene padre). |
d077686 | Los 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.html | El archivo es nuevo en el historial (100644 = archivo normal). |
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."git log -1| Mal mensaje | Buen mensaje |
|---|---|
cambios | Corrige el precio del capuchino en el menú |
arreglé cosas | Evita que el formulario se envíe con el correo vacío |
wip | Agrega la galería de fotos de la cafetería |
final final | Reemplaza 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 commitEl 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"git status -sEl 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"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.
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 -1Cada -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"-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
-mse abre el editor; un mensaje vacío cancela el commit. -aincluye lo modificado ya seguido, nunca los archivos nuevos.
9 · Leer la historia: git log y git show
Básico ~16 minYa 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 logy 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 logCada 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.
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 --onelinegit log --oneline -2Con --stat además ves qué archivos tocó cada commit:
git log --oneline --stat -2HEAD 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.htmlgit log --oneline --grep="precio"git log --format="%h · %an · %ad · %s" --date=short -2| Opción | Muestra |
|---|---|
-n (por ejemplo -2) | Solo los n commits más recientes |
-- archivo | Solo 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=short | Fechas 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 HEADgit show --stat --oneline HEAD~2En el próximo capítulo aprenderás a leer este formato de diferencias con calma.
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-- 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~1Primero 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 loglista los commits del más reciente al más antiguo;--onelinelos resume.(HEAD -> main)indica en qué rama y commit estás.- Filtra con
-n,-- archivo,--grepy--author. git showmuestra un commit con sus cambios;HEAD~1es el commit anterior.
10 · ¿Qué cambió? git diff en sus tres sabores
Básico ~16 minAntes 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
--staty 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 -sgit diffAsí se lee:
| Línea | Significado |
|---|---|
diff --git a/index.html b/index.html | Se 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 inicial | Contexto: 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ó (+).
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--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 HEADgit diff HEAD~2 HEAD --statgit diff --word-diff HEAD~1 HEADEn --word-diff, lo que está entre [-…-] se quitó y lo que está entre {+…+} se agregó.
| Quieres ver… | Comando |
|---|---|
| Lo que cambiaste y no preparaste | git diff |
| Lo que ya preparaste (irá al commit) | git diff --staged |
| Todo lo que cambió desde el último commit | git diff HEAD |
| Lo que hizo un commit | git show <commit> o git diff HEAD~1 HEAD |
| Solo un archivo | agrega -- archivo al final |
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 --stagedDespué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 --statHay 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 Bcompara dos commits;--statresume y--word-diffmarca palabras.
11 · Deshacer sin miedo: restore y commit --amend
Intermedio ~18 minEquivocarse 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 -sgit restore menu.html
git status -s
cat menu.htmlgit 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 -sgit restore --staged index.html
git status -sLa 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 --onelinecat menu.htmlgit restore --source=HEAD~1 menu.html
cat menu.htmlgit status -sEl 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"git commit --amend -m "Cambia el lema de la portada"git log --onelineObserva 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-editgit log --oneline --stat -1--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ón | Comando | ¿Se pierde algo? |
|---|---|---|
| Cambios que no preparé ni guardé | git restore archivo | Sí: esos cambios |
| Preparé algo por error | git restore --staged archivo | No |
| Quiero el archivo como en un commit anterior | git restore --source=HEAD~1 archivo | Los cambios sin guardar de ese archivo |
| El mensaje del último commit está mal | git commit --amend -m "…" | No |
| Olvidé un archivo en el último commit | git add archivo + git commit --amend --no-edit | No |
| Un commit ya compartido estaba mal | git revert (capítulo 30) | No |
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.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.htmlComo 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 --statUn solo --amend agrega el archivo y cambia el mensaje. Es seguro porque el commit aún no se compartió.
Puntos clave
git restore archivodescarta cambios no guardados (sin vuelta atrás).git restore --staged archivosaca un archivo de la preparación sin perder el cambio.git restore --source=<commit> archivotrae la versión de cualquier commit.git commit --amendreemplaza el último commit: úsalo solo si no lo compartiste.
12 · .gitignore: lo que nunca debe entrar
Básico ~16 minNo 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
.gitignorecon nombres, carpetas y comodines; - hacer excepciones con
!y comprobar reglas congit 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 -sDe 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 .gitignoregit status -sAhora Git solo muestra el propio .gitignore, que sí se guarda en el
repositorio para que todo el equipo use las mismas reglas.
| Regla | Ignora |
|---|---|
.env | el archivo .env, en cualquier carpeta |
node_modules/ | esa carpeta completa (la barra final indica carpeta) |
*.log | todo archivo que termine en .log |
/notas.txt | solo el notas.txt de la raíz del proyecto |
docs/*.pdf | los PDF dentro de docs (no los de subcarpetas) |
!importante.log | excepció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 .gitignoregit status -sgit check-ignore -v .env debug.logLa 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 -sgit rm --cached config.localgit add .gitignore
git status -sgit commit -m "Deja de seguir config.local y lo ignora"git status -sPlantillas 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.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 -sFí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.txtEl 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
.gitignorelista 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 archivodice 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 minLas 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
HEADy 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 branchgit log --onelinemain 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/HEADcat .git/refs/heads/mainHEAD 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.
| Concepto | Qué es | Analogía |
|---|---|---|
| Commit | Una foto del proyecto | Una parada del camino |
| Rama | Una etiqueta móvil que apunta a un commit | El marcador de una línea de bus: avanza con cada parada |
HEAD | La rama (o commit) donde estás ahora | El 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 branchgit log --oneline -1git 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.
git switch main.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(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=%HLos 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.
HEADindica en qué rama estás.git branchlista las ramas;git branch nombrecrea una sin moverte a ella.
14 · Crear y cambiar de rama: branch y switch
Intermedio ~18 minYa 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 switchy 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 postresgit branchcat .git/HEADEl 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"git log --oneline --graph --allpostres (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:
lsgit switch mainlsgit switch postreslsNo 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 contactogit branchCuando 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"git log --oneline --graph --allmain 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«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.
| Comando | Qué hace |
|---|---|
git switch rama | Te mueve a una rama existente |
git switch -c rama | Crea la rama y te mueve a ella |
git switch - | Vuelve a la rama anterior (como el botón «atrás») |
git log --oneline --graph --all | Dibuja todas las ramas |
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.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 --allSolo 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 -
lsgit switch - vuelve a la última rama en la que estuviste, como el botón «atrás» del navegador.
Puntos clave
git switch ramate mueve;git switch -c ramacrea 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 --allmuestra cómo se separan las líneas de trabajo.
15 · Fusionar I: el merge fast-forward
Intermedio ~14 minLa 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 --allmain 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 maingit merge postresgit log --oneline --graph --alllsLee 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.
git merge postres movió la etiqueta main hasta c8760e4. No se creó ningún commit nuevo.| Situación | Tipo de merge | Resultado |
|---|---|---|
| La rama que recibe NO tiene commits nuevos | Fast-forward | La etiqueta avanza; no hay commit nuevo |
| Ambas ramas tienen commits nuevos | Merge de tres vías (capítulo 16) | Se crea un commit de merge |
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«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 postresGit 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 otratrae los commits deotraa 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 minEn 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-ffcuando 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 --all8a4c569, 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-editgit log --oneline --graph --all«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'.
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--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"git log --oneline --graph --all -4| Opción | Cuándo usarla |
|---|---|
git merge rama | Lo habitual: fast-forward si se puede; si no, commit de merge. |
git merge --no-ff rama | Siempre un commit de merge, para dejar visible la integración. |
git merge --ff-only rama | Solo si es fast-forward; si no, falla en lugar de crear un merge. |
git merge --abort | Cancela 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.
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"%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 --allCon --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:engit show). --no-fffuerza el commit de merge;--ff-onlylo prohíbe.
17 · Ordenar las ramas: listar, renombrar y borrar
Intermedio ~14 minEn 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 branchgit branch -v¿Cuáles ya están fusionadas?
Estas dos opciones responden la pregunta clave antes de borrar, siempre desde la rama principal:
git branch --mergedgit branch --no-mergedpostres 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 postresgit log --oneline --graph -4git branch -d galeriapostres 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.
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 galeriagit branchgit reflog (capítulo 30).Renombrar y nombrar bien
git branch -m galeria feature/galeria
git branchLos equipos suelen usar prefijos que dicen qué tipo de trabajo contiene la rama:
| Prefijo | Para qué | Ejemplo |
|---|---|---|
feature/ | Funcionalidad nueva | feature/carta-postres |
fix/ | Corrección de un error | fix/precio-espresso |
docs/ | Solo documentación | docs/manual-instalacion |
hotfix/ | Arreglo urgente en producción | hotfix/formulario-caido |
Usa minúsculas, guiones en lugar de espacios y nombres que se entiendan solos. Evita prueba2 o rama-luis.
| Comando | Qué hace |
|---|---|
git branch -v | Lista las ramas con su último commit |
git branch --merged | Ramas cuyo trabajo ya está en la actual (se pueden borrar) |
git branch --no-merged | Ramas con trabajo pendiente de fusionar |
git branch -d rama | Borra solo si está fusionada |
git branch -D rama | Borra aunque no esté fusionada |
git branch -m viejo nuevo | Renombra |
-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 branchpostres 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-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.
--mergedy--no-mergeddicen qué ramas se pueden borrar.-dprotege el trabajo sin fusionar;-Dlo descarta a propósito.- Nombres con prefijo (
feature/,fix/) y en minúsculas con guiones.
18 · Por qué ocurren los conflictos
Intermedio ~14 minLa 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
CONFLICTy 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-editcat index.htmlEl 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:
git log --oneline --graph --allgit merge preciosLee 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«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ón | Mensaje de Git | Qué decides |
|---|---|---|
| Las dos ramas cambiaron la misma línea | CONFLICT (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 nombre | CONFLICT (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.
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 -sUU: 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 lema2La 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 statusmuestra «Unmerged paths». - Tipos: content, modify/delete y add/add.
19 · Anatomía de un conflicto: los marcadores
Intermedio ~15 minCuando 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
zdiff3para 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 -scat index.htmlHEAD). Azul: la versión de la rama que traes (precios). Las líneas sin color no tienen conflicto.| Marca | Significado |
|---|---|
<<<<<<< HEAD | Empieza el conflicto. Lo que sigue es TU versión: la de la rama donde estás (aquí, main). |
======= | Separa las dos versiones. |
>>>>>>> precios | Termina 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.
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 precioscat index.htmlzdiff3 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 --onelineCon 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.
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.htmlEntre <<<<<<< 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.htmlAhora el bloque entre ||||||| y ======= muestra el precio original (S/ 8): los dos lo subieron.
Puntos clave
- Entre
<<<<<<< HEADy=======está TU versión; después, la de la otra rama. - Fuera de las marcas no hay conflicto: Git ya combinó esas partes.
- Con
zdiff3también ves la base común, entre|||||||y=======. git log --mergemuestra los commits que chocaron.
20 · Resolver un conflicto paso a paso
Intermedio ~18 minYa 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 --ourso--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 -sgit diff --name-only --diff-filter=UPaso 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.htmlPaso 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 --checkcat > 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 --checkPaso 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«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-editgit log --oneline --graphPlan 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 statusgit log --oneline -1Quedarte 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.htmlgit restore --ours index.html
grep Espresso index.htmlgit restore --merge index.html
git status -sDespués de elegir, el paso 4 (git add) y el 5 (git commit) son los mismos.
| Paso | Comando | Para qué |
|---|---|---|
| 1 | git status | Ver qué archivos tienen conflicto |
| 2 | nano archivo | Decidir el contenido y borrar las marcas |
| 3 | git diff --check | Confirmar que no quedan marcas |
| 4 | git add archivo | Marcarlo como resuelto |
| 5 | git commit | Terminar el merge |
| — | git merge --abort | Cancelar todo y volver al estado previo |
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 --graphEn 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"--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 addsignifica «este archivo ya está resuelto». git merge --abortcancela el merge sin perder nada.git restore --ours/--theirseligen una versión completa del archivo.
21 · Laboratorio de conflictos: tres casos reales
Avanzado ~25 minLlegó 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 descripcionescat menu.htmlDecisió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-editcat menu.htmlCaso 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-2x1git status -slsDU = 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 vaya | git rm promo.html |
Decisión: la gerencia confirma que la promo terminó, así que se borra:
git rm promo.htmlgit commit -m "Integra promo-2x1: la promo sigue retirada"git log --oneline --graphCaso 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 redisenogit status -scat index.htmlEl 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 -sgit commit -m "Integra el rediseño: combina lemas y amplía el horario"cat estilos.cssCómo tener menos conflictos
| Práctica | Por qué ayuda |
|---|---|
| Commits pequeños y frecuentes | Los conflictos son más chicos y fáciles de entender. |
| Ramas que viven pocos días | Cuanto más se alejan dos ramas, más chocan. |
Traer main a tu rama a menudo | Resuelves los choques de a poco, no todos al final. |
| Avisar al equipo qué archivos vas a tocar | Dos personas no editan la misma línea a la vez. |
| Un formato de código común | Que nadie «cambie» líneas solo por espacios o comillas. |
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.htmlEn 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/preciosResolver 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 congit add(se queda) ogit rm(se va). - Con varios archivos, resuelve uno por uno;
--ours/--theirssirven por archivo. - Ramas cortas y merges frecuentes previenen la mayoría de conflictos.
22 · Remotos: qué es origin
Intermedio ~16 minHasta 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
mainde la rama de seguimientoorigin/main; - montar en tu computadora un «servidor de práctica» para la parte V.
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.gitConectar tu repositorio con el remoto
El repositorio de Ana todavía no conoce ningún remoto:
git remote -vCon git remote add nombre dirección se lo presentas:
git remote add origin ~/servidor/aroma.git
git remote -vAparece 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.gitEl 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 maingit branch -vvgit branch -agit log --oneline«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.
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».
| Comando | Qué hace |
|---|---|
git remote -v | Lista los remotos con sus direcciones |
git remote add origin URL | Agrega un remoto llamado origin |
git remote rename viejo nuevo | Cambia el nombre de un remoto |
git remote remove nombre | Quita un remoto (no borra nada en el servidor) |
git push -u origin main | Sube main y deja configurado el seguimiento |
git branch -vv | Muestra qué rama remota sigue cada rama local |
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[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 maingit 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 URLlo conecta;git push -u origin mainhace el primer envío.origin/maines 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 minPara 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
- Entra a github.com/signup y regístrate con el
mismo correo que configuraste en
user.email(capítulo 4). - Elige un nombre de usuario profesional: aparecerá en tus repositorios y en tu portafolio.
- 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 key | Presiona Enter para aceptar la ubicación por defecto. |
Enter passphrase | Una frase para proteger la llave privada (recomendado). Al escribirla no verás nada en pantalla: es normal. |
Enter same passphrase again | La misma frase, para confirmarla. |
Se crean dos archivos en la carpeta oculta ~/.ssh. El que termina en .pub es el público:
ls ~/.sshcat ~/.ssh/id_ed25519.pubPaso 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_ed25519Paso 4 · Registra la llave pública en GitHub
- Muestra la llave pública con
cat ~/.ssh/id_ed25519.puby copia la línea completa (empieza conssh-ed25519). En Git Bash de Windows también puedes copiarla directo conclip < ~/.ssh/id_ed25519.pub. - En GitHub: tu foto (arriba a la derecha) → Settings → sección Access → SSH and GPG keys → New SSH key.
- 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.comLa primera vez, SSH te muestra la huella del servidor y pregunta si confías en él:
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:
«Te autenticaste correctamente, pero GitHub no ofrece una terminal»: es el mensaje de éxito. Tu computadora y GitHub ya se reconocen.
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 mainRecarga 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.
| SSH | HTTPS | |
|---|---|---|
| Dirección | git@github.com:usuario/repo.git | https://github.com/usuario/repo.git |
| Cómo te identificas | Llave SSH registrada una vez | Token o Git Credential Manager |
| Ventaja | Sin claves que escribir ni renovar | Funciona en redes que bloquean SSH |
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.pubSolo 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 -vgit 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.emaily 2FA activada. ssh-keygen -t ed25519 -C correocrea la llave privada y la pública (.pub).- La pública se registra en GitHub → Settings → SSH and GPG keys.
ssh -T git@github.comresponde «Hi usuario!» cuando todo está bien.
24 · Clonar repositorios: git clone
Básico ~14 minLuis 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.
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.gitcd aroma
lsgit log --oneline«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 -vgit branch -agit status| Qué | Detalle |
|---|---|
| Archivos | La versión de la rama principal, lista para trabajar. |
| Historial | Todos los commits de todas las ramas (completo, no solo el último). |
Remoto origin | Ya configurado con la dirección desde la que clonaste. |
| Seguimiento | main 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.nameAsí, 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-cafeterials web-cafeteriaClonar 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.gitPractica
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 -vvEl 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 --onelineCada 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 URLtrae archivos, historial completo y el remotooriginconfigurado.- Después de clonar,
mainya sigue aorigin/main. git clone URL carpetausa otro nombre de carpeta.- El laboratorio de equipo:
~/servidor/aroma.git(GitHub) y los clones~/ana/aromay~/luis/aroma.
25 · push, fetch y pull: sincronizar sin pisarse
Intermedio ~20 minAna 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 fetchsin 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"git pushLa ú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¡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 fetchgit statusAhora sí: «tu rama está 1 commit atrás de origin/main y puede avanzar con fast-forward».
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 mergegit 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 pullgit log --oneline| Comando | Qué hace | ¿Cambia tus archivos? |
|---|---|---|
git push | Sube tus commits y mueve la rama del remoto | No |
git fetch | Baja commits nuevos y actualiza origin/main | No |
git pull | fetch + integra origin/main en tu rama | Sí |
git status | Compara tu rama con la última foto del remoto | No |
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«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 statusd9abbb8 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 pullHay 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-editgit log --oneline --graphgit pushEse 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.
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ón | Qué hace git pull con historias divergentes |
|---|---|
pull.rebase false | Crea un commit de merge (la que usamos en este curso) |
pull.rebase true | Reaplica tus commits encima de los del remoto (capítulo 28) |
pull.ff only | Se niega a integrar: solo acepta avanzar con fast-forward |
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 pullgit log --oneline --graphLos 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--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.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 pullgit 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 --graphEl 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 pushsube tus commits; el remoto lo rechaza si tiene commits que tú no tienes.git fetchactualizaorigin/mainsin tocar tu rama: siempre es seguro.git statussolo compara con la última foto del remoto: hazfetchpara saber la verdad.git pull=fetch+merge; configurapull.rebase falseuna vez.- Push rechazado ⇒
pull, resolver si hace falta,push. Nunca--forceen una rama compartida.
26 · Pull Requests desde la terminal con gh
Intermedio ~22 minEn 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
- Crear una rama para la tarea (capítulo 14) y hacer commits.
- Subir la rama al remoto con
git push -u. - Abrir el Pull Request: «quiero integrar
feature/contactoenmain». - Un compañero revisa, comenta y aprueba (o pide cambios: subes más commits a la misma rama y el PR se actualiza solo).
- Se fusiona en GitHub y se borra la rama.
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
| Sistema | Comando |
|---|---|
| Windows | winget install --id GitHub.cli --source winget |
| macOS | brew install gh |
| Ubuntu / Debian | Repositorio 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 -yComprueba la instalación (en Windows, abre una ventana nueva de Git Bash):
gh --versionIniciar 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 loginCopia 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.
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 --pushUsa --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/contactoecho "<p>Escríbenos: hola@aromaypunto.pe</p>" > contacto.html
git add contacto.html
git commit -m "Agrega la página de contacto"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«[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."«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 probarlaSi 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."Paso 5 · Fusionar y limpiar
gh pr merge 1 --merge --delete-branchGitHub 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 pullgit log --oneline --graphEl 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 merge | En GitHub | Resultado en main |
|---|---|---|
--merge | Create a merge commit | Todos los commits de la rama + un commit de merge (lo que viste arriba) |
--squash | Squash and merge | Un solo commit nuevo con todos los cambios de la rama |
--rebase | Rebase and merge | Los 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.
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.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 -rCon 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 -1Si 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 loginconecta la terminal con tu cuenta;gh repo createcrea el remoto.- Ciclo: rama → commits →
git push -u→gh pr create→gh pr review→gh pr merge. - Tras fusionar,
git pullenmainpara 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 minYa 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
mainantes 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/galeriaecho "<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"git push -u origin feature/galeriaAl 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/reservasecho "<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"git push -u origin feature/reservasmain 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 fetchgit log --oneline --graph --allEl 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/maincat index.htmlEs 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-editgit pushorigin/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.
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 --prunegit branch -vvgit switch maingit pullgit branch -d feature/galeria«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 maingit pull --prunegit branch -d feature/reservasgit log --oneline --graphLos dos PR quedaron en main, cada uno con su commit de merge. Para no tener que acordarte de podar:
git config --global fetch.prune trueLa 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áctica | Por 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ños | Un PR de 50 líneas se revisa bien; uno de 2000 se aprueba sin leer. |
| Nombres descriptivos | feature/reservas, fix/precio-americano: se sabe qué es sin abrirla. |
| Traer main a menudo | Resolver un conflicto pequeño hoy es más fácil que uno grande al final. |
| Avisar al equipo | Si vas a tocar un archivo central, coméntalo: muchos conflictos se evitan hablando. |
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/galeriagit 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 pushgit 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
mainavanzó,git fetch+git merge origin/mainpone al día tu rama. - Los conflictos se resuelven en tu rama, no en
main. git fetch --pruneborra ramas de seguimiento huérfanas;git branch -vvlas marca como «gone».git branch -dborra una rama local solo si ya se fusionó.
28 · Rebase: historia lineal y su regla de oro
Avanzado ~24 minHasta 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 rebasey en qué se diferencia demerge; - actualizar tu rama con
rebasey resolver conflictos durante el proceso; - subir una rama rebasada con
--force-with-leasesin 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 --allfeature/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 maingit log --oneline --graph --allGit 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ó.
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 pushgit push --force-with-lease--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 maingit merge feature/promogit log --onelineConflictos 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 maincat promo.htmlLo 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 --continuegit log --oneline| Durante un rebase | Qué hace |
|---|---|
git rebase --continue | Sigue con el siguiente commit tras resolver y hacer git add |
git rebase --skip | Descarta el commit que está aplicando |
git rebase --abort | Cancela 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 --rebasegit log --oneline --graphMuchos 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~3Git abre tu editor con la lista de los últimos tres commits (el más antiguo arriba):
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~3git log --onelineTres commits convertidos en uno. reword cambia solo un mensaje y drop elimina un commit.
| merge | rebase | |
|---|---|---|
| Historia | Real, con bifurcaciones | Lineal, como si todo fuera en orden |
| Commits existentes | No los toca | Los reemplaza por copias nuevas |
| Conflictos | Una vez, al final | Uno por cada commit que choca |
| Seguro en ramas compartidas | Siempre | Solo si nadie más tiene esos commits |
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 --onelineTras 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--abort devuelve la rama a su estado previo: mismos commits (fe759e6, e5f4d1a) y carpeta limpia.
Puntos clave
git rebase mainvuelve a aplicar tus commits encima demain: historia lineal, hashes nuevos.- Un conflicto se resuelve,
git addygit rebase --continue;--abortlo cancela. - Tras rebasar una rama ya subida:
git push --force-with-lease, solo en tu rama. git pull --rebaseevita commits de merge al sincronizar.git rebase -iune (squash), renombra (reword) o elimina (drop) commits antes de compartirlos.
29 · Caja de herramientas: stash, cherry-pick y tag
Intermedio ~20 minTres 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 -sgit stashgit status -s¡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"git status -s
git stash listAhora 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"git stash popTodo volvió: el menú modificado y la página de postres, sobre el nuevo commit del teléfono.
| Comando | Qué hace |
|---|---|
git stash push -u -m "nota" | Guarda los cambios (también archivos nuevos) con una descripción |
git stash list | Lista lo guardado: stash@{0} es lo más reciente |
git stash pop | Restaura lo último y lo quita del cajón |
git stash apply | Restaura lo último, pero lo deja en el cajón |
git stash drop | Borra lo último del cajón sin restaurarlo |
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/temporadaDesde main, copia solo el commit de la corrección usando su hash:
git cherry-pick 4aa378egit log --oneline --graph --all4dcd3ae 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.
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 taggit show --no-patch v1.0Las etiquetas no se suben con un git push normal: hay que enviarlas explícitamente.
git push origin v1.0git log --onelinetag: 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."| Comando | Qué hace |
|---|---|
git tag -a v1.0 -m "nota" | Etiqueta anotada en el commit actual |
git tag v1.0-beta | Etiqueta ligera: solo el nombre, sin autor ni mensaje |
git tag -a v0.9 4aa378e -m "nota" | Etiqueta un commit anterior |
git push origin v1.0 | Sube una etiqueta (--tags sube todas) |
git tag -d v1.0-beta | Borra una etiqueta local |
Versionado semántico
La convención más usada para nombrar versiones es SemVer:
MAYOR.MENOR.PARCHE.
| Sube… | Cuando… | Ejemplo |
|---|---|---|
| PARCHE | Corriges errores sin cambiar nada más | v1.0.0 → v1.0.1 |
| MENOR | Agregas funciones nuevas compatibles | v1.0.1 → v1.1.0 |
| MAYOR | Haces cambios que rompen lo anterior | v1.1.0 → v2.0.0 |
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 -sSin -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 -ngit tag -n muestra cada etiqueta con la primera línea de su mensaje.
Puntos clave
git stash push -uguarda cambios a medias (incluidos archivos nuevos);git stash poplos recupera.git cherry-pick HASHcopia 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 congit push origin v1.0.- Versionado semántico: MAYOR.MENOR.PARCHE.
30 · Rescate y graduación: revert, reset y reflog
Avanzado ~26 minTodos 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 resety 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ón | Herramienta | Qué hace |
|---|---|---|
| El commit ya se subió | git revert | Crea un commit nuevo que deshace el cambio. No reescribe nada. |
| El commit solo está en tu computadora | git reset | Mueve 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 --onelinegit 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-editcat menu.htmlgit log --onelinegit push10cd1d0 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--mixed (el modo por defecto): los cambios quedan en tu carpeta, sin preparar:
git reset HEAD~1
git status -s--hard: se descartan también los cambios. La carpeta vuelve a quedar como en el commit anterior:
git reset --hard HEAD~1git status -s
git log --onelinegit 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.| Modo | Commit | Área de preparación | Tus archivos |
|---|---|---|---|
--soft | Se deshace | Conserva los cambios | Conserva los cambios |
--mixed | Se deshace | Se vacía | Conserva los cambios |
--hard | Se deshace | Se vacía | Pierde los cambios |
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 refloggit reset --hard 4ff317agit log --onelineEl 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/encuestagit branch feature/encuesta 0c3764d
git log --oneline feature/encuestaSi ya no tienes ese mensaje a la vista, busca el hash en git reflog.
Mapa para deshacer
| Quiero… | Comando | Capítulo |
|---|---|---|
| Descartar cambios de un archivo sin preparar | git restore archivo | 11 |
| Sacar un archivo del área de preparación | git restore --staged archivo | 11 |
| Corregir el último commit (no subido) | git commit --amend | 11 |
| Cancelar un merge con conflictos | git merge --abort | 20 |
| Cancelar un rebase | git rebase --abort | 28 |
| Deshacer un commit ya subido | git revert HASH | 30 |
| Deshacer commits locales | git reset [--soft|--hard] HEAD~1 | 30 |
| Recuperar un commit o una rama | git reflog + git branch / git reset | 30 |
Graduación
Empezaste preguntándote por qué existe Git y terminas trabajando como un equipo profesional. Repasa todo lo que ya sabes hacer:
| Parte | Lo que dominas |
|---|---|
| I · Primeros pasos | Instalar y configurar Git, moverte en la terminal y crear repositorios. |
| II · Git a solas | Las tres zonas, commits con buenos mensajes, leer la historia, comparar y deshacer, .gitignore. |
| III · Ramas | Crear, cambiar, fusionar (fast-forward y tres vías) y ordenar ramas. |
| IV · Conflictos | Entender, leer y resolver conflictos sin miedo. |
| V · Equipo con GitHub | Remotos, SSH, clonar, sincronizar, Pull Requests con gh y trabajo en paralelo. |
| VI · Nivel profesional | Rebase, 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):
- Pro Git, el libro oficial de Git, gratuito y en español.
- Referencia de Git: el detalle de cada comando (también con
git help comando). - Documentación de GitHub y el manual de gh.
- GitHub Skills: cursos prácticos dentro de GitHub.
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 --onelinerevert 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 --onelineHEAD@{1} es «donde estaba HEAD antes del último movimiento»: justo antes del reset.
Puntos clave
git revert HASHdeshace un commit compartido creando uno nuevo; no reescribe la historia.git reset HEAD~1deshace commits locales:--softconserva lo preparado,--mixedlos archivos,--hardnada.--hardborra los cambios sin commit para siempre.git reflogregistra cada movimiento de HEAD y permite rescatar commits y ramas.- Una rama borrada se recrea con
git branch nombre HASH.