Git: El Kit de Emergencia

Muestra el estado del directorio de trabajo y del área de staging de forma concisa. La flag -s (o --short) muestra la salida en un formato abreviado y fácil de leer, indicando archivos modificados, añadidos o eliminados.

git status -s

Proporciona una salida de estado formateada para ser fácilmente parseada por scripts. Es una interfaz estable y no diseñada para lectura humana, ideal para automatización.

git status --porcelain

Incluye archivos ignorados (listados en el .gitignore) en la salida del estado, mostrándolos en la sección "Untracked files". Útil para verificar si las reglas de ignorar están funcionando como se esperaba.

git status --ignored

Muestra información adicional sobre la branch actual, como el nombre de la branch, si está por delante o por detrás de su upstream, y el hash del commit actual.

git status --branch

Muestra la cantidad de stashes que tienes actualmente. Útil para recordar si hay cambios guardados que necesitan ser aplicados o eliminados.

git status --show-stash

Proporciona una visualización completa y compacta del historial de commits. `--oneline` muestra cada commit en una línea, `--graph` dibuja un grafo ASCII del historial, `--all` incluye branches remotas y tags, y `--decorate` muestra los nombres de las branches y tags.

git log --oneline --graph --all --decorate

Muestra estadísticas de cada commit, indicando qué archivos fueron modificados y el número de líneas añadidas/eliminadas. Útil para tener una visión rápida del impacto de cada commit.

git log --stat

Muestra el diff completo (patch) para cada commit, exhibiendo los cambios exactos línea por línea. Esencial para revisar el contenido de cada alteración.

git log --patch

Filtra el historial de commits para mostrar solo aquellos realizados dentro de un período específico. Se pueden usar formatos como "2 weeks ago", "yesterday", "2023-01-01".

git log --since="2 weeks ago"

Filtra o histórico para exibir apenas os commits feitos por um autor específico. O nome do autor deve corresponder ao configurado no Git.

git log --author="nome"

Filtra el historial de commits por una palabra clave o patrón regex en el mensaje del commit. Útil para encontrar commits relacionados con correcciones de bugs o funcionalidades específicas.

git log --grep="fix"

Busca commits que introdujeron o eliminaron una string específica en el código (también conocido como opción "pickaxe"). Es potente para rastrear dónde una función o variable fue cambiada por primera vez.

git log -S "função"

Muestra el historial de un archivo específico, siguiendo su historial a través de renombres. Garantiza que veas todos los cambios en el archivo, incluso si su nombre ha cambiado.

git log --follow arquivo.txt

Presenta un log de commits altamente formateado y coloreado, mostrando hash, branches/tags, mensaje, fecha relativa y autor. Personalizable para una mejor legibilidad visual.

git log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset'

Una visualización compacta y decorada del historial, mostrando el grafo de branches y tags. Similar al log completo, pero sin incluir todas las referencias remotas por defecto.

git log --oneline --decorate --graph

Muestra el historial de commits en orden cronológico inverso, es decir, del commit más antiguo al más reciente. Útil para ver la evolución de un proyecto.

git log --reverse

Muestra el contenido del último commit en la branch actual, incluyendo el diff. Es una forma rápida de revisar lo que se ha commiteado más recientemente.

git show HEAD

Muestra el contenido del commit que está dos commits antes del HEAD. Se puede usar cualquier referencia de commit (hash, tag, branch, HEAD~n).

git show HEAD~2

Muestra solo los nombres de los archivos que fueron modificados en el commit especificado, sin mostrar el diff completo.

git show --name-only HEAD

Muestra estadísticas de modificación para el commit especificado, mostrando qué archivos fueron alterados y el número de líneas añadidas/eliminadas.

git show --stat HEAD

Crea una nueva rama con el nombre especificado (ej: `feature/nueva-funcionalidad`) e inmediatamente cambia a ella. Es un atajo para `git branch <nombre>` seguido de `git checkout <nombre>`.

git checkout -b feature/nova-funcionalidade

Comando moderno y más intuitivo para crear una nueva rama y cambiar a ella. Es la alternativa recomendada a `git checkout -b` para este propósito.

git switch -c feature/nova-funcionalidade

Lista todas las ramas, incluyendo las locales y las remotas. Las ramas remotas están prefijadas con el nombre del remote (ej: `remotes/origin/main`).

git branch -a

Lista solo las branches remotas. Útil para ver qué branches existen en los repositorios remotos sin contaminar la salida con las locales.

git branch -r

Lista las branches locales con información adicional, como el último commit de cada branch y el mensaje del commit. Ayuda a tener una visión rápida del estado de cada branch.

git branch -v

Lista las branches que ya fueron totalmente mergeadas en la branch actual. Generalmente, son branches que pueden ser eliminadas con seguridad.

git branch --merged

Lista las branches que aún no han sido mergeadas en la branch actual. Estas branches contienen trabajo que aún no ha sido integrado y no deben ser eliminadas sin cuidado.

git branch --no-merged

Elimina la branch local especificada (ej: `feature-branch`). Este es un "delete seguro" que fallará si la branch contiene commits no mergeados en la branch actual.

git branch -d feature-branch

Fuerza la eliminación de la branch local especificada, incluso si contiene commits no mergeados. Usa con cautela, ya que puede resultar en pérdida de trabajo.

git branch -D feature-branch

Elimina una branch del repositorio remoto (ej: `origin/feature-branch`). Es el comando para eliminar branches remotas que ya no son necesarias.

git push origin --delete feature-branch

Renombra la branch local `old-name` a `new-name`. Si `old-name` se omite, renombra la branch actual.

git branch -m old-name new-name

Fuerza el renombrado de una branch, incluso si `new-name` ya existe. Usa con cuidado para evitar sobrescribir branches existentes.

git branch -M old-name new-name

Muestra el nombre de la branch actual en la que estás trabajando. Útil para scripts o para confirmar rápidamente la branch.

git branch --show-current

Lista todas las branches que contienen el commit especificado (ej: `abc123`). Útil para rastrear dónde se integró un commit específico.

git branch --contains abc123

Lista las branches locales ordenadas por la fecha del último commit, del más reciente al más antiguo. La flag `-` invierte el orden.

git branch --sort=-committerdate

Integra los cambios de la `feature-branch` en la rama actual. Si es posible, realiza un fast-forward merge; de lo contrario, crea un merge commit.

git merge feature-branch

Fuerza la creación de un merge commit, incluso si un fast-forward merge fuera posible. Esto preserva el historial de ramas, mostrando explícitamente dónde se integró la feature.

git merge --no-ff feature-branch

Aplica los cambios de la `feature-branch` en la rama actual como un único commit, sin registrar la `feature-branch` en el historial. Los commits de la `feature-branch` son "aplastados" en un único commit en la rama de destino.

git merge --squash feature-branch

Inicia un rebase interactivo en los últimos 3 commits a partir del HEAD. Permite reordenar, editar, aplastar (squash) o dividir commits, y eliminar commits. Abre un editor de texto con las opciones.

git rebase -i HEAD~3

Inicia un rebase interactivo de todos los commits en la branch actual que no están en la branch `main`. Útil para limpiar el historial antes de hacer un merge en la `main`.

git rebase -i main

Continúa el proceso de rebase después de resolver conflictos de merge o después de editar un commit durante un rebase interactivo.

git rebase --continue

Cancela el rebase en curso y devuelve la branch al estado en que estaba antes del inicio del rebase. Útil si decides no continuar o si encuentras problemas insolubles.

git rebase --abort

Aplica los cambios introducidos por un commit específico (ej: `abc123`) en la branch actual, creando un nuevo commit con esos cambios. Útil para portar correcciones o funcionalidades puntuales.

git cherry-pick abc123

Aplica un rango de commits (del `abc123` exclusivo hasta el `def456` inclusivo) en la branch actual. Útil para portar múltiples cambios a la vez.

git cherry-pick abc123..def456

Aplica los cambios del commit `abc123` en el directorio de trabajo y área de staging, pero sin crear un nuevo commit. Permite revisar y ajustar los cambios antes de commitarlos.

git cherry-pick --no-commit abc123

Aplica el commit `abc123` y añade una línea "cherry-picked from commit abc123" al mensaje del nuevo commit, indicando el origen.

git cherry-pick -x abc123

Aplica el commit `abc123` y añade una línea "Signed-off-by: Your Name <your.email@example.com>" al mensaje del nuevo commit, indicando que certificas el origen del cambio.

git cherry-pick --signoff abc123

Cancela un cherry-pick en curso y devuelve la branch al estado anterior. Útil si hay conflictos o si el cherry-pick ya no es deseado.

git cherry-pick --abort

Busca una string o patrón regex en los archivos rastreados por Git en el directorio de trabajo. Es como un `grep` tradicional, pero optimizado para repositorios Git.

git grep "função"

Busca una string o patrón regex en el código en un commit específico (ej: `HEAD~5`). Útil para encontrar dónde existía una string en un punto anterior del historial.

git grep "função" HEAD~5

Busca una string y muestra los números de línea donde se encontró la coincidencia. Ayuda a localizar rápidamente la ocurrencia en el archivo.

git grep -n "função"

Realiza una búsqueda case insensitive, ignorando la diferencia entre letras mayúsculas y minúsculas al buscar la string.

git grep -i "função"

Muestra el historial de revisiones línea por línea para un archivo específico. Para cada línea, exhibe el commit que la modificó por última vez, el autor y la fecha. Útil para identificar quién y cuándo alteró una parte del código.

git blame arquivo.txt

Restringe la salida de `git blame` a un intervalo específico de líneas (de la línea 10 a la 20, inclusive) de un archivo. Útil para enfocarse en una sección problemática.

git blame -L 10,20 arquivo.txt

Muestra el historial de commits que afectaron el `archivo.txt`, incluyendo el patch (diff) completo de cada alteración. Permite ver exactamente cómo el archivo evolucionó.

git log -p arquivo.txt

Muestra el historial de un archivo específico, siguiendo su historial a través de renombramientos. Garantiza que veas todos los cambios en el archivo, incluso si su nombre ha cambiado.

git log --follow arquivo.txt

Inicia una sesión de `git bisect`, que es una herramienta para encontrar el commit que introdujo un bug usando una búsqueda binaria en el historial.

git bisect start

Marca el commit actual (HEAD) como "malo", indicando que el bug está presente en este punto.

git bisect bad HEAD

Marca un commit conocido (ej: `v1.0.0`) como "bueno", indicando que el bug no estaba presente en este punto. Git entonces elige un commit intermedio para que pruebes.

git bisect good v1.0.0

Automatiza el proceso de bisect ejecutando un script o comando (ej: `npm test`) en cada commit. El script debe devolver 0 para "bueno" y un código de error (1-127) para "malo".

git bisect run npm test

Finaliza la sesión de `git bisect` y devuelve la branch al commit en el que estaba antes de iniciar el bisect.

git bisect reset

Abre una interfaz gráfica (si está configurada) para visualizar el grafo de commits y el progreso del bisect.

git bisect visualize

Muestra el log de todos los comandos `git bisect` ejecutados en la sesión actual, útil para revisar el proceso.

git bisect log

Repite una sesión de bisect a partir de un archivo de log previamente guardado, permitiendo recrear el proceso de depuración.

git bisect replay arquivo.log

Crea una etiqueta ligera (lightweight tag) con el nombre `v1.0.0` en el commit actual. Las etiquetas ligeras son solo un puntero a un commit.

git tag v1.0.0

Crea una etiqueta anotada (annotated tag) con el nombre `v1.0.0` y un mensaje descriptivo. Las etiquetas anotadas son objetos Git completos, que contienen el nombre del etiquetador, e-mail, fecha y mensaje, y se recomiendan para releases.

git tag -a v1.0.0 -m "Release 1.0.0"

Crea una etiqueta anotada `v1.0.0` en un commit específico (ej: `abc123`), en lugar del HEAD. Útil para marcar commits pasados.

git tag -a v1.0.0 abc123 -m "Tag commit específico"

Lista todas las tags en el repositorio local en orden alfabético.

git tag

Lista tags que corresponden a un patrón específico (ej: todas las tags que comienzan con "v1.").

git tag -l "v1.*"

Muestra los detalles de una tag específica, incluyendo el mensaje de la tag (si es anotada) y el commit al cual apunta.

git show v1.0.0

Elimina la tag `v1.0.0` del repositorio local. Esto no elimina la tag de repositorios remotos.

git tag -d v1.0.0

Elimina la tag `v1.0.0` del repositorio remoto `origin`. Es necesario para eliminar tags publicadas.

git push origin --delete v1.0.0

Envía una tag específica (`v1.0.0`) al repositorio remoto `origin`. Las tags no se envían automáticamente con `git push`.

git push origin v1.0.0

Envía todas las tags locales al repositorio remoto `origin`. Útil para publicar varias tags a la vez.

git push origin --tags

Verifica la firma GPG de una tag anotada. Requiere que la tag haya sido firmada y que la clave GPG del firmante esté disponible.

git tag -v v1.0.0

Crea una tag anotada y firmada con GPG. La firma garantiza la autenticidad e integridad de la tag.

git tag -s v1.0.0 -m "Release"

Fuerza la creación o actualización de una tag existente. Usa con cautela, ya que puede sobrescribir tags importantes.

git tag -f v1.0.0

Guarda los cambios no commitados (modificaciones en el directorio de trabajo y archivos staged) en una pila de stashes, revirtiendo el directorio de trabajo al estado del último commit. Los archivos no rastreados no se incluyen por defecto.

git stash

Guarda los cambios con un mensaje descriptivo. El mensaje ayuda a identificar el contenido del stash posteriormente, especialmente cuando hay varios stashes.

git stash push -m "WIP: feature X"

Guarda solo los cambios de un archivo específico en el stash, dejando otros archivos inalterados. El `--` es necesario para distinguir la ruta del archivo de otras opciones.

git stash push -- arquivo.txt

Guarda los cambios, incluyendo también los archivos no rastreados (untracked files) en el stash. Útil para guardar todo el estado del directorio de trabajo.

git stash push --include-untracked

Lista todos los stashes actualmente almacenados, mostrando una breve descripción y el índice de cada uno (ej: `stash@{0}`).

git stash list

Muestra un resumen de los cambios contenidos en un stash específico (ej: `stash@{0}`). Muestra qué archivos fueron modificados.

git stash show stash@{0}

Muestra el patch completo (diff) de un stash específico, exhibiendo los cambios línea por línea. Esencial para revisar el contenido antes de aplicar.

git stash show -p stash@{0}

Aplica los cambios de un stash específico en el directorio de trabajo, pero mantiene el stash en la pila. Útil si quieres aplicar el mismo stash en varias branches.

git stash apply stash@{0}

Aplica los cambios de un stash específico en el directorio de trabajo y, a continuación, elimina el stash de la pila. Es el comando más común para aplicar y limpiar stashes.

git stash pop stash@{0}

Elimina un stash específico de la pila sin aplicar sus cambios. Útil para descartar stashes que ya no son necesarios.

git stash drop stash@{0}

Elimina todos los stashes de la pila. Usa con extrema precaución, ya que esta acción es irreversible.

git stash clear

Crea una nueva branch a partir del commit donde se creó el stash, aplica el stash en ella y, a continuación, elimina el stash de la pila. Útil para continuar el trabajo de un stash en una nueva branch.

git stash branch nova-branch stash@{0}

Guarda los cambios no staged en el stash, pero mantiene los cambios que ya estaban en el área de staging. Útil para commitear solo parte de los cambios y guardar el resto.

git stash --keep-index

Deshace el último commit, moviendo el HEAD al commit anterior, pero mantiene los cambios del commit deshecho en el área de staging. El directorio de trabajo permanece inalterado.

git reset --soft HEAD~1

Deshace el último commit y mueve los cambios del commit deshecho al directorio de trabajo (no staged). Es el comportamiento predeterminado de `git reset` si no se especifica ninguna flag. El área de staging se limpia.

git reset --mixed HEAD~1

Deshace el último commit, descarta todos los cambios del commit deshecho del directorio de trabajo y del área de staging. Esta acción es irreversible y puede resultar en pérdida de trabajo no commitado. ¡Usa con extrema precaución!

git reset --hard HEAD~1

Descarta los cambios en `archivo.txt` en el directorio de trabajo, restaurándolo al estado del último commit. Es una alternativa más segura e intuitiva a `git checkout -- archivo.txt`.

git restore arquivo.txt

Remueve el `archivo.txt` del área de staging, moviendo sus cambios de vuelta al directorio de trabajo (unstage). El archivo en el directorio de trabajo permanece inalterado.

git restore --staged arquivo.txt

Restaura el `archivo.txt` en el directorio de trabajo y en el área de staging al estado en que estaba en un commit específico (ej: `HEAD~1`). Útil para recuperar versiones antiguas de archivos.

git restore --source=HEAD~1 arquivo.txt

Muestra un log de todas las acciones que modificaron el HEAD del repositorio local. Es un historial de "dónde estuvo el HEAD", permitiendo recuperar commits que parecen haberse perdido después de resets o rebases.

git reflog

Muestra el reflog para una branch específica (ej: `main`), indicando todas las veces que la referencia `main` fue actualizada.

git reflog show main

Vuelve el HEAD (y la branch actual) a un estado anterior registrado en el reflog (en este caso, el segundo estado más reciente). Es la principal forma de recuperar commits después de un `git reset --hard` accidental.

git reset --hard HEAD@{2}

Lista los repositorios remotos configurados para el proyecto, mostrando sus nombres y URLs (verbose). Útil para verificar de dónde estás trayendo y a dónde estás enviando.

git remote -v

Añade un nuevo repositorio remoto con el nombre `upstream` y la URL especificada. Común para configurar un remote para el repositorio original en un fork.

git remote add upstream https://...

Cambia la URL de un repositorio remoto existente (ej: `origin`). Útil para actualizar la ubicación de un repositorio o cambiar entre SSH y HTTPS.

git remote set-url origin https://...

Elimina un repositorio remoto con el nombre `upstream` de la configuración local. Esto no afecta al repositorio remoto en sí.

git remote remove upstream

Descarga objetos y referencias de todos los repositorios remotos configurados. No integra los cambios en el directorio de trabajo, solo actualiza las referencias remotas locales.

git fetch --all

Elimina las referencias locales a branches remotas que fueron eliminadas en el repositorio remoto. Ayuda a mantener la lista de branches remotas limpia y actualizada.

git fetch --prune

Descarga los cambios del repositorio remoto y, a continuación, aplica tus cambios locales sobre ellos usando rebase. Esto evita commits de merge innecesarios y mantiene un historial lineal.

git pull --rebase

Descarga los cambios del repositorio remoto e intenta realizar un fast-forward merge. Si un fast-forward no es posible (es decir, hay commits locales que no son ancestros del remote), el comando falla, requiriendo un merge manual o rebase.

git pull --ff-only

Envía la `feature-branch` al repositorio remoto `origin` y la configura como la branch de upstream. Esto permite usar `git pull` y `git push` sin especificar el remote y la branch posteriormente.

git push -u origin feature-branch

Envía los cambios al repositorio remoto, forzando la sobrescritura del historial, pero con una salvaguarda. Solo funciona si la branch remota no ha sido actualizada por otra persona desde tu último fetch, previniendo sobrescrituras accidentales de trabajo ajeno.

git push --force-with-lease

Elimina la `feature-branch` del repositorio remoto `origin`. El `:` antes del nombre de la branch local indica que estás enviando "nada" a la branch remota, eliminándola efectivamente.

git push origin :feature-branch

Envía todas las branches locales al repositorio remoto `origin`. Útil para asegurar que todas tus branches estén sincronizadas con el remoto.

git push --all origin

Refleja el repositorio local en el repositorio remoto `origin`. Esto significa que todas las branches, tags y referencias del local serán replicadas en el remoto, incluyendo la eliminación de cualquier cosa que no esté en el local. Usa con extrema precaución, ya que es una operación destructiva.

git push --mirror origin

Envía todas las tags locales al repositorio remoto, y también envía cualquier commit que sea referenciado por esas tags (si aún no están en el remote). `--follow-tags` garantiza que las tags anotadas que apuntan a commits que aún no han sido enviados también sean enviadas.

git push --tags --follow-tags