Git cheatsheet: los comandos esenciales (con ejemplos)

Git es la herramienta de control de versiones que usa prácticamente todo el desarrollo de software. Tiene muchísimos comandos, pero en el día a día se repiten unos cuantos. Esta chuleta reúne los esenciales con ejemplos, organizados por tarea, para tenerlos siempre a mano.

Configuración inicial

git config --global user.name "Tu Nombre"
git config --global user.email "tu@email.com"
git config --global init.defaultBranch main

Configura tu identidad (aparece en cada commit) y la rama por defecto.

Empezar un repositorio

git init                      # Crea un repo nuevo en la carpeta actual
git clone <url>               # Clona un repo remoto
git clone <url> mi-carpeta    # Clona en una carpeta concreta

El flujo básico: estado, añadir, commit

git status                    # Qué ha cambiado
git add archivo.js            # Prepara un archivo para el commit
git add .                     # Prepara TODOS los cambios
git commit -m "mensaje"       # Crea el commit con lo preparado
git commit -am "mensaje"      # add + commit de archivos ya rastreados

El ciclo mental: modificas → add (staging) → commit (guardas).

Ramas (branches)

git branch                    # Lista las ramas
git branch nueva-rama         # Crea una rama
git checkout nueva-rama       # Cambia a esa rama
git checkout -b nueva-rama    # Crea Y cambia en un paso
git switch nueva-rama         # Alternativa moderna a checkout
git branch -d rama            # Borra una rama ya fusionada
git branch -D rama            # Borra una rama a la fuerza

Trabajar en ramas separa cada tarea o función del código estable.

Sincronizar con el remoto

git pull                      # Trae y fusiona los cambios del remoto
git push                      # Sube tus commits al remoto
git push -u origin mi-rama    # Sube y enlaza la rama por primera vez
git fetch                     # Trae cambios SIN fusionar
git remote -v                 # Muestra los remotos configurados

Fusionar cambios (merge)

git merge otra-rama           # Fusiona otra-rama en la actual
git merge --abort             # Cancela un merge con conflictos

Cuando hay un conflicto, Git marca las zonas en disputa con <<<<<<<, ======= y >>>>>>>. Edita el archivo dejando la versión correcta, quita esos marcadores, y haz git add + git commit.

Deshacer cambios (lo más buscado)

git restore archivo.js        # Descarta cambios no guardados de un archivo
git restore --staged archivo  # Quita un archivo del staging (sin perderlo)
git reset --soft HEAD~1       # Deshace el último commit, MANTIENE los cambios
git reset --hard HEAD~1       # Deshace el último commit y BORRA los cambios
git revert <hash>             # Crea un commit que deshace otro (seguro en remoto)

Regla de oro: reset --hard borra trabajo; úsalo con cuidado. En ramas compartidas usa revert, que no reescribe el historial.

Guardar cambios temporalmente (stash)

git stash                     # Guarda tus cambios y limpia el árbol de trabajo
git stash list                # Lista lo guardado
git stash pop                 # Recupera lo último guardado y lo borra del stash
git stash apply               # Recupera sin borrarlo del stash

Útil cuando necesitas cambiar de rama pero no quieres hacer commit aún.

Ver el historial y las diferencias

git log --oneline             # Historial compacto, una línea por commit
git log --graph --oneline     # Con gráfico de ramas
git diff                      # Cambios sin preparar (no staged)
git diff --staged             # Cambios preparados (staged)
git show <hash>               # Detalle de un commit concreto

Para comparar dos textos o versiones fuera de Git, puedes usar el comparador de textos, que resalta las diferencias en tu navegador.

Comandos que salvan el día

git reflog                    # Historial de TODO lo que has hecho (recupera commits "perdidos")
git cherry-pick <hash>        # Aplica un commit concreto de otra rama
git commit --amend            # Corrige el último commit (mensaje o contenido)
git clean -fd                 # Borra archivos no rastreados (¡cuidado!)

git reflog es el botón de pánico: aunque creas que has perdido un commit con un reset, casi siempre sigue ahí y puedes recuperarlo.

Buenas prácticas

Commits pequeños y frecuentes con mensajes claros: cada commit debería contar "qué" y "por qué".
Una rama por tarea: mantén main siempre estable.
Haz pull antes de empezar para no trabajar sobre código viejo.
No reescribas el historial (rebase, reset --hard, push --force) en ramas compartidas.

Conclusión

No necesitas memorizar los cientos de comandos de Git: con este puñado cubres el 95% del trabajo diario. Guarda esta chuleta, y cuando dudes con un merge o quieras deshacer algo, vuelve a ella. Y recuerda: ante un susto, git reflog suele tener la solución.