Chuleta

Comandos de Git: chuleta con ejemplos para el día a día

Actualizado: · Skillaria.Top

Los comandos principales de Git son git init y git clone para crear un repositorio; git status, git add y git commit para guardar cambios; git branch, git switch y git merge para trabajar con ramas; git push, git fetch y git pull para sincronizar con el servidor; y git restore, git reset y git revert para deshacer cambios.

Aquí tienes una chuleta de Git para el trabajo diario: los comandos están agrupados por tareas y cada uno tiene un ejemplo y una breve explicación. Conviene tenerla abierta junto al terminal: casi todo lo que un desarrollador hace con Git en un día cabe en los 20–30 comandos de estas tablas.

Para que los comandos tengan sentido, ten presentes tres áreas: el directorio de trabajo (los archivos en disco), el índice o staging area (lo que entrará en el próximo commit) y el repositorio (el historial de commits en la carpeta .git). La mayoría de los comandos de Git mueven cambios entre estas tres zonas o entre el repositorio local y el remoto.

Configuración de Git

Estos comandos se ejecutan una vez tras la instalación. La opción --global guarda los ajustes en ~/.gitconfig y se aplica a todos los repositorios del usuario; sin ella, solo al repositorio actual.

ComandoQué hace
git config --global user.name "Ana García"Nombre del autor de los commits
git config --global user.email "ana@example.com"Correo del autor de los commits
git config --global init.defaultBranch mainNombre de la rama por defecto en los repositorios nuevos
git config --global core.editor "code --wait"Editor para los mensajes de commit (aquí, VS Code)
git config --global pull.rebase falseComportamiento por defecto de git pull: fusión
git config --global core.autocrlf inputConvertir CRLF en LF al hacer commit (macOS/Linux; en Windows normalmente true)
git config --list --show-originMostrar todos los ajustes y el archivo del que sale cada uno
git config --global alias.st statusAlias: git st en lugar de git status
git --versionVersión de Git instalada
git help commitAyuda completa de un comando (o git commit -h, la breve)

Crear y clonar un repositorio

ComandoQué hace
git initCrea un repositorio vacío (la carpeta .git) en el directorio actual
git init my-projectCrea el directorio my-project y un repositorio dentro
git clone https://github.com/user/repo.gitCopia un repositorio remoto con todo su historial
git clone git@github.com:user/repo.git appClona por SSH en la carpeta app
git clone --depth 1 URLClon superficial: solo el último commit, rápido y ocupa poco
git clone -b develop URLClona y cambia directamente a la rama develop

El ciclo básico: status, add, commit

Es el núcleo del trabajo diario: ver qué ha cambiado, llevar al índice lo necesario y fijarlo con un commit.

ComandoQué hace
git statusEstado: archivos modificados, en el índice y sin seguimiento
git status -sFormato breve: M, modificado; A, añadido; ??, sin seguimiento
git add file.txtAñadir un archivo al índice
git add .Añadir todos los cambios del directorio actual y subdirectorios, incluidos los borrados
git add -AAñadir todos los cambios de todo el repositorio
git add -pElegir de forma interactiva fragmentos concretos (hunks) de los cambios
git commit -m "Añadir formulario de acceso"Crear un commit a partir del índice con un mensaje
git commit -am "Corregir errata"Añadir al índice todos los archivos con seguimiento modificados y hacer commit; los archivos nuevos no entran
git commit --amendReescribir el último commit: añadir lo olvidado del índice o corregir el mensaje
git commit --amend --no-editCompletar el último commit sin cambiar el mensaje
git rm file.txtBorrar un archivo del disco y del índice
git rm --cached secret.envDejar de seguir un archivo pero conservarlo en disco
git mv old.js new.jsRenombrar o mover un archivo

Un escenario típico es este:

git status
git add src/login.js src/login.css
git diff --staged          # comprobar qué va a entrar exactamente en el commit
git commit -m "Añadir formulario de acceso"

No uses --amend con commits que ya se han subido a una rama compartida: crea un commit nuevo con otro hash y tus compañeros tendrán que lidiar con un historial divergente.

Ver el historial y los cambios

ComandoQué hace
git logHistorial de commits de la rama actual
git log --onelineCada commit en una línea: hash corto y título
git log --oneline --graph --allGrafo de todas las ramas en el terminal
git log -p file.txtHistorial de un archivo con el diff de cada commit
git log --author="Ana" --since="2 weeks ago"Filtrar por autor y fecha
git log -S "getUser"Commits en los que se añadió o eliminó la cadena getUser
git log main..featureCommits que están en feature pero no en main
git diffCambios en el directorio de trabajo aún no añadidos al índice
git diff --stagedCambios del índice respecto al último commit (sinónimo de --cached)
git diff main featureDiferencia entre las puntas de dos ramas
git diff HEAD~3 -- src/Cambios en la carpeta src en los tres últimos commits
git show a1b2c3dMetadatos y diff de un commit concreto
git show HEAD:README.mdContenido de un archivo en el último commit
git blame app.jsQuién modificó por última vez cada línea y en qué commit
git shortlog -snNúmero de commits por autor

Las referencias a commits sirven en todas partes: HEAD es el commit actual, HEAD~1 su padre, HEAD~3 tres pasos atrás por el primer padre y HEAD^2 el segundo padre de un commit de merge.

Ramas: crear, cambiar y borrar

Desde la versión 2.23, Git tiene git switch para las ramas y git restore para los archivos: se repartieron las funciones del sobrecargado git checkout. Las formas antiguas siguen funcionando.

ComandoQué hace
git branchLista de ramas locales; la actual va marcada con *
git branch -aRamas locales y remotas (remote-tracking)
git branch -vvRamas con su último commit y cuánto van por detrás o por delante del upstream
git branch feature/loginCrear una rama sin cambiar a ella
git switch feature/loginCambiar a una rama
git switch -c feature/loginCrear una rama y cambiar a ella (equivale a git checkout -b)
git switch -Volver a la rama anterior
git branch -m new-nameRenombrar la rama actual
git branch -d feature/loginBorrar una rama si ya está fusionada
git branch -D feature/loginBorrar una rama a la fuerza, aunque no esté fusionada
git branch --mergedRamas ya integradas en la actual: candidatas a borrarse

Fusión y rebase

ComandoQué hace
git merge featureIntegrar feature en la rama actual (fast-forward si es posible)
git merge --no-ff featureCrear siempre un commit de merge
git merge --squash featureReunir todos los cambios de la rama en el índice como un solo bloque; después, git commit
git merge --abortCancelar una fusión con conflictos y volver al estado inicial
git rebase mainTrasladar los commits de la rama actual encima de main
git rebase -i HEAD~4Modo interactivo: combinar (squash), renombrar, reordenar o eliminar los 4 últimos commits
git rebase --continueContinuar tras resolver un conflicto
git rebase --abortCancelar el rebase por completo
git cherry-pick a1b2c3dAplicar un commit a la rama actual como commit nuevo

Resolver un conflicto de fusión casi siempre se ve igual:

git merge feature
# CONFLICT (content): Merge conflict in app.js
git status                 # archivos en la sección "both modified"
# editamos app.js y quitamos los marcadores <<<<<<< ======= >>>>>>>
git add app.js
git commit                 # Git propondrá un mensaje listo para el commit de merge

La regla principal de rebase: no hagas rebase de commits que ya están en una rama compartida y sobre los que otros construyen su trabajo.

Trabajar con repositorios remotos

ComandoQué hace
git remote -vLista de remotos y sus direcciones
git remote add origin git@github.com:user/repo.gitConectar un repositorio remoto con el nombre origin
git remote set-url origin NEW_URLCambiar la dirección del remoto (por ejemplo, de HTTPS a SSH)
git remote remove upstreamDesconectar un remoto
git fetchDescargar commits y ramas nuevos sin tocar tus archivos
git fetch --pruneLo mismo, y además borrar las referencias a ramas eliminadas en el servidor
git pullgit fetch + fusión de la rama upstream en la actual
git pull --rebasegit fetch + rebase de tus commits encima de los recibidos
git pushEnviar los commits de la rama actual a su upstream
git push -u origin feature/loginPrimer envío de una rama, configurando el upstream
git push --force-with-leaseSobrescribir la rama remota solo si no tiene commits nuevos de otros
git push origin --delete feature/loginBorrar una rama en el servidor
git push --tagsEnviar todas las etiquetas locales

En lugar de git push --force, acostúmbrate a --force-with-lease: si un compañero ya subió algo a esa misma rama, el comando se negará a sobrescribir su trabajo.

Deshacer cambios

La parte más estresante de Git. La pregunta clave antes de elegir el comando: ¿los cambios están solo en los archivos, ya en el índice, en un commit local o en un commit publicado?

SituaciónComando
Descartar los cambios de un archivo (dejarlo como en el último commit)git restore app.js
Sacar un archivo del índice conservando los cambiosgit restore --staged app.js
Recuperar un archivo de un commit concretogit restore --source=a1b2c3d app.js
Deshacer el último commit dejando los cambios en el índicegit reset --soft HEAD~1
Deshacer el último commit dejando los cambios en los archivosgit reset HEAD~1 (modo --mixed por defecto)
Eliminar el último commit y todos sus cambiosgit reset --hard HEAD~1
Deshacer un commit publicado con un commit «inverso» nuevogit revert a1b2c3d
Deshacer un commit de mergegit revert -m 1 <merge-hash>
Ver qué archivos sin seguimiento se borraríangit clean -n
Borrar archivos y carpetas sin seguimientogit clean -fd
Encontrar un commit «perdido» tras un reset o rebasegit reflog y después git reset --hard HEAD@{2}

git reset --hard y git clean -f eliminan sin vuelta atrás los cambios sin commit: el reflog solo guarda commits, no los cambios del directorio de trabajo. Antes de usarlos, haz git stash o al menos git status.

Stash: apartar el trabajo a medias

ComandoQué hace
git stashGuardar los cambios de los archivos con seguimiento y limpiar el directorio de trabajo
git stash push -u -m "wip: formulario"Guardar también los archivos sin seguimiento, con una descripción
git stash listLista de bloques guardados: stash@{0}, stash@{1}…
git stash show -p stash@{0}Ver el diff de un bloque guardado
git stash popRecuperar el último bloque y quitarlo de la lista
git stash apply stash@{1}Recuperar un bloque dejándolo en la lista
git stash drop stash@{1}Borrar un bloque
git stash branch fix-formCrear una rama desde el commit donde se hizo el stash y aplicarlo

Etiquetas y releases

ComandoQué hace
git tagLista de etiquetas
git tag -a v1.2.0 -m "Release 1.2.0"Etiqueta anotada con autor, fecha y mensaje
git tag v1.2.0 a1b2c3dEtiqueta ligera sobre un commit concreto
git push origin v1.2.0Enviar una etiqueta
git tag -d v1.2.0Borrar una etiqueta en local
git push origin --delete v1.2.0Borrar una etiqueta en el servidor
git describe --tagsLa etiqueta más cercana y el número de commits tras ella, por ejemplo v1.2.0-3-ga1b2c3d

Comandos avanzados de Git

ComandoQué hace
git bisect start, git bisect bad, git bisect good v1.1.0Búsqueda binaria del commit que introdujo un error; al final, git bisect reset
git worktree add ../hotfix mainUna segunda carpeta de trabajo con otra rama del mismo repositorio
git submodule update --init --recursiveDescargar los submódulos tras clonar
git grep "TODO"Búsqueda rápida en los archivos con seguimiento
git format-patch -1 HEAD / git apply fix.patchGuardar un commit como parche y aplicar un parche al directorio de trabajo
git gcEmpaquetar objetos y limpiar el repositorio (normalmente Git lo hace solo)

Errores frecuentes y cómo arreglarlos

Hiciste commit en main en lugar de en una rama nueva

Si el commit aún no se ha subido, crea una rama en el commit actual y haz retroceder main:

git branch feature/login      # la rama apunta a tu commit
git reset --hard HEAD~1       # main retrocede un paso
git switch feature/login

Olvidaste añadir un archivo al último commit

git add forgotten.js
git commit --amend --no-edit

Push rechazado: rejected, non-fast-forward

En el servidor hay commits que tú no tienes. Primero tráelos y después envía:

git pull --rebase
git push

Subiste por error un archivo con contraseñas

Deja de seguirlo y añádelo a .gitignore: git rm --cached .env y después un commit. Si el commit ya está publicado, considera el secreto comprometido y regéneralo: sigue estando en el historial.

Conclusión

Para el trabajo diario basta con un conjunto reducido: status, add, commit, switch, merge, pull, push y log --oneline. Elige los comandos para deshacer (restore, reset, revert) según si el commit está publicado o no, y recuerda reflog como red de seguridad para casos extremos. Todos los comandos de Git de esta chuleta se practican en el curso de Git, donde pruebas cada uno en tu propio repositorio.

Preguntas frecuentes

¿Cuántos comandos de Git necesita conocer un principiante?

Para empezar bastan 10–12: init, clone, status, add, commit, log, diff, branch, switch, merge, pull y push. Los demás se aprenden a medida que surgen las tareas.

¿En qué se diferencia git switch de git checkout?

git switch solo cambia de rama y crea ramas, mientras que git checkout además restaura archivos. La separación en switch y restore se hizo para no machacar cambios por confundir una rama con un archivo.

¿Cómo ver la ayuda de cualquier comando de Git?

Ejecuta git help nombre-del-comando para el manual completo o git nombre-del-comando -h para una lista breve de opciones. La misma documentación está en git-scm.com.

¿Se pueden acortar los comandos largos de Git?

Sí, con alias: git config --global alias.lg "log --oneline --graph --all" te permitirá escribir git lg.

¿Funcionan estos comandos en Windows?

Sí, los comandos son iguales en todos los sistemas. En Windows es cómodo ejecutarlos en Git Bash, PowerShell o el terminal del editor de código.

Aprende este tema en vídeo

Este tema se explica a fondo y con práctica en el curso «Git desde cero hasta desarrollador seguro».

Ir al curso