git Cheatsheet

2.47

Los comandos de git que usarás todos los días

Official docs →English version

Español: 2026-03-29

Git es una de esas herramientas donde puedes arreglártelas con unos 15 comandos durante años — y entonces un día accidentalmente haces rebase de tu rama main y de repente deseas haber aprendido algunos más. Este cheatsheet es esos "algunos más" sin el ataque de pánico.

Esto es algo que nadie te dice al principio: git es realmente solo un grafo acíclico dirigido de snapshots. Cada commit es un snapshot, cada branch es un puntero, y HEAD es solo una nota adhesiva que dice "estás aquí." Una vez que eso hace clic, todo lo demás — rebase, cherry-pick, reset — deja de sentirse como magia negra y empieza a sentirse como mover notas adhesivas.

Hemos organizado esto por flujo de trabajo en lugar de alfabéticamente, porque nadie piensa "necesito un comando que empiece con R." Piensas "necesito deshacer ese último commit" o "necesito traer la rama de mi compañero." Empieza con Flujo de Trabajo Básico si estás comenzando, luego ramifícate (el juego de palabras es totalmente intencional) a medida que te sientas cómodo. Las secciones de Stash y Reset te salvarán el pellejo al menos una vez por semana.

Una regla de oro: haz commit temprano, haz commit frecuentemente. Los commits pequeños son fáciles de revisar, fáciles de revertir y fáciles de entender seis meses después cuando estés leyendo git log y preguntándote qué estaba pensando tu yo del pasado.

Flujo de Trabajo Básico
git init
Crear un nuevo repositorio en el directorio actual
git clone <url>
Descargar un repositorio y todo su historial
git status
Mostrar archivos modificados, preparados y sin seguimiento
git add <file>
Preparar un archivo específico para el próximo commit
git add .
Preparar todos los cambios en el directorio actual
git commit -m "<msg>"
Hacer commit de los cambios preparados con un mensaje
git push
Subir commits locales al remoto
git pull
Descargar y fusionar cambios remotos en tu rama
Branching
git branch
Listar todas las ramas locales
git branch -a
Listar ramas locales y remotas
git branch <name>
Crear una nueva rama (pero quedarse en la actual)
git switch <name>
Cambiar a una rama existente
git switch -c <name>
Crear una nueva rama y cambiar a ella
git branch -d <name>
Eliminar una rama (seguro — bloquea si no está fusionada)
git branch -D <name>
Forzar eliminación de una rama, incluso si no está fusionada
git branch -m <new>
Renombrar la rama actual
Merge y Rebase
git merge <branch>
Fusionar una rama en tu rama actual
git merge --no-ff <branch>
Fusionar con un commit de merge, incluso si fast-forward es posible
git rebase <branch>
Replicar tus commits sobre otra rama
git rebase --abort
Cancelar un rebase en progreso y restaurar el estado original
git rebase --continue
Continuar el rebase después de resolver conflictos
git merge --abort
Cancelar un merge en progreso
git cherry-pick <hash>
Aplicar un commit individual de otra rama
Stash
git stash
Guardar temporalmente todos los cambios sin commit
git stash -u
Guardar en stash incluyendo archivos sin seguimiento
git stash pop
Restaurar el stash más reciente y eliminarlo
git stash apply
Restaurar el stash más reciente pero mantenerlo en la lista
git stash list
Mostrar todos los conjuntos de cambios guardados en stash
git stash drop
Eliminar el stash más reciente
git stash drop stash@{n}
Eliminar un stash específico por índice
Log y Diff
git log
Mostrar historial de commits de la rama actual
git log --oneline
Historial compacto de una línea por commit
git log --graph --oneline
Mostrar historial de ramas como un gráfico ASCII
git diff
Mostrar cambios no preparados vs último commit
git diff --staged
Mostrar cambios preparados vs último commit
git diff <branch1> <branch2>
Comparar dos ramas
git show <hash>
Mostrar los cambios de un commit específico
git log -p <file>
Mostrar el historial completo de cambios de un archivo
Reset y Revert
git reset <file>
Quitar un archivo del staging pero mantener los cambios
git reset HEAD~1
Deshacer el último commit, mantener cambios en staging
git reset --soft HEAD~1
Deshacer el último commit, mantener cambios en staging (explícito)
git reset --hard HEAD~1
Deshacer el último commit y descartar todos los cambios permanentemente
git revert <hash>
Crear un nuevo commit que deshace un commit anterior
git checkout -- <file>
Descartar cambios no preparados de un archivo específico
git restore <file>
Descartar cambios no preparados (sintaxis moderna)
git restore --staged <file>
Quitar un archivo del staging (sintaxis moderna)
Remotos
git remote -v
Listar todos los remotos con sus URLs
git remote add <name> <url>
Agregar un nuevo repositorio remoto
git fetch
Descargar cambios remotos sin fusionar
git fetch --prune
Descargar y eliminar ramas de seguimiento remoto obsoletas
git pull --rebase
Descargar cambios remotos y hacer rebase de tu trabajo encima
git push -u origin <branch>
Subir una rama y configurarla para rastrear el remoto
git push origin --delete <branch>
Eliminar una rama remota
Tags
git tag
Listar todos los tags
git tag <name>
Crear un tag ligero en el commit actual
git tag -a <name> -m "<msg>"
Crear un tag anotado con un mensaje
git push --tags
Subir todos los tags locales al remoto
git tag -d <name>
Eliminar un tag local
git push origin --delete <tag>
Eliminar un tag remoto

Usa git switch y git restore en lugar de git checkout. El comando checkout hace demasiadas cosas — switch maneja ramas, restore maneja archivos. Intención más clara, menos errores.

Ejecuta git pull --rebase en lugar de un simple git pull para mantener tu historial lineal. Mejor aún, configúralo como predeterminado: git config --global pull.rebase true.

¿Cometiste un error tipográfico en tu último mensaje de commit? git commit --amend -m "mensaje corregido" lo reescribe. Solo no hagas amend de commits que ya hayas subido — eso reescribe historial del que tus compañeros podrían depender.

Usa git stash -u en lugar de un simple git stash. La flag -u incluye archivos sin seguimiento, que es casi siempre lo que quieres. Sin ella, los archivos nuevos que no hayas añadido se quedan atrás.

El git reflog es tu máquina del tiempo. Incluso después de un mal reset --hard, tus commits no desaparecen realmente durante unos 30 días. Ejecuta git reflog, encuentra el hash que quieres, y git reset --hard <hash> para recuperarlo.

Antes de un merge o rebase grande, crea una "rama de seguridad" con git branch backup-antes-del-merge. Si todo sale mal, siempre puedes volver a donde empezaste. Un seguro barato.

Usa git log --oneline --graph --all para visualizar toda la topología de ramas en el terminal. Es la forma más rápida de entender qué está pasando en un repo con múltiples ramas activas.

Related Tools

nvimlazygittmux