Más de 100 comandos de Git que todo desarrollador DEBE conocer (guía 2026)

Git es la columna vertebral del control de versiones moderno. Todos los equipos con los que he trabajado, desde proyectos personales en un VPS barato hasta pipelines de CI/CD a gran escala, funcionan con Git. Esta guía cubre más de 100 comandos de Git, desde lo básico hasta flujos de trabajo avanzados, actualizada para 2026 (Git 2.55, con Git 3.0 en el horizonte).

Tanto si estás aprendiendo Git por primera vez como si buscas una chuleta para guardar en marcadores, este artículo te cubre. He organizado los comandos para que puedas saltar a cualquier sección y encontrar lo que necesitas. Si estás montando un entorno de desarrollo completo, también te interesarán los comandos esenciales de Linux y los comandos de Docker que todo desarrollador debería conocer. Combinan muy bien con Git en cualquier flujo de trabajo. Si usas herramientas de codificación con IA que se integran con Git, las secciones de worktrees y automatización te serán especialmente útiles.

Sección 1: Comandos básicos de Git

Estos son los comandos que usarás cada día. Domínalos primero.

1.1 git init

Inicializa un repositorio Git nuevo. Crea el directorio .git con todos los metadatos que Git necesita para rastrear cambios.

Ejemplo de uso:

mkdir my_project
cd my_project
git init
# Initialized empty Git repository in /path/to/my_project/.git/

Verifica: ejecuta git status. Deberías ver “On branch main” (o master, según la rama por defecto de tu configuración) sin commits todavía.

1.2 git clone

Crea una copia local de un repositorio remoto.

Ejemplo de uso:

git clone https://github.com/user/repository.git
# Cloning into 'repository'...
# remote: Enumerating objects: 10, done.
# remote: Counting objects: 100% (10/10), done.
# remote: Compressing objects: 100% (8/8), done.
# remote: Total 10 (delta 2), reused 10 (delta 2), pack-reused 0
# Unpacking objects: 100% (10/10), done.

Verifica: ls -la .git/ debería mostrar la estructura del repositorio. Para mayor seguridad, ejecuta git fsck para verificar la integridad.

Para clones superficiales y parciales (útiles en un VPS con ancho de banda limitado o en CI), consulta la Sección 3.5.

1.3 git status

Muestra el estado actual del directorio de trabajo y del área de preparación (staging).

Ejemplo de uso:

git status
# On branch main
# Your branch is up to date with 'origin/main'.
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#     newfile.txt
#
# nothing added to commit but untracked files present (use "git add" to track)

Es el comando que más ejecuto. Úsalo antes de cada commit para asegurarte de que estás preparando exactamente lo que crees.

1.4 git add

Añade el contenido de archivos al área de preparación para el próximo commit.

Ejemplo de uso:

# Prepara un solo archivo
git add newfile.txt

# Prepara todos los cambios
git add .

# Prepara de forma interactiva (elige hunks)
git add -p

Merece la pena aprender git add -p pronto. Te permite preparar partes de un archivo, lo que genera commits más limpios.

1.5 git commit

Registra los cambios preparados como un commit nuevo.

Ejemplo de uso:

git commit -m "Add newfile.txt"
# [main 1a2b3c4] Add newfile.txt
#  1 file changed, 1 insertion(+)
#  create mode 100644 newfile.txt

Modifica el último commit (antes de haber hecho push):

git commit --amend -m "Updated commit message"

1.6 git config

Configura los ajustes de Git. En Git 2.46+ (julio de 2024) hay una sintaxis más limpia basada en subcomandos:

git config set --global user.name "John Doe"
git config set --global user.email "[email protected]"
git config list
git config get user.name
git config unset user.name

git config --global user.name "John Doe"
git config --global user.email "[email protected]"
git config --list
git config --get user.name
git config --unset user.name

1.7 git grep

Busca un patrón en los archivos rastreados. Más rápido que grep -r porque opera sobre el índice de Git.

Ejemplo de uso:

# Busca "TODO" en todos los archivos rastreados
git grep "TODO"

# Busca con números de línea
git grep -n "function_name"

# Busca en un commit concreto
git grep "pattern" HEAD~3

# Búsqueda sin distinguir mayúsculas
git grep -i "error"

1.8 git rm

Elimina archivos del directorio de trabajo y del área de preparación.

Ejemplo de uso:

# Elimina un archivo rastreado
git rm oldfile.txt

# Deja de rastrearlo pero conserva el archivo en disco
git rm --cached secret.env

La flag --cached es útil cuando hiciste commit por accidente de un archivo que debería estar en .gitignore.

1.9 git mv

Mueve o renombra un archivo rastreado.

Ejemplo de uso:

git mv old_name.txt new_name.txt

Equivale a mv old_name.txt new_name.txt && git add new_name.txt && git rm old_name.txt, pero más limpio.

Sección 2: Ramas y fusiones

Las ramas te permiten trabajar en funcionalidades, correcciones y experimentos de forma aislada. Esta sección usa el moderno git switch como comando principal. Si todavía usas git checkout para todo, lee la nota sobre la sintaxis heredada en 2.3.

2.1 git branch

Lista, crea y elimina ramas.

Ejemplo de uso:

# Lista las ramas locales
git branch
# * main
#   feature-branch

# Lista todas las ramas (incluidas las remotas)
git branch -a

# Crea una rama nueva
git branch new-feature

# Fuerza el borrado de una rama sin fusionar
git branch -D experimental

2.2 git switch

La forma moderna de cambiar entre ramas y de crearlas. Introducido en Git 2.23 (agosto de 2019).

Ejemplo de uso:

# Cambia a una rama existente
git switch main

# Crea una rama nueva y cambia a ella
git switch -c new-feature

# Cambia a la rama anterior
git switch -

# Crea una rama desde un commit concreto
git switch -c hotfix abc1234

2.3 git checkout (heredado)

Sigue funcionando, pero git switch (ramas) y git restore (archivos) son los reemplazos recomendados desde Git 2.23.

# Heredado: cambiar de rama (usa git switch)
git checkout new-feature

# Heredado: crear y cambiar (usa git switch -c)
git checkout -b new-feature

# Heredado: restaurar archivo (usa git restore)
git checkout -- file.txt

2.4 git merge

Combina los cambios de una rama en la rama actual.

Ejemplo de uso:

# Fusiona una rama en la rama actual
git merge feature-branch

# Fusión con un merge commit explícito (aunque sea posible fast-forward)
git merge --no-ff feature-branch -m "Merge feature-branch"

# Aborta una fusión con conflictos
git merge --abort

Verifica: git log --oneline --graph -10 para ver la fusión en la topología de commits.

Modo de fallo (conflictos de fusión): cuando Git no puede fusionar automáticamente, marca los conflictos en los archivos. Edita los archivos en conflicto, luego haz git add y git commit. O git merge --abort para deshacerlo por completo.

2.5 git rebase

Reaplica commits sobre otra base. Crea un historial lineal (sin merge commits).

Ejemplo de uso:

# Rebase de la rama actual sobre main
git rebase main

# Rebase interactivo (squash, reordenar, editar commits)
git rebase -i HEAD~5

# Aborta un rebase
git rebase --abort

# Continúa tras resolver los conflictos
git rebase --continue

2.6 git worktree

Te permite desplegar varias ramas simultáneamente en directorios separados, todos vinculados al mismo repositorio. Sin stash ni segundos clones.

Ejemplo de uso:

# Crea un worktree de main en ../hotfix
git worktree add ../hotfix main

# Crea un worktree con una rama nueva
git worktree add -b hotfix-123 ../hotfix-123 main

# Lista todos los worktrees
git worktree list
# /home/user/project          abc1234 [main]
# /home/user/hotfix           def5678 [main]

# Elimina un worktree
git worktree remove ../hotfix

# Limpia metadatos de worktrees obsoletos
git worktree prune

Modo de fallo (detached HEAD): hacer git switch a un hash de commit concreto (no a un nombre de rama) te deja en estado detached HEAD. Tu trabajo no está en ninguna rama. Arréglalo con:

git switch -c new-branch-name

Esto guarda tu trabajo en una rama de verdad.

Sección 3: Comandos de repositorios remotos

Trabajar con repositorios remotos: GitHub, GitLab, Gitea, Forgejo o cualquier servidor Git. Si haces push por SSH, asegúrate primero de tener configurada tu clave SSH para GitHub.

3.1 git remote

Gestiona las conexiones con repositorios remotos.

Ejemplo de uso:

# Lista los remotos
git remote
# origin

# Lista los remotos con sus URL
git remote -v
# origin  https://github.com/user/repo.git (fetch)
# origin  https://github.com/user/repo.git (push)

# Añade un remoto
git remote add upstream https://github.com/original/repo.git

# Elimina un remoto
git remote remove upstream

# Cambia la URL de un remoto
git remote set-url origin [email protected]:user/repo.git

# Poda las ramas de seguimiento remoto obsoletas
git remote prune origin

3.2 git fetch

Descarga objetos y refs de un repositorio remoto sin fusionar.

Ejemplo de uso:

# Fetch desde origin
git fetch

# Fetch desde un remoto concreto
git fetch upstream

# Fetch y poda las ramas remotas borradas
git fetch --prune

# Fetch de una rama concreta
git fetch origin feature-branch

Uso git fetch --prune por costumbre. Limpia las ramas de seguimiento remoto que se han borrado en el servidor.

3.3 git pull

Descarga y fusiona los cambios de una rama remota. Equivale a git fetch seguido de git merge.

Ejemplo de uso:

# Pull con fusión
git pull

# Pull con rebase en lugar de merge (historial más limpio)
git pull --rebase

# Pull desde un remoto y una rama concretos
git pull upstream main

3.4 git push

Sube los commits locales a un repositorio remoto.

Ejemplo de uso:

# Push de la rama actual a origin
git push

# Push y establece el seguimiento upstream
git push -u origin new-feature

# Borra una rama remota
git push --delete origin old-branch

3.5 git push –force-with-lease (push forzado seguro)

Ejemplo de uso:

# Push forzado seguro (comprueba primero el estado remoto)
git push --force-with-lease origin main

# Aún más seguro (también comprueba el reflog local)
git push --force-with-lease --force-if-includes origin main

--force-with-lease me ha salvado más de una vez. Es la diferencia entre «reescribí el historial de forma segura» y «acabo de destruir el trabajo de mi compañero».

3.6 Clones superficiales y parciales

Cuando estás en un VPS con ancho de banda medido, ejecutas CI o trabajas con un repo enorme, los clones completos desperdician ancho de banda y disco. Estas flags ayudan.

Ejemplo de uso:

# Clone superficial: solo el último commit (ideal para CI)
git clone --depth 1 https://github.com/user/large-repo.git

# Clone parcial: descarga los blobs bajo demanda (ahorra disco)
git clone --filter=blob:none https://github.com/user/large-repo.git

# Convierte un clone superficial en historial completo más adelante
git fetch --unshallow

Sección 4: Ver el historial y comparar cambios

Entender qué pasó y cuándo. Estos comandos son tu máquina del tiempo.

4.1 git log

Muestra el historial de commits. La salida por defecto es verbosa: aprende las flags que importan.

Ejemplo de uso:

# Log básico
git log

# Formato de una línea (mi uso diario)
git log --oneline

# Grafo visual de ramas
git log --graph --oneline --all

# Limita la salida
git log -10

# Muestra los archivos cambiados por commit
git log --stat

# Busca commits que introdujeron/eliminaron una cadena (pickaxe)
git log -S"buggy_function"

# Traza el historial de una función concreta
git log -L :function_name:file.c

# Muestra commits desde una fecha
git log --since="2026-01-01"

# Muestra commits por autor
git log --author="Dragos"

# Limita el ancho del grafo (Git 2.55+)
git log --graph --oneline --all --graph-lane-limit=5

4.2 git diff

Muestra los cambios entre commits, ramas o el directorio de trabajo.

Ejemplo de uso:

# Cambios aún no preparados
git diff

# Cambios preparados para el commit
git diff --cached

# Diff entre dos ramas
git diff main..feature-branch

# Resumen de cambios (archivos y recuento de líneas)
git diff --stat

# Diff de un archivo concreto
git diff HEAD -- file.txt

4.3 git show

Muestra los detalles de un commit concreto (diff, mensaje, autor).

Ejemplo de uso:

# Muestra el último commit
git show

# Muestra un commit concreto
git show abc1234

# Muestra solo los archivos cambiados
git show --stat abc1234

4.4 git blame

Muestra quién modificó por última vez cada línea de un archivo y cuándo.

Ejemplo de uso:

# Blame de un archivo
git blame file.txt

# Blame de un rango de líneas concreto
git blame -L 10,20 file.txt

# Usa un algoritmo de diff distinto (Git 2.54+)
git blame --diff-algorithm=patience file.txt

4.5 git shortlog

Resume la salida de git log por autor. Útil para ver la actividad de los colaboradores.

Ejemplo de uso:

# Resumen por autor
git shortlog -sn

# Resumen desde una fecha
git shortlog -sn --since="2026-01-01"

4.6 git describe

Genera un identificador legible a partir de la etiqueta más cercana.

Ejemplo de uso:

git describe --tags
# v1.2.3-14-gabc1234
# (14 commits después de la etiqueta v1.2.3, commit que empieza por abc1234)

Úsalo en scripts de compilación para el versionado: la salida es siempre única y te dice exactamente a qué distancia estás de la última release.

4.7 git range-diff

Compara dos versiones de un rango de commits. El caso de uso principal: verificar que un rebase no ha perdido ni alterado nada.

Ejemplo de uso:

# Compara la versión antigua y la nueva de una rama tras un rebase
git range-diff origin/main..old-branch origin/main..new-branch

Verifica tras el rebase: ejecuta git range-diff después de rebasar para confirmar que el diff de cada commit es el mismo (o intencionadamente distinto). Si faltan commits o sus diffs cambiaron inesperadamente, algo salió mal.

Sección 5: Deshacer cambios y corregir errores

Todo el mundo comete errores. Estos comandos son tu red de seguridad.

5.1 git reset

Mueve HEAD y opcionalmente modifica el área de preparación y el directorio de trabajo.

Ejemplo de uso:

# Reset soft: mantiene los cambios preparados
git reset --soft HEAD~1

# Reset mixto (por defecto): mantiene los cambios sin preparar
git reset HEAD~1

# Reset hard: descarta todo desde ese commit
git reset --hard HEAD~1

# Consulta el reflog (tu red de seguridad)
git reflog
# abc1234 HEAD@{0}: reset: moving to HEAD~3
# def5678 HEAD@{1}: commit: Important work here

# Restaura al commit anterior al reset
git reset --hard HEAD@{1}
# o
git reset --hard def5678

5.2 git restore

La forma moderna de descartar cambios del directorio de trabajo o sacar archivos del staging. Sustituye a git checkout -- <file>.

Ejemplo de uso:

# Descarta los cambios de un archivo (restaura al último estado confirmado)
git restore file.txt

# Saca un archivo del área de preparación
git restore --staged file.txt

# Restaura un archivo desde un commit concreto
git restore --source=HEAD~2 file.txt

# Restaura todos los archivos del directorio de trabajo
git restore .

5.3 git revert

Crea un commit nuevo que deshace un commit concreto. A diferencia de reset, no reescribe el historial.

Ejemplo de uso:

# Revierte un commit concreto
git revert abc1234

# Revierte sin hacer commit (deja la reversión preparada)
git revert --no-commit abc1234

Usa git revert en ramas compartidas donde no puedes reescribir el historial. Usa git reset en ramas solo locales.

5.4 git clean

Elimina los archivos no rastreados del directorio de trabajo.

Ejemplo de uso:

# Simulacro: muestra qué se borraría
git clean -n

# Elimina archivos no rastreados
git clean -f

# Elimina archivos y directorios no rastreados
git clean -fd

# Incluye también los archivos ignorados
git clean -fdx

Ejecuta siempre primero con -n para previsualizar. git clean no tiene deshacer.

5.5 git stash

Aparta temporalmente los cambios para que puedas cambiar de rama o trabajar en otra cosa.

Ejemplo de uso:

# Guarda los cambios actuales en el stash
git stash

# Stash con un mensaje descriptivo
git stash push -m "WIP: login feature"

# Lista todos los stashes
git stash list
# stash@{0}: On main: WIP: login feature
# stash@{1}: On main: experimental changes

# Aplica el stash más reciente (lo mantiene en la lista)
git stash apply

# Aplica y elimina el stash más reciente
git stash pop

# Aplica un stash concreto
git stash apply stash@{1}

# Crea una rama desde un stash
git stash branch new-feature-branch stash@{0}

# Elimina un stash concreto
git stash drop stash@{0}

# Elimina todos los stashes
git stash clear

# Muestra el contenido de un stash
git stash show -p stash@{0}

5.6 git cherry-pick

Aplica un commit concreto de una rama a la rama actual.

Ejemplo de uso:

# Cherry-pick de un solo commit
git cherry-pick abc1234

# Cherry-pick sin hacer commit
git cherry-pick --no-commit abc1234

# Cherry-pick de un rango de commits
git cherry-pick abc1234..def5678

Sección 6: Comandos avanzados de Git

Depuración, automatización y flujos de trabajo de usuario avanzado.

6.1 git bisect

Usa búsqueda binaria para encontrar el commit que introdujo un bug.

Bisect manual:

git bisect start
git bisect bad          # el commit actual está roto
git bisect good v1.0    # esta etiqueta/commit funcionaba

# Git despliega un commit intermedio. Pruébalo y luego:
git bisect good         # este commit funciona
# o
git bisect bad          # este commit está roto

# Git va acotando hasta encontrar el commit malo
# Al terminar:
git bisect reset

Bisect automatizado con un script:

git bisect start HEAD v1.0
git bisect run ./test-script.sh

El script de prueba debe salir con 0 para «bueno» y con un valor distinto de cero para «malo». Git desplegará commits automáticamente y ejecutará el script hasta encontrar el primer commit malo. Este es el verdadero poder de bisect: deja que el ordenador haga el trabajo.

6.2 git tag

Crea referencias con nombre a commits concretos (normalmente para releases).

Ejemplo de uso:

# Etiqueta ligera
git tag v1.0.0

# Etiqueta anotada (recomendado: incluye metadatos)
git tag -a v1.0.0 -m "Release 1.0.0"

# Etiqueta un commit concreto
git tag -a v1.0.0 abc1234

# Lista etiquetas
git tag

# Lista etiquetas con mensajes
git tag -n

# Sube las etiquetas al remoto
git push origin v1.0.0

# Sube todas las etiquetas
git push origin --tags

6.3 git submodule

Gestiona repositorios externos incrustados en tu repositorio.

Ejemplo de uso:

# Añade un submódulo
git submodule add https://github.com/user/library.git libs/library

# Inicializa los submódulos tras clonar
git submodule init
git submodule update

# O combina ambos
git submodule update --init --recursive

# Actualiza los submódulos a los últimos commits remotos
git submodule update --remote

6.4 git archive

Crea un archivo tar o zip del repositorio en un punto concreto.

Ejemplo de uso:

# Crea un tar de HEAD
git archive --format=tar HEAD > project.tar

# Crea un zip de una etiqueta concreta
git archive --format=zip v1.0.0 > project-v1.0.0.zip

# Archiva solo rutas concretas
git archive --format=tar HEAD src/ > src-only.tar

6.5 git reflog

Muestra un registro de dónde ha estado HEAD. Tu red de seguridad para operaciones de recuperación.

Ejemplo de uso:

# Consulta el reflog
git reflog
# abc1234 HEAD@{0}: commit: Latest change
# def5678 HEAD@{1}: reset: moving to HEAD~1
# ghi9012 HEAD@{2}: commit: Important work

# Resetea a una entrada del reflog
git reset --hard HEAD@{2}

6.6 git notes

Adjunta metadatos a los commits sin reescribir el historial. Piensa en ello como comentarios sobre commits.

Ejemplo de uso:

# Añade una nota a un commit
git notes add -m "Reviewed-by: Jane" abc1234

# Muestra las notas de un commit
git notes show abc1234

# Lista todas las notas
git notes list

# Sube las notas al remoto (no se suben por defecto)
git push origin refs/notes/commits

Casos de uso: adjuntar resultados de CI, metadatos de code review o información de cobertura de tests a commits concretos.

6.7 git commit –fixup y –autosquash

Limpia el historial de commits antes de fusionar.

Ejemplo de uso:

# Crea un commit fixup dirigido a un commit concreto
git commit --fixup=abc1234

# Rebase interactivo que aplasta automáticamente los commits fixup
git rebase -i --autosquash main

Este es mi flujo preferido para pull requests: hago commits fixup según los revisores piden cambios y luego los aplasto en el lugar correcto antes de fusionar.

6.8 git bundle

Crea un archivo portable del repositorio que se puede clonar. Útil para entornos sin conexión (air-gapped), transferencias offline o copias de seguridad.

Ejemplo de uso:

# Crea un bundle con todas las ramas
git bundle create repo.bundle --all

# Crea un bundle con ramas concretas
git bundle create repo.bundle main feature-branch

# Clona desde un bundle
git clone repo.bundle new-repo

# Verifica que un bundle es válido
git bundle verify repo.bundle

6.9 git am

Aplica parches desde un mailbox (flujos basados en email). Todavía lo usan el kernel de Linux y otros proyectos con revisión de código por email.

Ejemplo de uso:

# Aplica un archivo de parche
git am < patch-file.patch

# Aplica una serie de parches desde un directorio
git am patches/*.patch

# Aborta si algo va mal
git am --abort

# Aplica con merge de 3 vías (resuelve más casos)
git am --3way < patch-file.patch

Sección 7: Colaboración y flujos de trabajo con parches

Trabajar con parches, envíos por email y revisión de código.

7.1 git cherry

Encuentra commits que no se han aplicado en upstream.

Ejemplo de uso:

# Muestra los commits de la rama actual que no están en upstream
git cherry upstream/main

# Salida detallada con mensajes de commit
git cherry -v upstream/main

7.2 git apply

Aplica un parche creado por git diff o git format-patch.

Ejemplo de uso:

# Verifica un parche sin aplicarlo
git apply --check changes.patch

# Aplica un parche
git apply changes.patch

# Aplica en reverso (deshace un parche)
git apply -R changes.patch

Ejecuta siempre git apply --check primero para verificar que el parche se aplica limpiamente.

7.3 git format-patch

Crea archivos de parche a partir de commits. Cada commit se convierte en un archivo .patch separado con el mensaje del commit.

Ejemplo de uso:

# Crea parches de los últimos 3 commits
git format-patch -3

# Crea parches de un rango
git format-patch main..feature-branch

# Crea los parches en un directorio
git format-patch -3 -o patches/

7.4 git send-email

Envía archivos de parche por email. Se usa en proyectos con revisión de código por email (el kernel de Linux, el propio Git).

Ejemplo de uso:

# Envía una serie de parches
git send-email patches/*.patch

# Envía a un destinatario concreto
git send-email [email protected] patches/*.patch

7.5 git request-pull

Genera un mensaje de pull request para flujos basados en email.

Ejemplo de uso:

git request-pull v1.0 https://github.com/user/repo.git main

Sección 8: Mantenimiento y rendimiento del repositorio

Mantén tus repositorios rápidos y sanos. Especialmente importante si alojas repos en un VPS con disco e I/O limitados.

8.1 git gc

Recolección de basura: limpia archivos innecesarios y optimiza el repositorio.

Ejemplo de uso:

# Recolección de basura estándar
git gc

# Agresiva (más lenta pero más exhaustiva: úsala ocasionalmente)
git gc --aggressive

# Auto-gc con umbrales más altos (empaquetado menos frecuente)
git gc --auto

Verifica: ejecuta git log -1 después del gc para confirmar que el repo sigue funcionando.

8.2 git fsck

Verifica la integridad de la base de datos del repositorio.

Ejemplo de uso:

# Comprueba objetos corruptos
git fsck

# Comprueba e informa de objetos sueltos (dangling)
git fsck --dangling

Ejecuta git fsck tras un clon sospechoso o cuando sospeches corrupción. Si informa de errores, vuelve a clonar desde una fuente fiable.

8.3 git maintenance

Programa tareas en segundo plano para mantener los repositorios rápidos. Introducido en Git 2.30.

Ejemplo de uso:

# Activa el mantenimiento en segundo plano (programa vía cron/systemd)
git maintenance start

# Ejecuta las tareas de mantenimiento manualmente
git maintenance run

# Desactiva el mantenimiento en segundo plano
git maintenance stop

# Ejecuta una tarea concreta
git maintenance run --task=commit-graph

8.4 git rerere

«Reuse recorded resolution»: recuerda cómo resolviste un conflicto y aplica la misma resolución automáticamente la próxima vez.

Ejemplo de uso:

# Activa rerere
git config set rerere.enabled true

# Una vez activado, Git registra automáticamente las resoluciones
# de conflictos y las reaplica durante rebases o merges

Si haces rebase con frecuencia o mantienes ramas longevas, rerere ahorra mucho tiempo.

8.5 git count-objects

Muestra el uso de disco de la base de datos de objetos de Git.

Ejemplo de uso:

# Recuento básico
git count-objects

# Legible con detalles
git count-objects -vH
# count: 0
# size: 0 bytes
# in-pack: 1523
# packs: 1
# size-pack: 2.34 MiB
# garbage: 0
# size-garbage: 0 bytes

Útil para vigilar el tamaño del repo en instancias VPS con disco limitado.

8.6 git prune

Elimina los objetos inalcanzables de la base de datos. Normalmente lo gestiona git gc, pero es útil para limpieza manual.

Ejemplo de uso:

# Simulacro
git prune -n

# Poda los objetos inalcanzables
git prune

Sección 9: Comandos para scripting y automatización

Comandos que usarás en pipelines de CI/CD, scripts de compilación y automatización. Si escribes scripts de despliegue o integras Git en tu pipeline de CI, son esenciales.

9.1 git rev-parse

Analiza especificaciones de revisión. El recurso principal para extraer información en scripts de shell.

Ejemplo de uso:

# Obtiene el hash completo del commit
git rev-parse HEAD
# a1b2c3d4e5f6...

# Obtiene el hash corto
git rev-parse --short HEAD
# a1b2c3d

# Obtiene el nombre de la rama actual
git rev-parse --abbrev-ref HEAD
# main

# Obtiene el directorio raíz del repositorio
git rev-parse --show-toplevel
# /home/user/project

9.2 git rev-list

Lista objetos commit en orden cronológico inverso.

Ejemplo de uso:

# Cuenta el total de commits
git rev-list --count HEAD

# Cuenta commits desde una fecha
git rev-list --since="2026-01-01" --count HEAD

# Lista los commits entre dos refs
git rev-list main..feature-branch

9.3 git ls-files / git ls-tree / git cat-file

Comandos de inspección de bajo nivel.

# Lista los archivos del índice (área de preparación)
git ls-files

# Lista el contenido del árbol en un commit
git ls-tree HEAD

# Muestra el tipo y el contenido de un objeto
git cat-file -t HEAD    # "commit"
git cat-file -p HEAD    # detalles del commit

# Muestra el contenido de un blob
git cat-file -p HEAD:file.txt

9.4 Fragmentos para CI/CD

# Obtiene los archivos cambiados en el último commit (para jobs de CI selectivos)
git diff --name-only HEAD~1

# Genera una cadena de versión desde las etiquetas
git describe --tags --always

# Lista los commits entre despliegues (para notas de release)
git log --oneline <previous-deploy-ref>..<new-deploy-ref>

# Crea un artefacto de despliegue
git archive --format=tar HEAD | gzip > deploy.tar.gz

# Obtiene el número de commits desde la última etiqueta (para números de build)
git rev-list $(git describe --tags --abbrev=0)..HEAD --count

# Clon rápido para CI
git clone --depth 1 --branch main https://github.com/user/repo.git

# Verifica la integridad del repo en CI
git fsck --no-dangling

Sección 10: Git moderno: switch, restore, worktrees y más

Esta sección consolida las funcionalidades modernas de Git que han madurado desde 2019. Si todavía usas flujos de Git como si fuera 2015, empieza aquí.

10.1 git sparse-checkout

Trabaja con un subconjunto de un repositorio grande. Esencial para monorepos.

Ejemplo de uso:

# Clona con sparse checkout
git clone --filter=blob:none --sparse https://github.com/large/repo.git
cd repo

# Define qué directorios quieres
git sparse-checkout set src/frontend docs/

# Añade más directorios después
git sparse-checkout add src/shared/

# Lista las rutas sparse-checkout actuales
git sparse-checkout list

# Desactiva sparse-checkout (obtén todo)
git sparse-checkout disable

Combinado con el clone parcial (--filter=blob:none), solo descargas los archivos que necesitas. Genial para monorepos en los que solo trabajas en un servicio.

10.2 Firma de commits con SSH

La firma con GPG ha sido la forma tradicional de firmar commits, pero la firma con SSH es mucho más sencilla de configurar y está soportada por GitHub, GitLab y Gitea.

# Configura Git para usar la firma SSH
git config set gpg.format ssh

# Define tu clave de firma (tu clave pública SSH)
git config set user.signingkey ~/.ssh/id_ed25519.pub

# Firma un commit
git commit -S -m "Signed commit"

# Firma todos los commits por defecto
git config set commit.gpgsign true

# Registra tu clave SSH como clave de firma en GitHub/GitLab
# GitHub: Settings → SSH and GPG keys → New SSH key (select "Signing key")

# Genera una clave GPG
gpg --full-generate-key

# Configura Git para usar la clave GPG
git config set user.signingkey YOUR_GPG_KEY_ID

# Firma un commit
git commit -S -m "Signed commit"

# Exporta la clave pública para GitHub/GitLab
gpg --armor --export YOUR_GPG_KEY_ID

La firma con SSH es más sencilla: ya tienes las claves, no hay gestión de claves más allá de la que usas para push/pull y no hay un agente GPG que configurar. Si empiezas de cero, usa SSH.

10.3 El comando git history (Git 2.54+)

Nuevo en Git 2.54, el comando git history simplifica los flujos de rebase interactivo.

# Reescribe el mensaje de un commit (sustituye al rebase interactivo en ediciones simples)
git history reword HEAD~3

# Divide un commit en varios commits
git history split HEAD~2

# Crea un commit fixup y prepáralo para autosquash
git history fixup HEAD~5

10.4 Hooks basados en config (Git 2.54+)

Los hooks ahora se pueden configurar vía git config en lugar de colocar scripts en .git/hooks/. Esto facilita compartir hooks en un equipo.

# Define un hook vía config
git config set core.hooksPath .githooks

Coloca tus scripts de hook en .githooks/ y haz commit de ese directorio. Todo el que clone el repo recibe los hooks automáticamente.

10.5 git stash export/import

Transfiere stashes entre repositorios o máquinas.

# Exporta el stash a un archivo
git stash export > stash.bundle

# Impórtalo en otro repo
git stash import < stash.bundle

Sección 11: Git 3.0: lo que viene

Git 3.0 apunta a finales de 2026. Esto es lo que necesitas saber para prepararte.

11.1 SHA-256 como algoritmo de hash por defecto

Git ha usado SHA-1 desde su creación, pero SHA-1 tiene ataques de colisión conocidos (el ataque SHAttered de 2017 lo hizo práctico). Git 3.0 hará de SHA-256 el valor por defecto para repositorios nuevos.

Qué cambia:

• La longitud del hash pasa de 40 caracteres hexadecimales a 64
• Los repos nuevos creados con Git 2.51+ ya usan SHA-256 por defecto
• Los repos SHA-1 existentes siguen funcionando (no hay migración forzada)

El problema: GitHub, GitLab y otras forjas aún no soportan repositorios SHA-256. El ecosistema necesita ponerse al día antes de que SHA-256 sea práctico para la mayoría de equipos.

11.2 Backend de referencias reftable

Reftable es un formato nuevo para almacenar las referencias de Git (ramas, etiquetas). Ya está disponible:

# Crea un repo con backend reftable
git init --ref-format=reftable

Por qué importa:

• Hasta 22x más rápido en fetch y 18x más rápido en push en repos con más de 10.000 referencias
• Actualizaciones de referencias atómicas (adiós a escrituras parciales tras un fallo)
• Sin conflictos de nombres de rama a nivel de sistema de archivos (sistemas de archivos que no distinguen mayúsculas)
• Menor huella de disco para el almacenamiento de referencias

Para repos con muchas ramas (monorepos, equipos grandes), reftable es una mejora significativa. Si autoalojas Git con Forgejo, comprueba el estado de su soporte de reftable.

11.3 Rust como requisito de compilación

Git 3.0 requerirá Rust como dependencia de compilación. Esto permite implementaciones memory-safe de las rutas de código críticas para el rendimiento. La integración del sistema de compilación Meson continúa.

Impacto: la mayoría de usuarios no lo notarán: instalan Git desde gestores de paquetes. Pero compilar Git desde el código fuente en plataformas sin toolchains de Rust requerirá un paso extra.

11.4 Cambios que rompen compatibilidad

• git-whatchanged eliminado. Usa git log --raw en su lugar (misma salida, más flags).
• git switch y git restore dejan de ser experimentales. Git 3.0 los recomendará encarecidamente frente a git checkout. Empieza a migrar ya.
• Varias opciones obsoletas eliminadas. Consulta BreakingChanges.txt en el código fuente de Git para la lista completa.

Sección 12: Fundamentos de seguridad

La seguridad de Git importa a todo equipo. Estos comandos y configuraciones ayudan a proteger tu repositorio.

12.1 Verificación de objetos en fetch/push

Detecta objetos corruptos o maliciosos durante la transferencia.

# Activa la verificación de objetos para todos los fetch/push
git config set transfer.fsckObjects true

Con esto activado, Git verifica la integridad de cada objeto recibido de un remoto. Actívalo globalmente o por repositorio.

12.2 Verificación de commits y etiquetas

Verifica que los commits y las etiquetas están firmados por claves de confianza.

# Verifica la firma de un commit
git verify-commit abc1234

# Verifica la firma de una etiqueta
git verify-tag v1.0.0

12.3 Mantén Git actualizado

Vulnerabilidades de seguridad recientes que deberías conocer:

# Comprueba tu versión de Git
git --version

# Actualiza en Ubuntu/Debian
sudo apt update && sudo apt install git

# Actualiza en macOS
brew upgrade git

# Actualiza en Fedora/RHEL
sudo dnf update git

Sección 13: Tabla de referencia rápida

Guarda esta sección en marcadores. Todos los comandos listados aquí funcionan en Git 2.50+. Los comandos marcados con ★ merecen especialmente la pena.

Son más de 100 comandos que cubren cada flujo de trabajo, desde operaciones básicas hasta automatización avanzada.

Conclusión

Git es una de esas herramientas en las que conocer bien 15 comandos te saca del paso el 90% del día, pero conocer más de 100 te da opciones cuando las cosas se tuercen o cuando necesitas automatizar algo.

Si estás montando tu entorno de desarrollo, estas guías complementarias merecen un marcador:

• Comandos esenciales de Linux: fundamentos de la línea de comandos
• Comandos de Docker: gestión de contenedores
• GitHub Copilot para escribir comandos de Git: flujo asistido por IA