Comandos de Git | Guía Interactiva Didáctica: Por dónde viajan tus cambios

Pipeline de Transporte de Cambios

Selecciona una acción para ver sus comandos

Carpeta de trabajoTus archivos locales

Área de preparaciónLo que irá en el commit (Index)

Repositorio localTu historial (.git)

RemotoGitHub, GitLab o servidor

Operaciones Complementarias

Temas esenciales del día a día

/

git add

Preparar cambios

De la carpeta de trabajo al área de preparación (Staging Area).

$git status

Muestra el estado de los archivos modificados y sin seguimiento

Úsalo antes de agregar archivos para verificar qué ha cambiado exactamente.

habitual

$git diff

Muestra línea por línea los cambios aún no preparados

Compara tu carpeta de trabajo contra el área de preparación.

habitual

$git add

Prepara un archivo específico para el próximo commit

Ejemplo: git add index.html estilos.css

básico

$git add .

Prepara todos los cambios en el directorio actual y subdirectorios

Incluye modificaciones, creaciones y eliminaciones.

básico

$git add -p

Modo interactivo: permite revisar y preparar fragmento por fragmento

Ideal para commits limpios con cambios específicos por partes.

avanzado

Laboratorio Interactivo

Simulador de Terminal en Vivo

Experimenta el ciclo de vida de Git en tiempo real. Ejecuta comandos de muestra y observa cómo responde la consola oficial y qué estado se activa en el flujo.

bash — git-demo@localhost: ~/mi-proyecto (main)

Haz clic para ejecutar:

developer@pc:~/mi-proyecto (main)$ git status

On branch main
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
	modified:   src/app.js
	modified:   public/styles.css

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	src/auth.js

no changes added to commit (use "git add" to track)

developer@pc:~/mi-proyecto (main)$

Estado actual de tus cambios:

1. Carpeta de trabajo

→

2. Área de preparación

→

3. Repositorio local

→

4. Remoto

Laboratorio Gráfico

Simulador Visual de Ramas: Merge vs Rebase

Observa cómo se conectan y reordenan los commits en tiempo real al ejecutar operaciones de fusión o rebase en Git.

Domina el Conflicto

Simulador Interactivo de Conflictos de Merge

Aprende qué ocurre cuando Git se detiene en un merge o rebase. Practica resolviendo colisiones de código reales y comprende los marcadores <<<<<<< HEAD sin miedo.

HEAD: main⤹feat/oauth2

Conflicto al actualizar el método de autenticación y tiempo de expiración del token JWT.

src/config/auth.tsNO RESUELTO

Comandos de consola para finalizar:

Registrar archivo resuelto

git add src/config/auth.ts

Concluir el commit de merge

git merge --continue

SOS

¡Pánico! Abortar sin cambios

git merge --abort

Cazador Binario de Bugs

Simulador Interactivo de Git Bisect

Descubre qué commit exacto rompió producción mediante búsqueda binaria O(log N). Prueba estados de código o automatiza la búsqueda con tus tests.

Estado: Listo para iniciar la depuración

El commit C8 está roto (bad) y C1 funcionaba correctamente (good). Haz clic en Iniciar para calcular el punto medio.

a1b2c3dfeat: setup base project structure

e4f5a6bfeat: add user login endpoint

c7d8e9ffix: handle token expiration

1a2b3c4perf: optimize sql queries in auth

5e6f7a8refactor: change payload signature in parser

9b0c1d2style: format response json outputs

3e4f5a6docs: update api swagger documentation

7b8c9d0feat: add analytics event ping

Automatización Pro:

Puedes automatizar la búsqueda al 100% conectándola con tu suite de pruebas:git bisect run npm test

Reescritura Interactiva de Historia

Playground de Rebase Interactivo (git rebase -i)

Experimenta visualmente con el rebase interactivo. Reordena commits, fusiona arreglos rápidos con squash/fixup, edita mensajes o elimina cambios sin miedo. Descubre por qué Git recalcula los hashes SHA y crea un historial lineal limpio.

OrdenAcción (Comando)HashMensaje del Commit

.git/rebase-merge/git-rebase-todo (vim buffer)

# git-rebase-todo preview

La Regla de Oro del Rebase:Nunca hagas rebase de commits que ya hayas subido (push) a una rama pública o compartida (como main o production). El rebase altera los hashes SHA-1, lo cual obligará a tus compañeros a resolver conflictos de sincronización innecesarios.

Git SOS — Modo Rescate

¿Metiste la pata? Aquí está la solución

Los errores en Git le pasan a todo el mundo. Encuentra tu escenario exacto y sigue los pasos comprobados para recuperar tu código sin pánico.

Riesgo mediaramas

Hice commit en la rama incorrecta (ej. en main)

Mover el último commit a una nueva rama sin perder nada

Situación:

Trabajaste y ejecutaste git commit directamente en la rama principal en lugar de crear una rama secundaria.

Pasos de solución:

git branch mi-rama-correcta

Crea la rama deseada exactamente en el punto actual con tu último commit incluido.

git reset --hard HEAD~1

Retrocede la rama actual (main) un commit hacia atrás para dejarla limpia.

git switch mi-rama-correcta

Pasa a tu nueva rama donde tu commit sigue intacto y listo para continuar.

Si ya habías subido el commit al repositorio remoto, no uses reset --hard; recurre a git revert para crear un commit inverso seguro.

Riesgo bajacommits

Escribí mal el mensaje del commit o me faltó un archivo

Corregir el commit más reciente de forma instantánea

Situación:

Cometiste una errata en el texto del mensaje o te diste cuenta de que olvidaste incluir un archivo.

Pasos de solución:

git add archivo-olvidado.js

(Opcional) Si te faltó un archivo, prepáralo primero con git add.

git commit --amend -m "feat: nuevo mensaje corregido"

Sobrescribe el mensaje y fusiona los archivos preparados en el commit previo sin duplicar historial.

Usa amend únicamente antes de haber hecho git push al servidor remoto.

Riesgo altaarchivos

Hice commit de contraseñas, claves API o un archivo .env

Eliminar archivos sensibles antes de enviarlos a producción

Situación:

Por error agregaste credenciales privadas a tu repositorio local.

Pasos de solución:

git rm --cached .env

Elimina el archivo del índice de Git pero lo conserva físicamente en tu disco duro.

echo ".env" >> .gitignore

Agrega el archivo a .gitignore para que Git nunca más vuelva a rastrearlo.

git commit -m "fix: remover archivo sensible del control de versiones"

Registra el cambio para que el archivo ya no exista en el próximo push.

Si ya hiciste push a GitHub, la clave debe considerarse comprometida y debe ser revocada/regenerada inmediatamente en el proveedor.

Riesgo bajaramas

Necesito cambiar de rama ya pero tengo cambios sin terminar

Guardar temporalmente el trabajo en un escondite seguro

Situación:

Tu jefe o compañero te pide revisar algo urgente en otra rama, pero tu código actual no compila ni amerita un commit.

Pasos de solución:

git stash

Limpia tu espacio de trabajo y guarda todas tus modificaciones en una pila temporal.

git switch otra-rama

Cambia de rama con el directorio totalmente limpio para realizar la tarea urgente.

git switch tu-rama

Vuelve a tu rama original cuando hayas finalizado la urgencia.

git stash pop

Restaura tus cambios pendientes exactamente como los tenías y vacía el cajón.

Riesgo mediaconflictos

Tengo un conflicto de merge y quiero cancelar todo

Volver al estado seguro antes de iniciar el merge

Situación:

Al ejecutar git merge o git pull aparecieron conflictos complicados y prefieres abortar para no romper nada.

Pasos de solución:

git merge --abort

Cancela la fusión en curso y restaura tus archivos al estado previo al intento de mezcla.

git status

Verifica que tu árbol de trabajo ha vuelto a un estado completamente limpio.

Si el conflicto ocurrió durante un rebase, el comando equivalente es: git rebase --abort.

Riesgo altacommits

Borré una rama o perdí un commit valioso

Rescatar código perdido con la bitácora universal de Git

Situación:

Ejecutaste un reset agresivo o eliminaste una rama creyendo que no servía y perdiste tu trabajo.

Pasos de solución:

git reflog

Muestra un registro cronológico de todas las acciones recientes junto a sus identificadores hash.

git switch -c rama-recuperada <hash-encontrado>

Crea una nueva rama partiendo exactamente del commit antes de ser perdido.

Los commits huérfanos se conservan en Git habitualmente por al menos 30 días antes del recolector de basura.

Guías de Trabajo en Equipo

Flujos de Trabajo Guiados Paso a Paso

Aprende los procedimientos estándar de la industria. Cada paso incluye el comando a ejecutar y la razón conceptual detrás de él.

Principiante

Tu primer proyecto en GitHub

Ruta completa para inicializar una carpeta local y publicarla en un repositorio remoto.

5Pasos clave

Inicializar el repositorio

Crea la estructura oculta .git dentro de tu carpeta actual.

$git init

Modelo mental: Transforma una carpeta ordinaria en un almacén con memoria temporal de cambios.

Preparar todos los archivos iniciales

Mueve todos los archivos del proyecto al área de preparación.

$git add .

Modelo mental: Coloca tus archivos en la caja lista para ser precintada.

Crear el primer commit (Snapshot)

Registra la versión inicial en el historial permanente de tu computadora.

$git commit -m "feat: estructura inicial del proyecto"

Modelo mental: Guarda una instantánea imborrable con fecha, autor y mensaje.

Conectar tu computadora con GitHub

Asigna el alias "origin" a la dirección web de tu repositorio.

$git remote add origin https://github.com/usuario/mi-proyecto.git

Modelo mental: Crea un puente de comunicación hacia la nube.

Publicar tus commits en la nube

Envía tu rama main y la deja vinculada para futuros push rápidos.

$git push -u origin main

Modelo mental: Sube la caja fuerte local al servidor remoto.

Frente a Frente

Comparativas Cara a Cara

Aclara las confusiones más comunes en Git. Comprende las diferencias técnicas, ventajas y el momento exacto para usar cada alternativa.

Opción A

`git fetch`

Descarga referencias, ramas y commits del servidor remoto SIN modificar tus archivos locales.

Cuándo usarlo:

Siempre que quieras curiosear qué hicieron tus compañeros sin alterar tu carpeta de trabajo.

Ventajas:

100% seguro: nunca genera conflictos en tus archivos
Permite revisar con git diff origin/main antes de aplicar
No altera tu rama actual

Desventajas / Precauciones:

Requiere un paso adicional (merge o rebase) para aplicar los cambios

Opción B

`git pull`

Equivale a ejecutar "git fetch" seguido automáticamente de "git merge".

Cuándo usarlo:

Cuando sabes con certeza que quieres incorporar los cambios remotos de inmediato.

Ventajas:

Rápido y conveniente en un solo comando
Mantiene tu rama al día en un segundo

Desventajas / Precauciones:

Puede detonar conflictos de merge sorpresa en tu pantalla
Puede crear commits de mezcla innecesarios si no usas --rebase

Asistente Inteligente

Generador Asistido de Comandos

Completa tus datos y obtén comandos exactos listos para copiar y pegar en tu terminal, siguiendo las mejores prácticas de la industria.

Herramienta 1

Generador de Ramas Semánticas

Crea ramas con nomenclatura estandarizada según el propósito del trabajo.

Tipo de tarea

Nombre descriptivo (kebab-case)

Comando listo para ejecutar:

$git switch -c feat/autenticacion-oauth

Herramienta 2

Secuencia de Primer Repositorio

Genera el bloque completo de comandos para publicar un proyecto local en GitHub de una sola vez.

URL del repositorio remoto (HTTPS o SSH)

Rama principal

Script completo (5 pasos):

Estándar Profesional

Asistente de Commits Semánticos (Conventional Commits)

Aprende a redactar mensajes claros y profesionales según la especificación Conventional Commits. Mejora el historial de tu equipo y facilita la generación automática de versiones y changelogs.

Tipo de cambio (Type)

Alcance opcional (Scope)

Descripción concisa en imperativo

¿Es un Breaking Change (Cambio disruptivo)?Introduce incompatibilidades con versiones anteriores (agrega el modificador "!" en el commit).

Comando de commit generado:

$git commit -m "feat(auth): implementar autenticacion con tokens jwt"

feat(auth):implementar autenticacion con tokens jwt

Prevención de Errores

Generador Interactivo de .gitignore

Evita subir por accidente secretos, contraseñas o carpetas gigantescas como node_modules/. Marca tus tecnologías y obtén tu archivo listo.

.gitignore

Terminal Turbo

Bóveda de Aliases y Productividad Pro

Los desarrolladores senior no teclean comandos largos una y otra vez. Configura atajos de alta velocidad y banderas recomendadas directamente en tu ~/.gitconfig.

$git lg

Grafo de historial visual, ultra compacto y coloreado en una línea por commit.

Se expande a:

git log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --date=relative

$git st

Estado breve (short) mostrando la rama actual y la relación con upstream.

Se expande a:git status -sb

$git unstage

Saca archivos del Staging Area sin perder las modificaciones locales.

Se expande a:git restore --staged

$git undo

Deshace el último commit pero conserva todos los cambios en el Staging Area.

Se expande a:git reset --soft HEAD~1

$git amend

Agrega los archivos en staging al commit anterior sin abrir el editor de mensaje.

Se expande a:git commit --amend --no-edit

$git br

Lista ramas locales con su último commit y estado de tracking remoto.

Se expande a:git branch -vv

$git cleanup

Elimina de forma segura todas las ramas locales que ya fueron fusionadas.

Se expande a:git !git branch --merged | grep -v "\*" | xargs -n 1 git branch -d

$git wip

Guarda rápidamente un snapshot temporal de trabajo en progreso.

Se expande a:git !git add -A && git commit -m "chore: work in progress [skip ci]"

~/.gitconfig

Plantilla optimizada que incluye rebase automático al hacer pull, rama main por defecto y reutilización de resoluciones de conflictos grabadas (rerere).

[init]
	defaultBranch = main
[pull]
	rebase = true
[rerere]
	enabled = true
[core]
	autocrlf = input
[color]
	ui = auto
[help]
	autocorrect = 1

[alias]
	st = status -sb
	lg = log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --date=relative
	undo = reset --soft HEAD~1
	unstage = restore --staged
	amend = commit --amend --no-edit
	br = branch -vv
	cleanup = !git branch --merged | grep -v "\\*" | xargs -n 1 git branch -d
	wip = !git add -A && git commit -m "chore: work in progress [skip ci]"

Ingeniería Defensiva

Automatizaciones con Git Hooks (Husky & Scripts)

Evita bugs, código desordenado y filtración de contraseñas antes de que lleguen a tu repositorio. Copia scripts de hooks probados en producción.

pre-commitLado Cliente

Auditoría de seguridad y linter antes de crear el commit

Se ejecuta antes de que se abra el editor para el mensaje del commit. Si sale con código distinto de cero, el commit se cancela inmediatamente.

.git/hooks/pre-commit

#!/bin/sh
# 1. Prevenir commit de archivos .env accidentales
if git diff --cached --name-only | grep -E "(^|/).env"; then
  echo "ERROR: Intento de commit de archivo .env detectado!"
  echo "Elimínalo del Staging Area con: git reset HEAD .env*"
  exit 1
fi

# 2. Ejecutar linter en archivos en preparación
echo "Ejecutando verificacion de codigo..."
npm run lint-staged || exit 1

commit-msgLado Cliente

Exigir estándar Conventional Commits en el mensaje

Recibe como parámetro la ruta del archivo temporal con el mensaje de commit. Permite validar que cumpla el formato feat:, fix:, docs:, etc.

.git/hooks/commit-msg

#!/bin/sh
MSG_FILE=$1
COMMIT_MSG=$(cat "$MSG_FILE")

# Validar formato: tipo(alcance)?: descripcion
REGEX="^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\([a-z0-9_-]+\))?: .+"

if ! echo "$COMMIT_MSG" | grep -qE "$REGEX"; then
  echo "ERROR: Mensaje de commit invalido!"
  echo "Formato requerido: feat(auth): descripcion en imperativo"
  exit 1
fi

pre-pushLado Cliente

Garantizar que las pruebas unitarias pasen antes de enviar a remoto

Se ejecuta justo antes de transferir datos al servidor remoto con git push. Ideal para evitar romper el pipeline CI/CD en GitHub.

.git/hooks/pre-push

#!/bin/sh
echo "Ejecutando suite de pruebas antes de hacer push..."
npm test -- --bail

if [ $? -ne 0 ]; then
  echo "ERROR: Pruebas fallidas. El push ha sido cancelado para proteger el repositorio remoto."
  exit 1
fi

Flujo Moderno

Configuración Moderna con Husky en 3 Pasos

En lugar de editar manualmente .git/hooks (que no se guardan en el repositorio), los equipos modernos usan Husky para compartir hooks con todo el equipo.

Terminal (Node.js / NPM)

# 1. Instalar Husky en tu proyecto moderno
npx husky init

# 2. Agregar hook de pre-commit para linter y secretos
echo "npx lint-staged" > .husky/pre-commit

# 3. Agregar hook para validar Conventional Commits
echo "npx --no -- commitlint --edit $1" > .husky/commit-msg

Bajo el Capó

Anatomía de Objetos y Plomería Interna de Git

Git no es magia: es un grafo acíclico dirigido (DAG) direccionable por contenido. Descubre cómo interactúan Blobs, Trees, Commits y Referencias bajo la superficie.

BLOB

Blob (Binary Large Object)

Almacenamiento de contenido puro

Un Blob solo almacena los bytes de un archivo comprimidos con zlib. No guarda el nombre del archivo, los permisos ni la fecha; solo el contenido puro indexado por su hash SHA-1.

Relación en el Grafo (DAG):

Commitf4a1209

➔

Tree (root)83ba6fc

➔

Blob70a34b2

¿Sabías que?Una rama de Git como main es solo un archivo de texto plano de 41 bytes en .git/refs/heads/main que contiene el hash SHA-1 de su último commit.

$git cat-file -p 70a34b2

SHA-1 / SHA-256 HASH:70a34b220377e8a93da26042e9154a43c7b3992d

Contenido Descomprimido del Objeto:

console.log("Hola Mundo!");
export const API_KEY = "segura";

Quieres crear una rama llamada "feat/perfil" y trasladarte a ella inmediatamente en un solo paso con la sintaxis moderna de Git.

¿Cuál es el comando recomendado por la documentación actual de Git?

Reto 3 de 5

Escenario:

Subiste un commit erróneo a la rama "main" en GitHub que ya fue descargado por varios compañeros de equipo.

¿Cuál es la estrategia más segura para deshacer ese commit en un repositorio compartido?

Reto 4 de 5

Escenario:

Quieres inspeccionar qué cambios han subido tus compañeros a GitHub antes de decidir si los fusionas o no en tu código.

¿Qué comando descarga la información remota sin tocar ni alterar tus archivos locales?

Reto 5 de 5

Escenario:

Acabas de hacer un commit local pero olvidaste agregar una pequeña modificación en un archivo antes de subirlo.

Preparar cambios

Guardar en el historial

Subir al remoto

Traer del remoto

Empezar

Ramas

Deshacer

Resultados encontrados

Simulador de Terminal en Vivo

Simulador Visual de Ramas: Merge vs Rebase

Simulador Interactivo de Conflictos de Merge

Simulador Interactivo de Git Bisect

Playground de Rebase Interactivo (git rebase -i)

¿Metiste la pata? Aquí está la solución

Estación de Seguridad sin Pánico

Hice commit en la rama incorrecta (ej. en main)

Escribí mal el mensaje del commit o me faltó un archivo

Hice commit de contraseñas, claves API o un archivo .env

Necesito cambiar de rama ya pero tengo cambios sin terminar

Tengo un conflicto de merge y quiero cancelar todo

Borré una rama o perdí un commit valioso

Flujos de Trabajo Guiados Paso a Paso

Desarrollo en Paralelo y Fusiones Limpias

Tu primer proyecto en GitHub

Inicializar el repositorio

Preparar todos los archivos iniciales

Crear el primer commit (Snapshot)

Conectar tu computadora con GitHub

Publicar tus commits en la nube

Flujo en equipo (Feature Branch Workflow)

Asegurar sincronización de main

Crear una rama para tu tarea

Preparar y confirmar tus avances

Publicar tu rama en el remoto

Resolución de conflictos de fusión

Descubrir qué archivos chocaron

Inspeccionar los marcadores en el código

Limpiar y marcar el conflicto como resuelto

Cerrar la fusión de forma limpia

Comparativas Cara a Cara

git fetch

git pull

git merge

git rebase

git restore / git reset

git revert

git switch

git checkout

Generador Asistido de Comandos

Generador de Ramas Semánticas

Secuencia de Primer Repositorio

Asistente de Commits Semánticos (Conventional Commits)

Generador Interactivo de .gitignore

Bóveda de Aliases y Productividad Pro

Automatizaciones con Git Hooks (Husky & Scripts)

Auditoría de seguridad y linter antes de crear el commit

Exigir estándar Conventional Commits en el mensaje

Garantizar que las pruebas unitarias pasen antes de enviar a remoto

Configuración Moderna con Husky en 3 Pasos

Anatomía de Objetos y Plomería Interna de Git

Blob (Binary Large Object)

Glosario Visual de Conceptos Clave

HEAD

Detached HEAD (HEAD desacoplado)

Origin & Upstream

Commit Hash (SHA-1 / SHA-256)

Working Tree (Árbol de trabajo)

Staging Area (Índice o Index)

Fast-Forward (Avance rápido)

Cherry-Pick (Cosecha selectiva)

Squash (Aplastamiento / Fusión de commits)

Reflog (Registro de referencias)

Mini Retos Didácticos

¿Qué comando moderno te permite sacar "estilos.css" del área de preparación sin perder tu código escrito?

¿Cuál es el comando recomendado por la documentación actual de Git?

¿Cuál es la estrategia más segura para deshacer ese commit en un repositorio compartido?

¿Qué comando descarga la información remota sin tocar ni alterar tus archivos locales?

¿Qué opción te permite incorporar ese cambio al último commit sin generar un commit duplicado?

`git fetch`

`git pull`

`git merge`

`git rebase`

`git restore / git reset`

`git revert`

`git switch`

`git checkout`