Referencia de Comandos Git

Manual completo de comandos Git, organizado por categorías para búsqueda rápida

Todos: 65 个命令

Comandos Básicos(13)

git init

Crear nuevo repositorio Git en directorio actual

git clone <url>

Clonar repositorio remoto a local

git clone --depth=1 <url>

Clonación superficial, solo último commit

git add <file>

Agregar archivo al área de staging

git add .

Agregar todos los cambios al staging

git commit -m "message"

Confirmar cambios en staging

git commit --amend

Modificar el último commit

git status

Mostrar estado actual del repositorio

git diff

Mostrar cambios sin staging

git diff --staged

Mostrar cambios en staging

git config --list

Mostrar toda la configuración

git config --global user.name "name"

Configurar nombre global

git config --global user.email "email"

Configurar email global

Gestión de Ramas(14)

git branch

Listar todas las ramas locales

git branch -a

Listar todas las ramas (incluyendo remotas)

git branch <name>

Crear nueva rama

git branch -d <name>

Eliminar rama

git branch -m <old> <new>

Renombrar rama

git checkout <branch>

Cambiar a una rama

git checkout -b <branch>

Crear y cambiar a nueva rama

git switch <branch>

Cambiar a una rama (Git 2.23+)

git switch -c <branch>

Crear y cambiar a nueva rama (Git 2.23+)

git merge <branch>

Fusionar rama especificada con actual

git merge --no-ff <branch>

Fusionar con commit de fusión

git rebase <branch>

Rebase rama actual sobre rama especificada

git rebase --continue

Continuar rebase después de resolver conflictos

git cherry-pick <commit>

Aplicar commit específico a rama actual

Operaciones Remotas(10)

git remote -v

Mostrar detalles de repositorios remotos

git remote add <name> <url>

Agregar repositorio remoto

git fetch <remote>

Obtener último contenido del remoto

git fetch --all

Obtener actualizaciones de todos los remotos

git pull <remote> <branch>

Obtener y fusionar rama remota

git pull --rebase

Obtener y rebase

git push <remote> <branch>

Enviar a repositorio remoto

git push -f

Forzar push (usar con precaución)

git push -u origin <branch>

Push y establecer rama upstream

git push origin --delete <branch>

Eliminar rama remota

Deshacer Cambios(8)

git reset <file>

Quitar archivo del staging

git reset --soft HEAD~1

Deshacer último commit, mantener cambios

git reset --mixed HEAD~1

Deshacer commit y staging, mantener directorio

git reset --hard HEAD~1

Deshacer commit y descartar todos los cambios

git revert <commit>

Deshacer commit (crea nuevo commit)

git restore <file>

Restaurar archivo del directorio (Git 2.23+)

git restore --staged <file>

Quitar archivo del staging (Git 2.23+)

git clean -fd

Eliminar archivos y directorios no trackeados

Gestión de Etiquetas(6)

git tag

Listar todas las etiquetas

git tag <name>

Crear etiqueta ligera

git tag -a <name> -m "msg"

Crear etiqueta anotada

git tag -d <name>

Eliminar etiqueta local

git push origin <tag>

Enviar etiqueta al remoto

git push --tags

Enviar todas las etiquetas al remoto

Ver Historia(7)

git log

Mostrar historial de commits

git log --oneline

Mostrar historial compacto

git log --oneline --graph --all

Mostrar historial de todas las ramas como gráfico

git show <commit>

Mostrar detalles del commit

git blame <file>

Mostrar historial de modificación por línea

git reflog

Mostrar todo historial de operaciones

git bisect start

Iniciar búsqueda binaria del commit problemático

Stash(7)

git stash

Guardar cambios actuales

git stash save "message"

Guardar cambios con mensaje

git stash list

Listar todos los stash

git stash pop

Aplicar y eliminar último stash

git stash apply

Aplicar stash sin eliminar

git stash drop

Eliminar último stash

git stash clear

Eliminar todos los stash

¿Qué es Git?

Una chuleta de Git es una referencia rápida de comandos de control de versiones, organizada según la tarea que quieres realizar. Git es un sistema distribuido: cada clon contiene el historial del proyecto, las ramas son punteros ligeros y los commits registran cómo cambia una base de código con el tiempo. La chuleta ayuda cuando recuerdas el flujo de trabajo pero no la sintaxis exacta, por ejemplo ver cambios en staging, crear una rama, deshacer un commit, guardar trabajo con stash, etiquetar una versión o sincronizar con un remoto. Es una referencia, no un sustituto de entender el estado del repositorio. Comandos destructivos como reset --hard, clean -fd, rebase o push forzado deben copiarse solo tras revisar cambios sin commit, rama actual e impacto remoto.

Guía de uso

Referencia rápida

Haz clic en una tarjeta de comando para copiarla
Usa la búsqueda para encontrar rápidamente comandos específicos
Haz clic en las etiquetas de categoría para filtrar por tipo
Pasa el cursor sobre los comandos para ver descripciones detalladas

Características

Organizado por escenarioComandos agrupados por básicos, branch, remote, deshacer, etiquetas, historial y stash para una búsqueda fácil sin desplazarte por toda la lista.

Búsqueda y filtradoCombina la búsqueda y los botones de categoría para reducir rápidamente los resultados, perfecto cuando solo recuerdas parte del comando o la descripción.

Haz clic para copiarHaz clic en la tarjeta del comando para copiarlo, luego reemplaza nombres de branch, rutas de archivos o hashes de commit según sea necesario.

Advertencia de riesgoLos comandos de undo, reset y force push requieren confirmar el alcance del impacto para evitar eliminar cambios locales o reescribir historial compartido por accidente.

Consejos avanzados

Usa git restore --staged para sacar archivos del staging
Usa git commit --amend para modificar el último commit
Usa git stash para guardar temporalmente el progreso del trabajo
Usa git revert para deshacer commits ya enviados

Casos de uso

Encontrar la categoría de comando que necesitas en medio de una tareaBusca o filtra comandos de Git por trabajo básico, ramas, remotos, deshacer, etiquetas, historial y stash para que la sintaxis correcta sea visible sin escanear un artículo largo ni reabrir una pestaña de tutorial. Cada tarjeta ya muestra la descripción breve junto al comando, lo cual es útil cuando recuerdas el flujo de trabajo pero no los flags exactos, como necesitar --force-with-lease en lugar de --force, o querer la diferencia entre git restore y git reset.

Copiar comandos con marcadores de posición intactosUsa la copia con un clic para comandos como git checkout -b <branch>, git push -u origin <branch>, git log --oneline --graph --all o git restore --staged <file>, luego reemplaza los marcadores en tu terminal. Como la referencia vive en el navegador y no se envían datos de commit ni nombres de rama a ningún lugar, es seguro copiar junto a hashes reales, prefijos de rama internos o nombres de funciones en desarrollo que aún no se han subido.

Revisar comandos arriesgados antes de usarlosLa sección de deshacer agrupa los flujos de trabajo relacionados con reset, clean, restore y force push para que la intención destructiva sea visible de un vistazo. Antes de ejecutar git reset --hard HEAD~3 o git push --force, verifica la rama actual con git status y el estado de seguimiento remoto con git rev-parse --abbrev-ref --symbolic-full-name @{u}, ya que reescribir historial compartido no puede deshacerse por los compañeros.

Guardar fragmentos de ramas, etiquetas y stash como plantillasComandos como 'git switch -c feature/x', 'git tag -a v1.2 -m' y 'git stash push -m' se repiten entre proyectos con las convenciones de ramificación o lanzamiento del equipo. Cópialos una vez en el documento de incorporación, runbook o configuración de pre-commit hook del equipo, y revísalos cada vez que el comportamiento de Git cambie — por ejemplo, cuando un proyecto requiera --force-with-lease en lugar de --force en ramas protegidas.

Usar comandos de historial para leer el repositorio, no reescribirloEjecuta 'git log --oneline --graph --all', 'git blame -L' y 'git diff <branch>...' para entender quién cambió qué antes de abrir un rebase o revert. Leer primero es más barato que recuperarse de una reescritura de historial fallida, especialmente en monorepos donde un rebase errante entre ramas de función puede invalidar docenas de pull requests en curso.

Principio técnico

Git almacena cada estado del proyecto como un grafo de objetos con direccionamiento por contenido dentro de .git/objects, donde la dirección es un hash SHA-1 de 40 caracteres (SHA-256 es opcional desde el formato de objetos experimental de Git 2.29). Hay cuatro tipos de objetos: blob contiene los bytes crudos del archivo, tree asigna nombres a blobs y subárboles, commit apunta a un tree más commits padres y metadatos del autor, y tag es un puntero firmado a cualquiera de los anteriores. Las ramas y etiquetas bajo refs/heads/, refs/remotes/ y refs/tags/ son simplemente archivos de texto que contienen un SHA, y HEAD es una referencia simbólica que nombra la rama actual.

Los cambios locales fluyen a través de tres áreas: el directorio de trabajo, el índice (también llamado área de staging, almacenado en .git/index), y la base de datos de objetos. git add registra hashes de blob en el índice, git commit congela el índice en un nuevo objeto tree y commit, y git checkout/switch actualiza el índice y el árbol de trabajo a un commit objetivo. Las fusiones se dividen en dos categorías: fast-forward simplemente avanza el puntero de la rama cuando el objetivo es un descendiente directo, mientras que las fusiones de tres vías (estrategia recursiva u ort) calculan un ancestro común y construyen un commit de fusión con dos padres. git rebase reescribe la historia rejugando commits uno a uno sobre una nueva base, produciendo nuevos SHAs.

La sincronización remota se ejecuta sobre el protocolo inteligente HTTPS, SSH o el protocolo obsoleto git://, intercambiando archivos pack generados por compresión delta. Después de un fetch, Git almacena el snapshot bajo refs/remotes/origin/* y el reflog bajo .git/logs/ mantiene un rastro de deshacer de 90 días por defecto (gc.reflogExpire) para que incluso reset --hard o un rebase mal ejecutado puedan recuperarse antes de que la recolección de basura poda objetos inalcanzables.

Modelo de objetos: blob, tree, commit, tag — con direccionamiento por contenido mediante SHA-1 (o SHA-256 desde 2.29), almacenados sueltos bajo .git/objects/xx/ o empaquetados en .git/objects/pack/*.pack
Índice/staging: .git/index es un archivo binario que asigna ruta → hash blob + información de stat; git add lo actualiza, git commit lo congela en un tree
Refs y HEAD: refs/heads/<branch>, refs/remotes/<remote>/<branch>, refs/tags/<tag> son archivos planos que contienen un SHA; HEAD es una referencia simbólica a la rama actual
Estrategias de fusión: fast-forward cuando el objetivo es un descendiente, de lo contrario fusión recursiva/ort de tres vías usando la base de fusión; --no-ff fuerza un commit de fusión
Reescrituras con rebase: git rebase reejecuta commits sobre una nueva base produciendo nuevos SHAs, rompiendo la historia compartida si se empuja — de ahí que --force-with-lease se prefiera sobre --force
Recuperación con reflog: .git/logs/HEAD y los logs por referencia retienen movimientos de refs durante 90 días (gc.reflogExpire); git reflog más git reset restaura después de operaciones destructivas
Transporte: HTTPS inteligente, SSH o git:// negocian archivos pack mediante el protocolo upload-pack/receive-pack; los clones superficiales usan --depth para limitar el historial

Ejemplos

Crear y cambiar a una nueva rama

git checkout -b feature/login  # Crear y cambiar a una nueva rama

Deshacer cambios en el directorio de trabajo

git restore filename  # Restaurar el archivo al último estado confirmado

Ver historial de commits

git log --oneline --graph --all  # Mostrar gráficamente el historial de todas las ramas

Preguntas frecuentes

¿Cómo deshago el commit más reciente?

git reset --soft HEAD~1 deja tus cambios en stage para que puedas hacer commit otra vez; git reset --mixed HEAD~1 los deja en el árbol de trabajo pero sin stage; git reset --hard HEAD~1 los descarta. Si el commit ya está pusheado, usa git revert HEAD, que crea un nuevo commit que deshace el cambio sin reescribir la historia.

¿Cuál es la diferencia entre git pull y git fetch?

git fetch solo descarga commits del remoto a tus refs locales: nunca toca tu rama de trabajo. git pull equivale a git fetch seguido de git merge (o git rebase si --rebase está activo). Usa fetch cuando quieras inspeccionar los cambios upstream antes de integrarlos.

¿Cómo descarto cambios locales en un archivo?

git restore <file> descarta las ediciones sin commit en el árbol de trabajo; git restore --staged <file> quita el archivo del stage sin perder su contenido; git checkout HEAD -- <file> restaura la versión del último commit. Para archivos no rastreados usa git clean -f, o -fd para borrar también directorios.

¿Cuándo conviene rebase y cuándo merge?

Rebase cuando quieras una historia lineal en una rama de feature privada antes de integrarla. Merge cuando integras una rama compartida y conservar la historia real de desarrollo importa. Nunca rebases commits que ya están en una rama compartida salvo que todos estén de acuerdo: reescribe los SHA y rompe los clones de los demás.

¿Cómo veo lo que está a punto de pushearse?

git log @{u}.. muestra los commits de tu rama que no están en el upstream. git diff @{u} muestra el diff combinado. git status comparado con origin (tras un fetch) muestra cuántos commits estás por delante o por detrás.

¿Cómo recupero una rama eliminada o un commit perdido?

git reflog lista todas las posiciones por las que ha pasado HEAD; encuentra el SHA del commit perdido y ejecuta git checkout <sha> o git branch <name> <sha>. Las entradas del reflog duran unos 90 días por defecto antes de la recolección de basura, así que hazlo poco después del error.

¿Cuál es la forma más segura de enmendar un commit?

git commit --amend te permite editar el mensaje del commit más reciente o añadir archivos olvidados. Reescribe el SHA, así que hazlo solo en commits locales no pusheados. Si tienes que enmendar un commit ya pusheado, hazlo con --force-with-lease (no --force) para no pisar las actualizaciones de tus compañeros.

Herramientas relacionadas

Consulta de Códigos de Estado HTTP

Referencia gratuita de códigos de estado HTTP en línea con todos los códigos estándar. Búsqueda y filtrado por categoría, encuentra rápidamente significados de códigos 1xx a 5xx.

Referencia Tipos MIME

Herramienta gratuita de consulta de tipos MIME en línea. Encuentra rápidamente tipos MIME para extensiones de archivo. Búsqueda y filtrado por categoría, cubriendo documentos, imágenes, audio, video y más.

Consulta de Tabla ASCII

Tabla de referencia ASCII en línea con caracteres de control, caracteres imprimibles y caracteres extendidos. Búsqueda y filtrado por categoría para consulta rápida de códigos de caracteres.

Generador de Expresiones Cron

Herramienta de expresión Cron en línea gratuita para analizar y generar expresiones de programación Cron. Configuración visual, soporta sintaxis extendida de segundos y Quartz.

Herramienta de Búsqueda de Dirección IP

Herramienta gratuita de consulta de dirección IP en línea. Obtiene instantáneamente tu dirección IP pública e información de geolocalización incluyendo país, ciudad e ISP.

Editor Markdown

Editor Markdown en línea gratuito con vista previa en tiempo real, resaltado de sintaxis y exportación HTML. Soporta tablas, bloques de código, diagramas, escribe más eficientemente.