Explorar guías rápidas · Git
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
- Problema
- Respuesta rápida
- Código / comandos
- 1. Comprobar el estado actual del repositorio
- 2. Mostrar un estado compacto
- 3. Ver los cambios sin preparar
- 4. Ver los cambios preparados
- 5. Mostrar el contexto preparado y sin preparar
- 6. Crear una rama nueva y cambiar a ella
- 7. Cambiar a una rama existente
- 8. Listar las ramas locales
- 9. Renombrar la rama actual
- 10. Preparar un archivo
- 11. Preparar varios archivos conocidos
- 12. Preparar todos los cambios actuales
- 13. Preparar de forma interactiva
- 14. Quitar un archivo del área de preparación sin descartar sus cambios
- 15. Hacer commit de los cambios preparados
- 16. Inspeccionar el commit antes de hacer push
- 17. Corregir el commit local más reciente con amend
- 18. Traer las actualizaciones remotas sin cambiar tus archivos
- 19. Inspeccionar qué cambió en la rama main remota
- 20. Actualizar tu rama main local
- 21. Hacer rebase de una rama de funcionalidad sobre main actualizada
- 22. Hacer merge de main en la rama de funcionalidad
- 23. Hacer push de una rama nueva
- 24. Hacer push de commits posteriores
- 25. Preferir force-with-lease a force
- 26. No hacer nunca push forzado a la ligera en ramas compartidas y protegidas
- 27. Ver el historial reciente
- 28. Mostrar los commits de un archivo
- 29. Ver quién cambió líneas concretas
- 30. Comparar tu rama con main
- 31. Comparar dos commits
- 32. Restaurar un archivo sin preparar a la última versión confirmada
- 33. Restaurar un archivo desde otro commit
- 34. Revertir un commit compartido de forma segura con revert
- 35. No confundir revert con reset
- 36. Mover HEAD hacia atrás manteniendo los cambios preparados
- 37. Mover HEAD hacia atrás manteniendo los cambios sin preparar
- 38. Evitar reset --hard salvo que estés seguro
- 39. Guardar temporalmente los cambios locales con stash
- 40. Hacer stash de archivos con y sin seguimiento
- 41. Listar los stashes
- 42. Inspeccionar un stash antes de aplicarlo
- 43. Aplicar un stash sin eliminarlo
- 44. Aplicar y eliminar un stash
- 45. Eliminar un stash de forma deliberada
- 46. Eliminar una rama local ya integrada con merge
- 47. Forzar la eliminación de una rama local solo de forma intencionada
- 48. Eliminar una rama remota
- 49. Ver los remotos configurados
- 50. Inspeccionar el seguimiento upstream
- 51. Configurar una rama upstream manualmente
- 52. Mostrar la raíz del repositorio
- 53. Mostrar el nombre de la rama actual
- 54. Mostrar el commit actual
- 55. Comprobar si el árbol de trabajo está limpio en automatizaciones
- 56. Hacer fetch y podar las ramas remotas eliminadas
- 57. Ver los commits exclusivos de tu rama
- 58. Ver los archivos cambiados respecto a main
- 59. Buscar en los mensajes de commit
- 60. Encontrar commits que cambiaron una cadena
- 61. Encontrar commits cuyo parche coincide con un patrón
- 62. Mostrar un commit
- 63. Hacer cherry-pick de un commit conocido
- 64. Abortar un cherry-pick con conflictos
- 65. Abortar un rebase
- 66. Continuar un rebase después de resolver conflictos
- 67. Abortar un merge
- 68. Inspeccionar los marcadores de conflicto
- 69. Usar reflog para recuperar el historial local
- 70. Crear una rama de seguridad antes de editar historial local con riesgo
- Qué significa el resultado
- Qué revisar
- git status muestra cambios preparados y sin preparar en el mismo archivo
- El push es rechazado
- El commit contiene archivos no relacionados
- El merge o el rebase generó conflictos
- Perdiste un commit local después de un reset/rebase
- La rama de funcionalidad contiene commits inesperados
- Notas de producción
- El historial compartido debe tratarse como inmutable por defecto
- --force-with-lease es más seguro, no está libre de riesgo
- Git no protege automáticamente el trabajo sin confirmar frente a todos los comandos
- Un árbol de trabajo limpio simplifica las operaciones arriesgadas
- Los commits pequeños y enfocados facilitan la recuperación
- El historial de Git forma parte de la ingeniería de producción
- Errores comunes
- 1. Ejecutar git add . sin revisar el estado
- 2. Hacer commit sin revisar git diff --cached
- 3. Usar git pull sin entender la estrategia configurada
- 4. Usar git push --force
- 5. Usar git reset --hard como limpieza general
- 6. Hacer amend de commits ya compartidos con compañeros
- 7. Eliminar una rama sin revisar sus commits exclusivos
- 8. Tratar git stash como almacenamiento permanente
- 9. Usar git blame para buscar culpables
- 10. Suponer que un push rechazado obliga a hacer push forzado
- Siguiente paso
- 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.
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.