Squash my last X commits together usando Git

Puedes hacer esto fácilmente sin git rebase o git merge --squash. En este ejemplo, aplastaremos las últimas 3 confirmaciones.

Si desea escribir el nuevo mensaje de confirmación desde cero, esto es suficiente:

git reset --soft HEAD~3 &&
git commit

Si desea comenzar a editar el nuevo mensaje de confirmación con una concatenación de los mensajes de confirmación existentes (es decir, similar a lo que una lista de instrucciones de pick/squash/squash/squash/squash git rebase -i lo iniciaría), entonces necesita extraer esos mensajes y pasarlos a git commit:

git reset --soft HEAD~3 && 
git commit --edit -m"$(git log --format=%B --reverse HEAD..HEAD@{1})"

Ambos métodos aplastan las últimas tres confirmaciones en una única confirmación nueva de la misma manera. El restablecimiento suave solo re-apunta la CABEZA a la última confirmación que no desea aplastar. Ni el índice ni el árbol de trabajo son tocados por el restablecimiento suave, dejando el índice en el estado deseado para su nueva confirmación (es decir, ya tiene todos los cambios de las confirmaciones que está a punto de "tirar").

Puedes usar git merge --squash para esto, que es un poco más elegante que git rebase -i. Supongamos que estás en master y quieres aplastar los últimos 12 commits en uno.

ADVERTENCIA: Primero asegúrese de confirmar su trabajo-compruebe que git status está limpio (ya que git reset --hard desechará los cambios por etapas y los no escalonados)

Entonces:

# Reset the current branch to the commit just before the last 12:
git reset --hard HEAD~12

# HEAD@{1} is where the branch was just before the previous command.
# This command sets the state of the index to be as it would just
# after a merge from that commit:
git merge --squash HEAD@{1}

# Commit those squashed changes.  The commit message will be helpfully
# prepopulated with the commit messages of all the squashed commits:
git commit

La documentación para git merge describe la opción --squash con más detalle.

Actualización: la única ventaja real de este método sobre lo más simple git reset --soft HEAD~12 && git commit sugerido por Chris Johnsen en su respuesta es que obtienes el mensaje de confirmación pre-llenado con cada mensaje de confirmación que estás aplastando.

Recomiendo evitar git reset cuando sea posible especially especialmente para los principiantes de Git. A menos que realmente necesites automatizar un proceso basado en un número de commits, hay una forma menos exótica...

1. Poner las confirmaciones a ser aplastadas en una rama de trabajo (si aún no lo están) use usar gitk para esto
2. Echa un vistazo a la rama de destino (por ejemplo, 'master')
3. git merge --squash (working branch name)
4. git commit

El mensaje de confirmación se rellenará previamente en función del squash.

Basado en la respuesta de Chris Johnsen ,

Agregue un alias global de "squash" desde bash: (o Git Bash en Windows)

git config --global alias.squash '!f(){ git reset --soft HEAD~${1} && git commit --edit -m"$(git log --format=%B --reverse HEAD..HEAD@{1})"; };f'

... o usando el símbolo del sistema de Windows:

git config --global alias.squash "!f(){ git reset --soft HEAD~${1} && git commit --edit -m\"$(git log --format=%B --reverse HEAD..HEAD@{1})\"; };f"

Su ~/.gitconfig ahora debe contener este alias:

[alias]
    squash = "!f(){ git reset --soft HEAD~${1} && git commit --edit -m\"$(git log --format=%B --reverse HEAD..HEAD@{1})\"; };f"

Uso:

git squash N

... Que automáticamente comprime las últimas confirmaciones N, inclusive.

Nota: El mensaje de confirmación resultante es una combinación de todas las confirmaciones aplastadas, en orden. Si usted es insatisfecho con eso, siempre puede git commit --amend modificarlo manualmente. (O bien, edite el alias para que coincida con sus gustos.)

Gracias a esta práctica entrada de blog Encontré que puedes usar este comando para aplastar las últimas 3 confirmaciones:

git rebase -i HEAD~3

Esto es útil, ya que funciona incluso cuando está en una rama local sin información de seguimiento/repositorio remoto.

El comando abrirá el editor de rebase interactivo que luego le permite reordenar, aplastar, reformular, etc. como es normal.

Usando el editor de rebase interactivo:

El editor de rebase interactivo muestra tres últimos commits. Esta restricción fue determinada por HEAD~3 al ejecutar el comando git rebase -i HEAD~3.

La confirmación más reciente, HEAD, se muestra primero en la línea 1. Las líneas que comienzan con # son comentarios/documentación.

La documentación mostrada es bastante clara. En cualquier línea puede cambiar el comando de pick a un comando de su elección.

Prefiero usar el comando fixup ya que esto "aplasta" los cambios del commit en el commit en la línea anterior y descarta el mensaje del commit.

Como la confirmación en la línea 1 es HEAD, en la mayoría de los casos lo dejarías como pick. No puedes usar squash o fixup ya que no hay otro commit en el que aplastar el commit.

Si usa TortoiseGit, puede usar la función Combine to one commit:

1. Abra el menú contextual de TortoiseGit
2. Seleccione Show Log
3. Marque las confirmaciones relevantes en la vista de registro
4. Seleccione Combine to one commit desde el menú contextual

Esta función ejecuta automáticamente todos los pasos individuales necesarios de git. Desafortunadamente solo disponible para Windows.

Basado en este artículo encontré este método más fácil para mi caso de uso.

Mi rama 'dev' estaba por delante de 'origin/dev' por 96 commits (así que estos commits no fueron empujados al remoto todavía).

Quería aplastar estos commits en uno antes de impulsar el cambio. Prefiero restablecer la rama al estado de 'origin/ dev '(esto dejará todos los cambios de las 96 confirmaciones sin escalonar) y luego confirmar los cambios a la vez:

git reset origin/dev
git add --all
git commit -m 'my commit message'

1) Identificar el hash corto del commit

# git log --pretty=oneline --abbrev-commit
abcd1234 Update to Fix for issue B
cdababcd Fix issue B
deab3412 Fix issue A
....

Aquí incluso git log --oneline también se puede usar para obtener hash corto.

2) Si quieres aplastar (fusionar) los dos últimos commit

# git rebase -i deab3412 

3) Esto abre un editor nano para fusionar. Y se ve como abajo

....
pick cdababcd Fix issue B
pick abcd1234 Update to Fix for issue B
....

4) Cambie el nombre de la palabra pick a squash que está presente antes de abcd1234. Después de renombrar debe ser como a continuación.

....
pick cdababcd Fix issue B
squash abcd1234 Update to Fix for issue B
....

5) Ahora guarde y cierre el editor nano. Pulse ctrl + o y pulse Enter para guardar. Y luego pulse ctrl + x para salir del editor.

6) Luego nano el editor se abre nuevamente para actualizar los comentarios, si es necesario actualizarlo.

7) Ahora que se ha aplastado con éxito, puede verificarlo revisando los registros.

# git log --pretty=oneline --abbrev-commit
1122abcd Fix issue B
deab3412 Fix issue A
....

8) Ahora empuja a repo. Nota para agregar el signo + antes del nombre de la rama. Esto significa empuje forzado.

# git push origin +master

Nota : Esto se basa en usar git en ubuntu shell. Si está utilizando sistemas operativos diferentes (Windows o Mac), los comandos anteriores son los mismos excepto editor. Usted podría consigue un editor diferente.

Para hacer esto puedes usar el siguiente comando de git.

 git rebase -i HEAD~n

N(=4 aquí) es el número de la última confirmación. Luego tienes las siguientes opciones,

pick 01d1124 Message....
pick 6340aaa Message....
pick ebfd367 Message....
pick 30e0ccb Message....

Actualizar como abajo,

p 01d1124 Message....
s 6340aaa Message....
s ebfd367 Message....
s 30e0ccb Message....

Para más detalles, haga clic en Enlace

¡Buena suerte!!

Si estás en una rama remota (llamada feature-branch) clonada desde un Repositorio Dorado (golden_repo_name), entonces esta es la técnica para aplastar tus commits en uno:

1. Checkout the golden repo

   git checkout golden_repo_name
   

2. Crea una nueva rama a partir de ella(repo dorado) de la siguiente manera

   git checkout -b dev-branch
   

3. Squash fusionar con su rama local que ya tiene

   git merge --squash feature-branch
   

4. Commit tus cambios (este será el único commit que entra dev-branch)

   git commit -m "My feature complete"
   

5. Envía la rama a tu repositorio local

   git push origin dev-branch
   

Anomies answer es bueno, pero me sentí inseguro sobre esto, así que decidí agregar un par de capturas de pantalla.

Paso 0: git log

Mira dónde estás con git log. Lo más importante es encontrar el hash de confirmación de la primera confirmación que no quieres aplastar. Así que solo el :

Paso 1: git rebase

Ejecutar git rebase -i [your hash], en mi caso:

$ git rebase -i 2d23ea524936e612fae1ac63c95b705db44d937d

Paso 2: elige / squash lo que quieres

En mi caso, quiero aplastar todo en el commit que fue el primero en el tiempo. El orden es de primero a último, así que exactamente al revés como en git log. En mi caso, quiero:

Paso 3: Ajustar mensaje(s)

Si has elegido solo un commit y aplastado el resto, puedes ajustar un mensaje de commit:

Eso es todo. Una vez que guardes esto (:wq), habrás terminado. Échale un vistazo con git log.

Esto es super-duper kludgy, pero de una manera genial, así que lo lanzaré al ring:

GIT_EDITOR='f() { if [ "$(basename $1)" = "git-rebase-todo" ]; then sed -i "2,\$s/pick/squash/" $1; else vim $1; fi }; f' git rebase -i foo~5 foo

Traducción: proporcionar un nuevo "editor" para git que, si el nombre de archivo a editar es git-rebase-todo (el símbolo de cambio interactivo) cambia todo menos el primer "pick" a "squash", y de lo contrario genera vim - de modo que cuando se le solicite editar el mensaje de confirmación aplastado, obtendrá vim. (Y obviamente estaba aplastando las últimas cinco confirmaciones en la rama foo, pero podrías cambiar eso sin importar cómo como.)

Probablemente haría lo que Mark Longair sugirió, sin embargo.

Si quieres aplastar cada commit en un solo commit (por ejemplo, cuando publicas un proyecto por primera vez), prueba:

git checkout --orphan <new-branch>
git commit

Lo que puede ser realmente conveniente: Encuentra el hash de confirmación que quieres aplastar encima; digamos que es d43e15 Ahora use

git reset d43e15

git commit -am 'new commit name'

Creo que la forma más fácil de hacer esto es haciendo una nueva rama de master y haciendo un merge squash squash de la rama feature.

git checkout master
git checkout -b feature_branch_squashed
git merge --squash feature_branch

Entonces tienes todos los cambios listos para confirmar.

Creo que una solución más genérica no es especificar 'N' commits, sino más bien el branch/commit-id sobre el que desea aplastar. Esto es menos propenso a errores que contar los commits hasta un commit específico - solo especifica la etiqueta directamente, o si realmente quieres contar puedes especificar HEAD~N.

En mi flujo de trabajo, inicio una rama, y mi primer commit en esa rama resume el objetivo (es decir, generalmente es lo que enviaré como el mensaje 'final' para la característica al repositorio público.) Tan cuando haya terminado, todo lo que quiero hacer es git squash master volver al primer mensaje y luego estoy listo para empujar.

Utilizo el alias:

squash = !EDITOR="\"_() { sed -n 's/^pick //p' \"\\$1\"; sed -i .tmp '2,\\$s/^pick/f/' \"\\$1\"; }; _\"" git rebase -i

Esto volcará el historial que se está aplastando antes de que lo haga-esto le da la oportunidad de recuperarse al agarrar un ID de confirmación antiguo de la consola si desea revertir. (Los usuarios de Solaris notan que usa la opción GNU sed -i, los usuarios de Mac y Linux deberían estar de acuerdo con esto.)

En cuestión podría ser ambiguo lo que se entiende por "último".

Por ejemplo git log --graph se obtiene lo siguiente (simplificado):

* commit H0
|
* merge
|\
| * commit B0
| |
| * commit B1
| | 
* | commit H1
| |
* | commit H2
|/
|

Entonces las últimas confirmaciones por tiempo son H0, merge, B0. Para aplastarlos tendrás que rebase tu rama fusionada en la confirmación H1.

El problema es que H0 contiene H1 y H2 (y generalmente más confirmaciones antes de la fusión y después de la bifurcación), mientras que B0 no. Por lo tanto, debe administrar los cambios de H0, merge, H1, H2, B0 al menos.

Es posible utilizar rebase pero de manera diferente entonces en otras respuestas mencionadas:

rebase -i HEAD~2

Esto le mostrará las opciones de elección (como se menciona en otras respuestas):

pick B1
pick B0
pick H0

Poner squash en lugar de pick a H0:

pick B1
pick B0
s H0

Después de guardar y salir, rebase aplicará confirmaciones a su vez después de H1. Eso significa que te pedirá que resuelvas conflictos de nuevo (donde HEAD será H1 al principio y luego acumulará confirmaciones a medida que se apliquen).

Después de rebase terminará usted puede elegir mensaje para H0 y B0 aplastados:

* commit squashed H0 and B0
|
* commit B1
| 
* commit H1
|
* commit H2
|

P.d. Si usted acaba de hacer algunos reset a BO: (por ejemplo, usando reset --mixed que se explica con más detalle aquí https://stackoverflow.com/a/18690845/2405850):

git reset --mixed hash_of_commit_B0
git add .
git commit -m 'some commit message'

Luego se squash en B0 cambios de H0, H1, H2 (perdiendo completamente confirmaciones de cambios después de la ramificación y antes de la fusión.

git rebase -i HEAD^^

Donde el número de ^ ' s es X

(en este caso, aplasta las dos últimas confirmaciones)

Echa un vistazo a esta esencia:

Gist-Easy git-squash

Tendrás que escribir, por ejemplo, git-squash 3 y eso es todo. Las últimas tres confirmaciones se fusionaron en una con sus mensajes concatenados.

Además de otras excelentes respuestas, me gustaría añadir cómo git rebase -i siempre me confunde con el orden de confirmación - ¿más antiguo a más nuevo o viceversa? Así que este es mi flujo de trabajo:

1. git rebase -i HEAD~[N], donde N es el número de confirmaciones a las que quiero unirme, comenzando por la más reciente. Así que git rebase -i HEAD~5 significaría "aplastar los últimos 5 commits en uno nuevo";
2. aparece el editor, mostrando la lista de confirmaciones que quiero fusionar. Ahora se muestran en orden inverso : los más antiguos commit está en la parte superior. Marque como "squash" o " s " todas las confirmaciones excepto la primera/anterior: se utilizará como punto de partida. Guardar y cerrar el editor;
3. el editor aparece de nuevo con un mensaje predeterminado para la nueva confirmación: cámbielo a sus necesidades, guárdelo y ciérrelo. Squash completado!

Fuentes y lecturas adicionales: #1, #2.

Para aplastar los últimos 10 commits en 1 commit simple:

git reset --soft HEAD~10 && git commit -m "squashed commit"

Si también desea actualizar la rama remota con la confirmación aplastada:

git push -f

En la rama en la que desea combinar las confirmaciones, ejecute:

git rebase -i HEAD~(n number of commits back to review)

Esto abrirá el editor de texto y debes cambiar el 'pick' delante de cada commit con 'squash' si quieres que estos commits se fusionen. Por ejemplo, si estás buscando fusionar todos los commits en uno, el 'pick' es el primer commit que hiciste y todos los futuros (colocados debajo del primero) deberían estar configurados como 'squash'. Si usa vim, use : x en el modo de inserción para guardar y salir del Editor.

Luego para terminar el rebase:

git rebase --continue

Para obtener más información sobre esta y otras formas de reescribir su historial de confirmaciones, consulte esta útil publicación

¿Qué hay de una respuesta a la pregunta relacionada con un flujo de trabajo como este?

1. muchas confirmaciones locales, mezcladas con múltiples fusiones DE master ,
2. finalmente un push a remoto,
3. PR y merge TO master por reviewer. (Sí, sería más fácil para el desarrollador merge --squash después del PR, pero el equipo pensó que eso ralentizaría el proceso.)

No he visto un flujo de trabajo como ese en esta página. (Esos pueden ser mis ojos.) Si entiendo rebase correctamente, las fusiones múltiples requerirían múltiples resoluciones de conflictos . ¡Ni siquiera quiero pensar en eso!

Por lo tanto, esto parece funcionar para nosotros.

1. git pull master
2. git checkout -b new-branch
3. git checkout -b new-branch-temp
4. editar y confirmar mucho localmente, fusionar maestro regularmente
5. git checkout new-branch
6. git merge --squash new-branch-temp / / pone todos los cambios en la etapa
7. git commit 'one message to rule them all'
8. git push
9. El revisor hace relaciones públicas y se fusiona con master.

Si estás usando GitUp, selecciona la confirmación que deseas fusionar con su padre y presiona S. Tienes que hacerlo una vez por cada commit, pero es mucho más sencillo que encontrar el encantamiento correcto de la línea de comandos. Especialmente si es algo que solo haces de vez en cuando.

Simplemente agregue esta función bash a su bash de.archivo zshrc.

# Squash last X commits with a Commit message.
# Usage: squash X 'COMMIT_MSG'
# where X= Number of last commits.
# where COMMIT_MSG= New commit msg.
function squash() {
    if [ -z "${1}" -o -z "${2}" ]; then
        echo "Usage: \`squash X COMMIT_MSG\`"
        echo "X= Number of last commits."
        echo "COMMIT_MSG= New commit msg."
        return 1
    fi

    git reset --soft HEAD~"$1"
    git add . && git ci -m "$2" # With 100 emoji
    git push --force
}

Entonces simplemente ejecuta

squash X 'New Commit Message'

Y ya está.

Otra forma de hacer esto si tienes un montón de commits es hacer una squash DESPUÉS de un commit como git rebase -i <hashbeforeyouwanttosquash>

Esto abrirá su editor para elegir/aplastar como de costumbre.

Véase https://git-scm.com/docs/git-rebase#_interactive_mode

Primero averiguo el número de confirmaciones entre mi rama feature y la rama master actual por

git checkout master
git rev-list master.. --count

Luego, creo otra rama basada en la rama my-feature, mantengo la rama my-feature intacta.

Por último, corro

git checkout my-feature
git checkout -b my-rebased-feature
git checkout master
git checkout my-rebased-feature
git rebase master
git rebase head^x -i
// fixup/pick/rewrite
git push origin my-rebased-feature -f // force, if my-rebased-feature was ever pushed, otherwise no need for -f flag
// make a PR with clean history, delete both my-feature and my-rebased-feature after merge

Espero que ayude, gracias.

Cambia a la rama master y asegúrate de estar actualizado:

sh git checkout master && git fetch && git pull

Fusiona tu rama feature en la rama master localmente:

sh git merge feature_branch

Restablece la rama maestra local al estado de origin:

sh git reset origin/master

Ahora todos sus cambios se consideran como cambios no escalonados. Puedes prepararlas y enviarlas a una o más confirmaciones.

sh git add . --all git commit