Explorar guías rápidas · Git

Tecnología: GitCategoría: Control de versionesNivel: PrincipianteActualizado

Comandos de Git para el día a día

Usa los comandos de Git que los ingenieros necesitan con más frecuencia para inspeccionar cambios, crear commits, sincronizar ramas, revisar el historial y recuperarte de errores locales comunes.

En esta página
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Comprobar el estado actual del repositorio
  5. 2. Mostrar un estado compacto
  6. 3. Ver los cambios sin preparar
  7. 4. Ver los cambios preparados
  8. 5. Mostrar el contexto preparado y sin preparar
  9. 6. Crear una rama nueva y cambiar a ella
  10. 7. Cambiar a una rama existente
  11. 8. Listar las ramas locales
  12. 9. Renombrar la rama actual
  13. 10. Preparar un archivo
  14. 11. Preparar varios archivos conocidos
  15. 12. Preparar todos los cambios actuales
  16. 13. Preparar de forma interactiva
  17. 14. Quitar un archivo del área de preparación sin descartar sus cambios
  18. 15. Hacer commit de los cambios preparados
  19. 16. Inspeccionar el commit antes de hacer push
  20. 17. Corregir el commit local más reciente con amend
  21. 18. Traer las actualizaciones remotas sin cambiar tus archivos
  22. 19. Inspeccionar qué cambió en la rama main remota
  23. 20. Actualizar tu rama main local
  24. 21. Hacer rebase de una rama de funcionalidad sobre main actualizada
  25. 22. Hacer merge de main en la rama de funcionalidad
  26. 23. Hacer push de una rama nueva
  27. 24. Hacer push de commits posteriores
  28. 25. Preferir force-with-lease a force
  29. 26. No hacer nunca push forzado a la ligera en ramas compartidas y protegidas
  30. 27. Ver el historial reciente
  31. 28. Mostrar los commits de un archivo
  32. 29. Ver quién cambió líneas concretas
  33. 30. Comparar tu rama con main
  34. 31. Comparar dos commits
  35. 32. Restaurar un archivo sin preparar a la última versión confirmada
  36. 33. Restaurar un archivo desde otro commit
  37. 34. Revertir un commit compartido de forma segura con revert
  38. 35. No confundir revert con reset
  39. 36. Mover HEAD hacia atrás manteniendo los cambios preparados
  40. 37. Mover HEAD hacia atrás manteniendo los cambios sin preparar
  41. 38. Evitar reset --hard salvo que estés seguro
  42. 39. Guardar temporalmente los cambios locales con stash
  43. 40. Hacer stash de archivos con y sin seguimiento
  44. 41. Listar los stashes
  45. 42. Inspeccionar un stash antes de aplicarlo
  46. 43. Aplicar un stash sin eliminarlo
  47. 44. Aplicar y eliminar un stash
  48. 45. Eliminar un stash de forma deliberada
  49. 46. Eliminar una rama local ya integrada con merge
  50. 47. Forzar la eliminación de una rama local solo de forma intencionada
  51. 48. Eliminar una rama remota
  52. 49. Ver los remotos configurados
  53. 50. Inspeccionar el seguimiento upstream
  54. 51. Configurar una rama upstream manualmente
  55. 52. Mostrar la raíz del repositorio
  56. 53. Mostrar el nombre de la rama actual
  57. 54. Mostrar el commit actual
  58. 55. Comprobar si el árbol de trabajo está limpio en automatizaciones
  59. 56. Hacer fetch y podar las ramas remotas eliminadas
  60. 57. Ver los commits exclusivos de tu rama
  61. 58. Ver los archivos cambiados respecto a main
  62. 59. Buscar en los mensajes de commit
  63. 60. Encontrar commits que cambiaron una cadena
  64. 61. Encontrar commits cuyo parche coincide con un patrón
  65. 62. Mostrar un commit
  66. 63. Hacer cherry-pick de un commit conocido
  67. 64. Abortar un cherry-pick con conflictos
  68. 65. Abortar un rebase
  69. 66. Continuar un rebase después de resolver conflictos
  70. 67. Abortar un merge
  71. 68. Inspeccionar los marcadores de conflicto
  72. 69. Usar reflog para recuperar el historial local
  73. 70. Crear una rama de seguridad antes de editar historial local con riesgo
  74. Qué significa el resultado
  75. Qué revisar
  76. git status muestra cambios preparados y sin preparar en el mismo archivo
  77. El push es rechazado
  78. El commit contiene archivos no relacionados
  79. El merge o el rebase generó conflictos
  80. Perdiste un commit local después de un reset/rebase
  81. La rama de funcionalidad contiene commits inesperados
  82. Notas de producción
  83. El historial compartido debe tratarse como inmutable por defecto
  84. --force-with-lease es más seguro, no está libre de riesgo
  85. Git no protege automáticamente el trabajo sin confirmar frente a todos los comandos
  86. Un árbol de trabajo limpio simplifica las operaciones arriesgadas
  87. Los commits pequeños y enfocados facilitan la recuperación
  88. El historial de Git forma parte de la ingeniería de producción
  89. Errores comunes
  90. 1. Ejecutar git add . sin revisar el estado
  91. 2. Hacer commit sin revisar git diff --cached
  92. 3. Usar git pull sin entender la estrategia configurada
  93. 4. Usar git push --force
  94. 5. Usar git reset --hard como limpieza general
  95. 6. Hacer amend de commits ya compartidos con compañeros
  96. 7. Eliminar una rama sin revisar sus commits exclusivos
  97. 8. Tratar git stash como almacenamiento permanente
  98. 9. Usar git blame para buscar culpables
  99. 10. Suponer que un push rechazado obliga a hacer push forzado
  100. Siguiente paso
  101. Para profundizar

Problema

Usas Git todos los días, pero no quieres memorizar todos los comandos ni arriesgarte a ejecutar uno destructivo en el momento equivocado.

La mayoría de los flujos de trabajo de ingeniería necesitan repetidamente:

  • inspeccionar qué cambió
  • crear ramas o cambiar de rama
  • preparar archivos concretos
  • hacer commit del trabajo
  • actualizar desde el remoto
  • hacer push de una rama
  • comparar cambios
  • inspeccionar el historial
  • descartar o restaurar cambios locales de forma segura
  • recuperarte de un pequeño error local

El objetivo es usar un conjunto reducido de comandos fiables entendiendo con claridad qué cambia cada uno.

Respuesta rápida

Para una rama de funcionalidad normal:

git status
git switch -c feature/my-change
git add path/to/file
git diff --cached
git commit -m "Describe the change"
git fetch origin
git rebase origin/main
git push -u origin feature/my-change

Antes de cualquier comando que cambie el historial o elimine trabajo, ejecuta:

git status
git diff
git log --oneline --decorate -10

El hábito más seguro es:

inspeccionar
→ preparar de forma intencionada
→ revisar el diff preparado
→ commit
→ sincronizar
→ push

Código / comandos

1. Comprobar el estado actual del repositorio

git status

Usa este comando primero.

Muestra:

  • la rama actual
  • los archivos preparados
  • los archivos modificados
  • los archivos sin seguimiento
  • si la rama va por delante o por detrás de su rama upstream

Antes de hacer reset, restore, rebase o cambiar de rama, revisa git status.


2. Mostrar un estado compacto

git status --short

Salida típica:

 M src/app.py
M  README.md
?? notes.txt

Interpretación:

columna izquierda = estado en el área de preparación
columna derecha   = estado en el árbol de trabajo
??                = sin seguimiento

Un archivo puede tener cambios preparados y sin preparar al mismo tiempo.


3. Ver los cambios sin preparar

git diff

Esto compara:

el árbol de trabajo
con
el índice/área de preparación (staging area)

Úsalo antes de preparar.


4. Ver los cambios preparados

git diff --cached

Equivalente:

git diff --staged

Esto compara:

el área de preparación
con
HEAD

Ejecútalo antes de hacer commit.

Responde a la pregunta:

¿Qué contendrá exactamente este commit?

5. Mostrar el contexto preparado y sin preparar

git diff
git diff --cached

No hay un único sustituto para entender ambos estados.

Un error común es revisar solo el diff del árbol de trabajo y olvidar los cambios ya preparados.


6. Crear una rama nueva y cambiar a ella

git switch -c feature/report-engine

Esto crea:

feature/report-engine

a partir del commit actual y cambia a ella.

En las versiones modernas de Git, prefiere git switch para cambiar de rama.


7. Cambiar a una rama existente

git switch main

Equivalente antiguo:

git checkout main

checkout sigue funcionando, pero switch deja más clara la intención de cambiar de rama.


8. Listar las ramas locales

git branch

Mostrar las ramas locales y las de seguimiento remoto:

git branch -a

Mostrar la información de seguimiento:

git branch -vv

9. Renombrar la rama actual

git branch -m new-branch-name

Si ya habías hecho push de la rama antigua, renombrar la rama local no renombra automáticamente la rama remota.

Gestiona la limpieza del remoto por separado y de forma deliberada.


10. Preparar un archivo

git add src/app.py

Usa esto cuando quieras que el alcance del commit siga siendo explícito.


11. Preparar varios archivos conocidos

git add src/app.py src/config.py README.md

Es más seguro que prepararlo todo cuando hay trabajo no relacionado en el repositorio.


12. Preparar todos los cambios actuales

git add -A

Esto prepara:

  • archivos nuevos
  • archivos modificados
  • eliminaciones

Úsalo solo después de comprobar:

git status

y de revisar si todos los cambios pertenecen al mismo commit.


13. Preparar de forma interactiva

git add -p

Usa esto cuando un archivo contiene cambios para varios commits lógicos.

Git te permitirá preparar fragmentos (hunks) de forma selectiva.

Es uno de los comandos más útiles para mantener commits enfocados.


14. Quitar un archivo del área de preparación sin descartar sus cambios

git restore --staged src/app.py

Esto saca el archivo del área de preparación.

Tus cambios en el árbol de trabajo se conservan.

Úsalo si preparaste el archivo equivocado.


15. Hacer commit de los cambios preparados

git commit -m "Add pipeline retry handling"

Los mensajes de commit deben describir el cambio, no el acto de editar.

Prefiere:

Add pipeline retry handling

en lugar de:

Changes

16. Inspeccionar el commit antes de hacer push

git show --stat

Mostrar el parche completo:

git show

De forma predeterminada, esto muestra el commit HEAD actual.


17. Corregir el commit local más reciente con amend

Si olvidaste preparar un archivo:

git add src/config.py
git commit --amend --no-edit

O para cambiar el mensaje:

git commit --amend

Usa amend libremente con un commit que no se haya compartido.

Si el commit ya está en una rama compartida, amend reescribe el historial y puede requerir un push forzado.


18. Traer las actualizaciones remotas sin cambiar tus archivos

git fetch origin

Esto actualiza las referencias de seguimiento remoto, como:

origin/main
origin/develop

No hace merge ni rebase de tu rama actual.

Por eso fetch es un primer paso seguro antes de decidir cómo sincronizar.


19. Inspeccionar qué cambió en la rama main remota

git log --oneline HEAD..origin/main

Esto muestra los commits de origin/main que no están en tu rama actual.

Para ver los commits que tiene tu rama y que origin/main no tiene:

git log --oneline origin/main..HEAD

20. Actualizar tu rama main local

git switch main
git pull --ff-only

--ff-only se niega a crear un commit de merge inesperado.

Si tu main local ha divergido, Git se detiene y te deja investigar en lugar de hacer un merge automático.


21. Hacer rebase de una rama de funcionalidad sobre main actualizada

git fetch origin
git rebase origin/main

Usa esto cuando tu equipo prefiera un historial lineal en las ramas de funcionalidad.

Conceptualmente:

tus commits
→ se vuelven a aplicar encima del último origin/main

No hagas rebase a la ligera de commits sobre los que otras personas ya están trabajando.


22. Hacer merge de main en la rama de funcionalidad

Alternativa a rebase:

git fetch origin
git merge origin/main

Usa esto cuando se prefiera un historial basado en merges o cuando no convenga reescribir el historial de la rama.

La elección entre merge y rebase es una decisión del flujo de trabajo del equipo.


23. Hacer push de una rama nueva

git push -u origin feature/report-engine

-u configura la rama upstream.

Después, normalmente:

git push

es suficiente.


24. Hacer push de commits posteriores

git push

Si Git indica que el remoto contiene trabajo que tú no tienes, no hagas un push forzado de inmediato.

Haz fetch e inspecciona la divergencia.


25. Preferir force-with-lease a force

Si hiciste rebase intencionadamente de tu propia rama de funcionalidad remota:

git push --force-with-lease

Prefiere esto en lugar de:

git push --force

--force-with-lease se niega a sobrescribir la rama remota si cambió de una forma que tu repositorio local no espera.

Aun así, úsalo con cuidado.


26. No hacer nunca push forzado a la ligera en ramas compartidas y protegidas

Evita reescribir:

main
master
develop
ramas de release
ramas compartidas del equipo

salvo que el flujo de trabajo de tu repositorio lo exija explícitamente.

Reescribir el historial en ramas compartidas puede afectar a otros desarrolladores y a CI/CD.


27. Ver el historial reciente

git log --oneline -10

Con decoración de ramas y tags:

git log --oneline --decorate -10

Con el grafo:

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

Es útil para entender las relaciones entre ramas.


28. Mostrar los commits de un archivo

git log --oneline -- src/app.py

Mostrar los parches:

git log -p -- src/app.py

Úsalo para investigar cuándo y por qué cambió un archivo.


29. Ver quién cambió líneas concretas

git blame src/app.py

Usa blame como herramienta de navegación para encontrar el commit relevante.

No lo tomes como prueba de quién «causó» un bug actual; la línea puede haberse movido o heredado de una lógica más antigua.


30. Comparar tu rama con main

git diff origin/main...HEAD

La comparación con tres puntos es útil para revisar los cambios que introdujo tu rama desde la base de merge con origin/main.

Se acerca mucho al conjunto de cambios que normalmente se revisa en una pull request.


31. Comparar dos commits

git diff <commit-a> <commit-b>

Ejemplo:

git diff a1b2c3d e4f5a6b

Añade:

--stat

para obtener un resumen:

git diff --stat a1b2c3d e4f5a6b

32. Restaurar un archivo sin preparar a la última versión confirmada

git restore src/app.py

Advertencia:

Esto descarta los cambios sin preparar de ese archivo.

Ejecuta:

git diff src/app.py

primero si tienes cualquier duda.


33. Restaurar un archivo desde otro commit

git restore \
  --source=<commit> \
  -- path/to/file

Ejemplo:

git restore \
  --source=HEAD~1 \
  -- src/app.py

Esto coloca esa versión en tu árbol de trabajo.

No crea un commit automáticamente.


34. Revertir un commit compartido de forma segura con revert

git revert <commit>

Esto crea un commit nuevo que invierte el commit seleccionado.

Úsalo con historial ya compartido, porque conserva el grafo de commits existente.

Ejemplo:

git revert a1b2c3d

35. No confundir revert con reset

git revert
→ crea un nuevo commit inverso

git reset
→ mueve una referencia de rama y puede alterar el estado del área de preparación/árbol de trabajo

Para un historial público o compartido, revert suele ser más seguro.


36. Mover HEAD hacia atrás manteniendo los cambios preparados

git reset --soft HEAD~1

Esto elimina el último commit local y deja sus cambios preparados.

Úsalo para limpiar el historial local antes de compartirlo.


37. Mover HEAD hacia atrás manteniendo los cambios sin preparar

git reset HEAD~1

Modo predeterminado equivalente:

--mixed

El commit se elimina localmente, pero los cambios en los archivos se quedan en el árbol de trabajo.


38. Evitar reset --hard salvo que estés seguro

git reset --hard HEAD

Esto descarta los cambios rastreados del árbol de trabajo y del área de preparación.

Puede destruir trabajo sin confirmar.

No lo uses como comando de limpieza habitual.

Inspecciona primero:

git status
git diff
git diff --cached

39. Guardar temporalmente los cambios locales con stash

git stash push -m "WIP report changes"

Úsalo cuando necesites un árbol de trabajo limpio de forma temporal.


40. Hacer stash de archivos con y sin seguimiento

git stash push -u -m "WIP"

-u incluye los archivos sin seguimiento.

Los archivos ignorados siguen excluidos.


41. Listar los stashes

git stash list

Ejemplo:

stash@{0}: On feature/report-engine: WIP

42. Inspeccionar un stash antes de aplicarlo

git stash show -p stash@{0}

Útil cuando tienes varios stashes y no recuerdas su contenido.


43. Aplicar un stash sin eliminarlo

git stash apply stash@{0}

Usa esto cuando quieras conservar el stash como copia de seguridad hasta confirmar el resultado.


44. Aplicar y eliminar un stash

git stash pop

Esto aplica el stash más reciente y lo elimina si la aplicación se completa sin conflictos.

Para trabajo valioso, usar apply primero puede ser más seguro.


45. Eliminar un stash de forma deliberada

git stash drop stash@{0}

No ejecutes:

git stash clear

salvo que quieras eliminar todos los stashes intencionadamente.


46. Eliminar una rama local ya integrada con merge

Después de confirmar que se hizo merge:

git branch -d feature/report-engine

-d se niega si Git no considera que la rama esté completamente integrada.

Es más seguro que -D.


47. Forzar la eliminación de una rama local solo de forma intencionada

git branch -D feature/report-engine

Esto elimina la rama local aunque contenga commits que no se hayan integrado en ningún otro sitio.

Comprueba primero:

git log main..feature/report-engine

48. Eliminar una rama remota

git push origin --delete feature/report-engine

Hazlo después de que la rama se haya integrado o cuando ya no sea necesaria.

La eliminación en el remoto afecta a otros colaboradores, así que confirma primero de quién es la rama y cuál es el flujo de trabajo.


49. Ver los remotos configurados

git remote -v

Útil antes de hacer push si existen varios remotos.


50. Inspeccionar el seguimiento upstream

git branch -vv

Esto muestra si una rama local sigue a:

origin/main
origin/feature/...

y si va por delante o por detrás.


51. Configurar una rama upstream manualmente

git branch \
  --set-upstream-to=origin/main \
  main

Normalmente git push -u la configura automáticamente para las ramas de funcionalidad.


52. Mostrar la raíz del repositorio

git rev-parse --show-toplevel

Útil cuando trabajas en directorios anidados y no tienes claro en qué repositorio estás.


53. Mostrar el nombre de la rama actual

git branch --show-current

Útil en scripts y comprobaciones rápidas.


54. Mostrar el commit actual

git rev-parse HEAD

Versión corta:

git rev-parse --short HEAD

Útil para los registros de despliegue y los metadatos de compilación.


55. Comprobar si el árbol de trabajo está limpio en automatizaciones

git status --porcelain

Si no hay salida, no hay cambios con o sin seguimiento que Git informaría normalmente.

Útil en scripts porque el formato de salida es estable para el análisis automático.


56. Hacer fetch y podar las ramas remotas eliminadas

git fetch --prune

Esto elimina referencias de seguimiento remoto obsoletas, como:

origin/feature/old-branch

cuando la rama se eliminó en el remoto.

No elimina ramas locales.


57. Ver los commits exclusivos de tu rama

git log --oneline origin/main..HEAD

Úsalo antes de abrir una pull request para confirmar qué aporta tu rama.


58. Ver los archivos cambiados respecto a main

git diff --name-status origin/main...HEAD

Ejemplo de salida:

M  src/app.py
A  src/new_module.py
D  src/old_module.py

Úsalo para revisar rápidamente el alcance.


59. Buscar en los mensajes de commit

git log \
  --oneline \
  --grep="pipeline"

Útil cuando buscas un cambio pasado por tema.


60. Encontrar commits que cambiaron una cadena

git log \
  -S "old_function_name" \
  --oneline

Usa -S cuando quieras los commits que cambiaron el número de apariciones de una cadena concreta.

Es útil para depurar con el historial.


61. Encontrar commits cuyo parche coincide con un patrón

git log \
  -G "retry.*count" \
  --oneline

-G busca una expresión regular en el diff.

Úsalo para investigar el historial del código.


62. Mostrar un commit

git show <commit>

Solo el resumen:

git show --stat <commit>

Úsalo antes de hacer revert o cherry-pick de un commit.


63. Hacer cherry-pick de un commit conocido

git cherry-pick <commit>

Úsalo cuando haya que aplicar un commit concreto a otra rama.

Antes de hacer cherry-pick, confirma que el commit es autónomo.

Un cherry-pick puede generar conflictos o arrastrar dependencias ocultas de los commits cercanos.


64. Abortar un cherry-pick con conflictos

git cherry-pick --abort

Úsalo si hay que abandonar la operación y quieres volver al estado anterior al cherry-pick.


65. Abortar un rebase

git rebase --abort

Úsalo cuando un rebase se vuelve inseguro o te das cuenta de que partiste del estado equivocado.


66. Continuar un rebase después de resolver conflictos

Después de editar los archivos en conflicto:

git add path/to/resolved-file
git rebase --continue

Repite hasta terminar.

No hagas commit manual de las resoluciones de conflictos durante un rebase normal, salvo que el flujo de trabajo lo pida explícitamente.


67. Abortar un merge

Si hay un merge en curso y debe abandonarse:

git merge --abort

Usa esto en lugar de intentar restablecer los archivos manualmente durante un merge activo.


68. Inspeccionar los marcadores de conflicto

Un archivo en conflicto puede contener:

<<<<<<< HEAD
tu versión
=======
versión entrante
>>>>>>> branch-name

Resuelve el código que realmente se pretende, elimina los marcadores y luego prepara el archivo:

git add path/to/file

No elijas a ciegas «ours» o «theirs» sin entender el cambio.


69. Usar reflog para recuperar el historial local

git reflog

Esto muestra los movimientos recientes de HEAD y de las referencias de rama en el repositorio local.

Suele ser útil después de:

  • un reset accidental
  • un rebase
  • la eliminación de una rama
  • errores con checkout/switch

Ejemplo de flujo de recuperación:

git reflog
git show <old-commit>

Después, crea una rama de recuperación:

git switch -c recovery <old-commit>

70. Crear una rama de seguridad antes de editar historial local con riesgo

Antes de un rebase/reset complicado:

git branch backup-before-rewrite

Luego continúa.

Es un seguro barato cuando manipulas historial local no publicado.

Qué significa el resultado

Comando ¿Cambia archivos/historial? Uso típico
git status No Inspeccionar el estado
git diff No Revisar cambios sin preparar
git diff --cached No Revisar cambios preparados
git add Área de preparación Seleccionar el contenido del commit
git commit Historial Crear un commit
git fetch Referencias remotas Inspeccionar actualizaciones remotas de forma segura
git pull --ff-only Rama/archivos Avanzar la rama local solo con fast-forward
git rebase Historial Volver a aplicar commits locales
git merge Historial Combinar historiales
git restore Árbol de trabajo/índice Restaurar el contenido o estado de un archivo
git revert Historial Invertir de forma segura un commit compartido
git reset Rama/índice/archivos según el modo Reescribir el estado o historial local
git stash Stash + árbol de trabajo Apartar trabajo temporalmente
git reflog No Recuperar el historial local de referencias

La distinción importante es:

comandos de inspección
→ riesgo bajo

comandos de árbol de trabajo/área de preparación
→ pueden cambiar el estado sin confirmar

comandos que reescriben el historial
→ exigen saber si los commits ya están compartidos

Qué revisar

git status muestra cambios preparados y sin preparar en el mismo archivo

Preparaste una versión y luego volviste a editar el archivo.

Revisa ambos:

git diff --cached
git diff

antes de hacer commit.

El push es rechazado

La rama remota tiene trabajo que tú no tienes.

Ejecuta:

git fetch origin

y luego inspecciona:

git log --oneline --graph --decorate HEAD origin/<branch>

No pases directamente a un push forzado.

El commit contiene archivos no relacionados

Usa:

git restore --staged <file>

y vuelve a hacer commit solo con el alcance previsto.

El merge o el rebase generó conflictos

Determina si ambas ramas cambiaron el mismo código lógico.

Resuelve según el comportamiento previsto, no eligiendo un lado de forma mecánica.

Perdiste un commit local después de un reset/rebase

Revisa:

git reflog

antes de dar por hecho que ha desaparecido.

La rama de funcionalidad contiene commits inesperados

Compárala con main:

git log --oneline origin/main..HEAD

e inspecciona el grafo.

Notas de producción

El historial compartido debe tratarse como inmutable por defecto

Una vez que se ha hecho push de los commits y otros los usan, prefiere:

git revert

en lugar de reescribir el historial.

Las ramas de funcionalidad de un solo desarrollador suelen ser lugares más seguros para flujos con rebase/amend.

--force-with-lease es más seguro, no está libre de riesgo

Te protege de sobrescribir actualizaciones remotas que no has visto.

Aun así, reescribe intencionadamente el historial remoto.

Git no protege automáticamente el trabajo sin confirmar frente a todos los comandos

Comandos como:

git restore
git reset --hard

pueden descartar cambios locales.

Inspecciona primero.

Un árbol de trabajo limpio simplifica las operaciones arriesgadas

Antes de un rebase, un merge o una cirugía de ramas:

git status

Haz commit o stash del trabajo no relacionado.

Los commits pequeños y enfocados facilitan la recuperación

Los commits enfocados facilitan:

  • revisar
  • hacer revert
  • hacer cherry-pick
  • hacer bisect
  • entender el historial

No combines refactorizaciones no relacionadas con cambios de comportamiento salvo que haya una buena razón.

El historial de Git forma parte de la ingeniería de producción

Los identificadores de commit suelen aparecer en:

  • despliegues
  • CI/CD
  • cronologías de incidentes
  • notas de versión
  • reversiones

Haz commits significativos y evita reescribir sin necesidad el historial compartido.

Errores comunes

1. Ejecutar git add . sin revisar el estado

Puedes preparar archivos no relacionados, archivos generados o secretos.

2. Hacer commit sin revisar git diff --cached

El commit puede contener más o menos de lo previsto.

3. Usar git pull sin entender la estrategia configurada

Según la configuración, pull puede hacer merge o rebase.

Para ramas main locales protegidas, git pull --ff-only suele ser más predecible.

4. Usar git push --force

Prefiere --force-with-lease cuando reescribir tu propia rama remota sea realmente necesario.

5. Usar git reset --hard como limpieza general

Puede descartar de forma permanente cambios rastreados sin confirmar.

6. Hacer amend de commits ya compartidos con compañeros

Esto cambia los identificadores de commit y puede afectar a sus ramas.

7. Eliminar una rama sin revisar sus commits exclusivos

Inspecciona:

git log main..branch-name

primero.

8. Tratar git stash como almacenamiento permanente

Los stashes son instantáneas temporales del estado de trabajo, no una estrategia de ramas duradera.

9. Usar git blame para buscar culpables

Úsalo para encontrar contexto histórico y commits relevantes.

10. Suponer que un push rechazado obliga a hacer push forzado

Normalmente significa que primero debes hacer fetch y entender los cambios remotos.

Siguiente paso

Usa la situación para elegir el siguiente comando.

  • No tienes claro qué cambió → git status, git diff, git diff --cached.
  • Necesitas una rama de funcionalidad nueva → git switch -c <branch>.
  • Necesitas un commit enfocado → git add -p y luego git diff --cached.
  • Necesitas el último estado remoto sin cambiar los archivos locales → git fetch.
  • Necesitas actualizar main local de forma segura → git pull --ff-only.
  • Necesitas la rama de funcionalidad sobre el último main → haz rebase o merge según la política del equipo.
  • Push rechazado → haz fetch e inspecciona la divergencia antes de decidir.
  • Necesitas deshacer un commit compartido → git revert.
  • Necesitas corregir el último commit no compartido → git commit --amend.
  • Necesitas apartar trabajo temporalmente → git stash push.
  • Crees que perdiste un commit local → inspecciona git reflog.
  • Necesitas flujos más avanzados de ramas/historial → pasa a Ramas y merge, Referencia rápida de rebase, Deshacer cambios de forma segura o Git stash: guardar cambios temporalmente.

← Todas las guías rápidas