Git squash: qué es y cómo juntar varios commits en uno
Qué es git squash, las cuatro formas de juntar commits en uno (merge --squash, rebase -i, reset --soft y el botón de GitHub) y qué se rompe después.
Hacer squash en Git es combinar varios commits en uno solo: el código final queda exactamente igual, pero los pasos intermedios (los “wip” y los “ahora sí”) desaparecen del historial de la rama donde lo integras. Es como entregar la versión final de un trabajo en lugar de la carpeta con todos los borradores.
Para seguir esto necesitas saber qué es un commit (si no, empieza por qué es un commit en Git) y haber trabajado alguna vez con una rama. Todos los comandos de abajo los ejecuté con Git 2.43 en un repositorio de prueba, en una sola sesión, así que los hashes coinciden de principio a fin.
Qué le pasa a tu historial cuando haces squash
Partimos de esto: una rama feature/login con tres commits, una rama feature/perfil que un compañero sacó de la mía y en la que añadió una línea a login.js, y main, que ha avanzado por su cuenta con un commit de documentación.
git log --oneline --graph --decorate --all # todas las ramas, en forma de grafo
* b4a1e3b (feature/perfil) carga el perfil al entrar
* 0501199 (feature/login) ahora sí
* a3da8dd wip
* 22a0739 añade login
| * c65563c (HEAD -> main) documenta la instalación
|/
* a41e61b Primer commit
Tres commits para una sola idea: el primero crea login.js, el segundo deja un comentario a medias y “ahora sí” lo limpia y renombra check a checkUser. Al hacer squash, main recibe un único commit nuevo con el resultado de los tres. Ese commit tiene un hash propio y un solo padre (el último de main), así que no es un commit de fusión: Git no guarda ninguna conexión entre él y los commits originales de la rama.
Esa última frase parece un detalle. Es la causa de casi todos los sustos que vienen después.
Las cuatro formas de hacer squash
Todas acaban en un commit en lugar de varios; cambia dónde ocurre.
1. git merge —squash: aplastar al integrar
Estás en main y quieres traer feature/login como un solo commit:
git merge --squash feature/login # prepara los cambios, NO crea commit
git status --short # qué ha quedado preparado
git commit -m "Login de usuarios" # ahora sí, el commit único
Automatic merge went well; stopped before committing as requested
Squash commit -- not updating HEAD
A login.js
[main 5624ef4] Login de usuarios
1 file changed, 3 insertions(+)
create mode 100644 login.js
--squash deja los cambios preparados y se para. La documentación de git merge lo describe así: produce el estado de los ficheros “como si hubiera ocurrido un merge real”, pero sin hacer el commit ni mover HEAD[1]. Si haces el commit sin -m, Git te propone un mensaje que empieza por Squashed commit of the following: con la lista de commits aplastados.
El historial resultante:
* b4a1e3b (feature/perfil) carga el perfil al entrar
* 0501199 (feature/login) ahora sí
* a3da8dd wip
* 22a0739 añade login
| * 5624ef4 (HEAD -> main) Login de usuarios
| * c65563c documenta la instalación
|/
* a41e61b Primer commit
Fíjate en que las dos líneas no se unen. En un merge normal verías un commit con dos padres cerrando la bifurcación. Aquí no.
2. git rebase -i con squash o fixup: limpiar tu rama antes de la PR
Este es el squash que haces sobre tu propia rama, antes de enseñarla. En mi repositorio, la rama feature/ajustes tenía dos commits:
git log --oneline main.. # mis commits que no están en main
6e2d952 typo
9accf73 ajustes
git rebase -i main abre una lista con esos commits (del más antiguo al más nuevo, al revés que git log) y cambias pick por fixup (o squash) en los commits que quieres fundir con el de arriba:
pick 9accf73 ajustes
fixup 6e2d952 typo
Al guardar, git log --oneline main.. mostraba un solo commit, 14cb62f ajustes. La diferencia entre las dos palabras es solo el mensaje: squash te deja combinar los mensajes y fixup se queda con el del commit de arriba. El editor tiene más comandos y trampas propias, y los tienes explicados con un ejemplo completo en la guía de git rebase interactivo.
3. git reset —soft: la vía rápida para juntar los últimos commits
Si lo que quieres es “todo lo de esta rama, en un commit”, hay un atajo sin editor. reset --soft mueve la rama hacia atrás pero deja tus ficheros y el área de preparación tal cual[2], así que el siguiente commit lo recoge todo:
git log --oneline main.. # mis commits que no están en main
git reset --soft main # vuelvo a la base, sin tocar ficheros
git commit -m "Añade logout"
git log --oneline main..
6778cf1 fix 2
3fd8be3 fix
16f523f logout
[feature/logout 9bee3a8] Añade logout
1 file changed, 4 insertions(+)
create mode 100644 logout.js
9bee3a8 Añade logout
Aquí funcionó porque main no se había movido desde que creé la rama. Si main ha avanzado, git reset --soft main es una trampa: el commit nuevo incluiría, además de lo tuyo, la eliminación de todo lo que main ha recibido mientras tanto. Lo comprobé en otro repositorio de prueba y git status mostraba un D (borrado) sobre un fichero que solo existía en main. Para no depender de eso, usa el punto donde nació tu rama:
# $(...) ejecuta el comando de dentro y pone su resultado (un hash) en su lugar.
# Es sintaxis de bash y zsh; en PowerShell o cmd no funciona igual: ejecuta antes
# git merge-base main HEAD y pega el hash que te devuelva.
git reset --soft $(git merge-base main HEAD) # base común con main
4. El botón “Squash and merge” de GitHub
Al cerrar una pull request (la petición para integrar tu rama; aquí tienes qué es una pull request), GitHub ofrece “Squash and merge”. Según su documentación, junta todos los commits de la PR en uno solo sobre la rama base y genera un mensaje por defecto que puedes editar[3]. Es el merge --squash de la forma 1, pero hecho en el servidor. En GitLab, se hace con la casilla “Squash commits” de la merge request (según cómo esté configurado el proyecto, GitLab añade además un commit de merge)[5].
| Forma | Dónde ocurre | Cuándo usarla |
|---|---|---|
git merge --squash + git commit | En local, en la rama que recibe | Integras tú, sin plataforma de por medio |
git rebase -i con squash/fixup | En tu rama | Quieres dejar varios commits limpios, no necesariamente uno |
git reset --soft <base> + commit | En tu rama | Quieres todo en un commit, ya |
| Botón “Squash and merge” | En GitHub, al cerrar la PR | Tu equipo integra así todas las PR |
Hasta aquí llega lo que cuentan casi todos los tutoriales. Lo interesante empieza cuando vuelves a tu terminal después del squash.
Lo que se rompe después de un squash
Git cree que tu rama no está fusionada
Con el login ya en main, intento borrar la rama como haría con cualquier rama integrada:
git branch -d feature/login # borrado "seguro"
git diff main feature/login -- login.js
error: the branch 'feature/login' is not fully merged.
If you are sure you want to delete it, run 'git branch -D feature/login'
El diff no imprimió nada: el contenido de login.js es idéntico en las dos ramas. Pero -d no mira el contenido: comprueba que los commits de la rama estén en su upstream (la rama remota que sigue, si tiene una) o, si no tiene, en HEAD[4]. feature/login nunca se subió, así que Git mira en main, y ninguno de sus commits está allí. Está su resultado, que no es lo mismo.
Con una rama que sí subiste y que se integró con “Squash and merge” en GitHub, depende de si su rama remota sigue existiendo. Si sigue, -d compara contra ella, ve que tiene los mismos commits y borra tu rama local con un aviso (merged to 'refs/remotes/origin/...', but not yet merged to HEAD). Si ya se borró en GitHub y has hecho git fetch --prune (que limpia de tu copia las ramas remotas que ya no existen), su upstream deja de existir (git branch -vv lo marca como gone), Git vuelve a comparar con HEAD y te da el mismo error de arriba. Lo comprobé con un remoto de prueba en local y pasa exactamente así. Cuando has comprobado que el contenido está en main, -D es la respuesta correcta. Lo que no conviene es acostumbrarte a -D sin mirar, porque ese mismo mensaje es el que te avisa cuando de verdad tienes trabajo sin integrar.
La rama que salió de la tuya hereda conflictos
feature/perfil nació encima de los tres commits del login. Mi compañero quiere ponerse al día con main:
git switch feature/perfil
git merge main
Auto-merging login.js
CONFLICT (add/add): Merge conflict in login.js
Automatic merge failed; fix conflicts and then commit the result.
Su rama trae login.js de los commits originales del login, más su línea nueva. main lo trae del commit aplastado, que no recuerda de qué commits viene. Así que Git no puede saber que los dos parten del mismo código: ve dos commits sin relación que crean el mismo fichero, uno con la línea de loadProfile y otro sin ella, y te pide que elijas. La documentación de GitHub avisa de lo mismo: si sigues trabajando sobre una rama después de un squash merge, las siguientes PR pueden incluir commits que ya se aplastaron y es más fácil que aparezcan conflictos[3].
La salida limpia es reaplicar solo los commits propios de feature/perfil encima de main, saltándose los del login (aquí uso --onto, una opción de rebase que dice exactamente desde dónde copiar; si no tienes claro qué hace git rebase, empieza por ahí):
git merge --abort # descarto el merge a medias
# reaplica lo que hay entre feature/login y feature/perfil, encima de main
git rebase --onto main feature/login feature/perfil
git log --oneline --graph --decorate main feature/perfil
Successfully rebased and updated refs/heads/feature/perfil.
* afa155b (HEAD -> feature/perfil) carga el perfil al entrar
* 5624ef4 (main) Login de usuarios
* c65563c documenta la instalación
* a41e61b Primer commit
Ojo con el orden: necesitas feature/login (o el hash de su último commit, 0501199) para decirle a Git dónde empiezan los commits de tu compañero. Si borras la rama antes, apunta el hash. Solo entonces tocaba el git branch -D feature/login, que respondió Deleted branch feature/login (was 0501199).
blame y bisect pierden detalle
git blame te dice qué commit escribió cada línea. Después del squash, mirando el fichero tal como está en main:
git blame main -- login.js
5624ef4e (Ana 2026-11-16 10:00:00 +0100 1) function login(user) {
5624ef4e (Ana 2026-11-16 10:00:00 +0100 2) return checkUser(user)
5624ef4e (Ana 2026-11-16 10:00:00 +0100 3) }
Todo viene del mismo commit: el paso en que check pasó a ser checkUser ya no está en main. (En feature/perfil, después del rebase, la línea de loadProfile saldría con afa155b, el commit de tu compañero.) Con git bisect, que busca qué commit introdujo un bug probando commits del historial, pasa lo mismo: como mucho llega a señalar el commit aplastado entero. En una PR pequeña da igual; en una enorme, es mucho donde buscar.
Cuándo no conviene hacer squash
No aplastes una rama compartida. Las formas 2 y 3 reescriben commits de tu rama, y si otra persona ya los tiene en su copia, la dejas con una historia que no coincide con la del servidor. Las formas 1 y 4 no reescriben nada que ya exista, pero producen el problema de feature/perfil que acabas de ver.
Tampoco merece la pena cuando cada commit de la rama cuenta algo por sí solo: una migración de base de datos y el código que la usa, en commits separados, son dos puntos que puedes revertir por separado. Aplastarlos te quita esa opción. Y si una rama vive semanas y se integra varias veces, un squash por integración acaba en conflictos repetidos.
Squash vs merge vs rebase
Las tres integran una rama, pero dejan historiales distintos. El squash crea un commit nuevo con un solo padre, y los commits originales no llegan a main. El merge crea un commit de fusión con dos padres y conserva todos los commits de la rama. El rebase reaplica cada commit uno a uno encima de main, con hashes nuevos.
Al integrar una PR casi nunca decides tú: manda la convención del equipo, y las tres opciones (con la regla de no reescribir lo compartido) están comparadas en merge vs rebase y qué convención adoptar. Lo que sí decides es limpiar tu rama antes de pedir revisión.
Cómo deshacer un squash
Depende de la forma que usaste. Con merge --squash o el botón de GitHub, tu rama sigue intacta: lo que sobra es el commit nuevo en main. Si ya lo subiste, git revert <hash> crea un commit que invierte sus cambios sin reescribir nada; si todavía no lo has subido, git reset --hard HEAD~1 lo quita.
Con las formas 2 y 3 los commits originales parecen desaparecer, pero no se borran en el momento: quedan accesibles en el reflog, el registro de por dónde ha pasado tu rama. Con el squash de feature/logout de antes:
git reflog -4 # últimas posiciones de HEAD
git reset --hard HEAD@{2} # vuelvo a la de antes del reset
git log --oneline main..
9bee3a8 HEAD@{0}: commit: Añade logout
5624ef4 HEAD@{1}: reset: moving to main
6778cf1 HEAD@{2}: commit: fix 2
3fd8be3 HEAD@{3}: commit: fix
HEAD is now at 6778cf1 fix 2
6778cf1 fix 2
3fd8be3 fix
16f523f logout
Los tres commits han vuelto. reset --hard descarta lo que tengas sin guardar, así que úsalo con el árbol de trabajo limpio. Cómo leer el reflog sin perderte está en git reflog como red de seguridad.
Fuentes
- git-merge, opción —squash (documentación de Git en git/git) respalda que
--squashprepara el resultado sin crear commit, sin moverHEADy sin registrarMERGE_HEAD. - git-reset, opción —soft (documentación de Git en git/git) respalda que
--softdeja ficheros e índice intactos y el ejemplogit reset --soft HEAD~5; git commitpara juntar commits. - About pull request merges (documentación de GitHub) respalda cómo funciona “Squash and merge”, su mensaje por defecto editable y el aviso sobre seguir trabajando en una rama tras un squash merge.
- git-branch, opción -d (documentación de Git en git/git) respalda que
-dexige que la rama esté completamente fusionada en su upstream, o enHEADsi no tiene upstream, y que-Des--delete --force. - Squash and merge (documentación de GitLab) respalda la casilla “Squash commits” de las merge requests.
Preguntas Frecuentes
¿Hacer squash cambia mi código?
No. El commit aplastado contiene exactamente el mismo resultado final; solo cambia cuántos commits lo cuentan.
¿Tengo que hacer squash antes de abrir la PR si mi equipo usa “Squash and merge”?
No hace falta, porque el botón ya lo junta todo al final. Lo que sí ayuda es que los commits de la PR tengan mensajes legibles mientras se revisa, ya que el revisor los ve uno a uno. Además, según la configuración del repositorio y cuántos commits tenga la PR, el mensaje por defecto del squash puede incluir la información de esos commits[3]: commits legibles te dan un commit final legible.
¿Es lo mismo squash que git commit —amend?
Se parecen, pero --amend solo rehace el último commit (por ejemplo, para añadirle un fichero olvidado). Squash junta varios commits ya hechos. Si te ves encadenando --amend, estás haciendo squash sobre la marcha.
¿Por qué git branch —merged no muestra mi rama si ya está en main?
Por lo mismo que falla git branch -d: esa lista solo incluye ramas cuyos commits están en main, y tras un squash los suyos no están. Para saber si su contenido ya llegó, compara los ficheros que tocó la rama, como hice arriba con git diff main feature/login -- login.js. Si no sale nada (y nadie los ha vuelto a cambiar en main), el contenido está.
Si quieres practicar squash, rebase y el resto del flujo de ramas con ejercicios en lugar de leerlo, el curso Git de cero a profesional recorre todo ese camino.