¿Cómo modificar las confirmaciones existentes sin flujo?

Escribí lo incorrecto en un post de compromiso. Alternativamente, he olvidado include algunos files.

¿Cómo puedo cambiar los posts / files de confirmación? La confirmación no se ha enviado aún.

Enmendar el post de confirmación más reciente

git commit --amend 

abrirá su editor, lo que le permite cambiar el post de confirmación de la confirmación más reciente. Además, puede establecer el post de confirmación directamente en la línea de command con:

 git commit --amend -m "New commit message" 

… sin embargo, esto puede hacer que los posts de compromiso de varias líneas o pequeñas correcciones sean más engorrosos de ingresar.

Asegúrese de que no haya realizado cambios en la copy de trabajo antes de hacer esto o se comprometerán también. (Los cambios sin escena no se comprometerán).

Cambiar el post de una confirmación que ya ha enviado a su twig remota

Si ya has empujado tu confirmación a la twig remota, deberás forzar la inserción de la confirmación con:

 git push <remote> <branch> --force # Or git push <remote> <branch> -f 

Advertencia: el empuje forzado sobrescribirá la twig remota con el estado de la suya local . Si hay confirmaciones en la sucursal remota que no tiene en su sucursal local, perderá esas confirmaciones.

Advertencia: tenga cuidado al modificar las confirmaciones que ya ha compartido con otras personas. Enmendar confirmaciones esencialmente las reescribe para tener diferentes ID de SHA , lo que plantea un problema si otras personas tienen copys de la antigua confirmación que ha reescrito. Cualquiera que tenga una copy de la confirmación anterior deberá sincronizar su trabajo con la confirmación recién reescrita, lo que a veces puede ser difícil, así que asegúrese de coordinarse con los demás cuando intente reescribir el historial de commit compartido, o simplemente evite reescribir las confirmaciones compartidas en total.


Use rebase interactivo

Otra opción es usar rebase interactivo.
Esto le permite editar cualquier post que quiera actualizar, incluso si no es el último post.

Para hacer una calabaza git, sigue estos pasos:

 // X is the number of commits to the last commit you want to be able to edit git rebase -i HEAD~X 

Una vez que aplaque sus compromisos, elija e/r para editar el post

enter image description here

Nota importante sobre la rebase interactiva

Cuando usas git rebase -i HEAD~X , puede haber más de X commits. Git "recostackrá" todas las confirmaciones en los últimos X commits y si hubo una fusión en algún punto entre ese range, verá todos los commits así que el resultado será X +.

Buen consejo:

Si tiene que hacerlo para más de una twig y puede enfrentar conflictos al enmendar el contenido configurado, git rerere y resuelva esos conflictos automáticamente.


Documentación

  • git-commit (1) Página manual

  • git-rebase (1) Página manual

  • git-push (1) Página manual

 git commit --amend -m "your new message" 

Si la confirmación que desea corregir no es la más reciente:

  1. git rebase --interactive $parent_of_flawed_commit

    Si desea corregir varios commits defectuosos, pase el padre del más antiguo de ellos.

  2. Aparecerá un editor, con una list de todas las confirmaciones desde la que diste.

    1. Cambie la pick para reword a reword (o en versiones anteriores de Git, para edit ) frente a las confirmaciones que desee corregir.
    2. Una vez que guardes, Git reproducirá los commits listdos.
  3. Para cada confirmación que desee volver a networkingactar , Git lo regresará a su editor. Para cada compromiso que desee editar , Git lo coloca en el shell. Si estás en el caparazón:

    1. Cambie la confirmación de cualquier forma que desee.
    2. git commit --amend
    3. git rebase --continue

La mayoría de esta secuencia se explicará a través de la salida de los diversos commands sobre la marcha. Es muy fácil, no necesitas memorizarlo, solo restring que git rebase --interactive te permite corregir confirmaciones sin importar cuánto time hace que fueron.


Tenga en count que no querrá cambiar las confirmaciones que ya haya enviado. O tal vez lo haga, pero en ese caso tendrá que tener mucho cuidado para comunicarse con todos los que puedan haber hecho sus commits y haber hecho un trabajo encima de ellos. ¿Cómo recupero / vuelvo a sincronizar después de que alguien empuja una rebase o un reinicio a una twig publicada?

Para modificar la confirmación anterior, realice los cambios que desee y realice esos cambios, y luego ejecútelos

 git commit --amend 

Esto abrirá un file en su editor de text que representa su nuevo post de confirmación. Comienza lleno con el text de su post de confirmación anterior. Cambie el post de confirmación como desee, luego guarde el file y salga de su editor para finalizar.

Para modificar la confirmación anterior y mantener el mismo post de logging, ejecute

 git commit --amend -C HEAD 

Para corregir la confirmación anterior quitándola por completo, ejecuta

 git reset --hard HEAD^ 

Si desea editar más de un post de confirmación, ejecute

 git rebase -i HEAD~ commit_count 

(Reemplace commit_count por el número de confirmaciones que desee editar). Este command inicia su editor. Marque la primera confirmación (la que desea cambiar) como "editar" en lugar de "seleccionar", luego guarde y salga de su editor. Haga el cambio que desea confirmar y luego ejecute

 git commit --amend git rebase --continue 

Nota: También puede "Hacer el cambio que desee" desde el editor abierto por git commit --amend

Como ya se mencionó, git commit --amend es la forma de sobrescribir el último commit. Una nota: si también desea sobrescribir los files , el command sería

 git commit -a --amend -m "My new commit message" 

También puedes usar git filter-branch para eso.

 git filter-branch -f --msg-filter "sed 's/errror/error/'" $flawed_commit..HEAD 

No es tan fácil como un git commit --amend trivial de git commit --amend , pero es especialmente útil, si ya tienes algunas fusiones después de tu post de compromiso erróneo.

Tenga en count que esto intentará reescribir CADA commit entre HEAD y el commit defectuoso, por lo que debe elegir su command msg-filter muy sabio 😉

Prefiero de esta manera.

 git commit --amend -c <commit ID> 

De lo contrario, habrá una nueva confirmación con una nueva ID de confirmación

Si está utilizando la herramienta GUI de Git, hay un button llamado modificar la última confirmación. Haga clic en ese button y luego mostrará sus últimos files y posts de confirmación. Simplemente edite ese post y puede confirmarlo con un nuevo post de confirmación.

O use este command desde una console / terminal:

 git commit -a --amend -m "My new commit message" 

Puedes usar el rebase de Git . Por ejemplo, si desea modificar de nuevo para confirmar bbc643cd, ejecute

 $ git rebase bbc643cd^ --interactive 

En el editor pnetworkingeterminado, modifique 'elegir' para 'editar' en la línea cuyo compromiso desea modificar. Haga sus cambios y luego póngalos en escena con

 $ git add <filepattern> 

Ahora puedes usar

 $ git commit --amend 

para modificar la confirmación, y después de eso

 $ git rebase --continue 

para volver al compromiso de la cabeza anterior.

  1. Si solo desea modificar su último post de confirmación, haga lo siguiente:

     git commit --amend 

    Eso lo llevará a su exitor de text y le permitirá cambiar el último post de confirmación.

  2. Si desea cambiar los últimos 3 posts de confirmación, o cualquiera de los posts de confirmación hasta ese momento, suministre HEAD~3 al command git rebase -i :

     git rebase -i HEAD~3 

Si tiene que cambiar un post de confirmación anterior en varias twigs (es decir, la confirmación con el post erróneo está presente en varias twigs), es posible que desee utilizar:

 git filter-branch -f --msg-filter \ 'sed "s/<old message>/<new message>/g"' -- --all 

Git creará un directory temporal para la reescritura y, además, hará una copy de security de las references antiguas en refs/original/ .

  • -f hará cumplir la ejecución de la operación. Esto es necesario si el directory temporal ya está presente o si ya hay references almacenadas en refs/original . Si ese no es el caso, puede soltar esta bandera.

  • -- separa las opciones de la twig de filter de las opciones de revisión.

  • --all se asegurarán de que todas las twigs y tags se reescriban.

Debido a la copy de security de sus references anteriores, puede volver fácilmente al estado antes de ejecutar el command.

Digamos que quieres recuperar tu master y acceder a él en la twig old_master :

 git checkout -b old_master refs/original/refs/heads/master 

Utilizar

 git commit --amend 

Para entenderlo en detalle, una publicación excelente es 4. Reescribir la historia de Git . También habla sobre cuándo no usar git commit --amend .

Enmendar

Tienes un par de opciones aquí. Tu puedes hacer

 git commit --amend 

siempre que sea tu último compromiso.

Rebase interactivo

De lo contrario, si no es su último compromiso, puede hacer una rebase interactiva,

 git rebase -i [branched_from] [hash before commit] 

Luego, dentro de la database interactiva simplemente agrega editar a esa confirmación. Cuando aparece un git commit --amend y modifica el post de confirmación. Si desea retroceder antes de ese punto de confirmación, también puede usar git reflog y simplemente eliminar esa confirmación. Entonces haces un git commit nuevamente.

Si está utilizando la GUI de Git, puede modificar la última confirmación que no se haya enviado:

 Commit/Amend Last Commit 

Utilizo la GUI de Git tanto como puedo, y eso te da la opción de modificar la última confirmación:

Tick that box

Además, git rebase -i origin/master es un buen mantra que siempre te presentará las confirmaciones que hayas hecho sobre el maestro, y te dará la opción de enmendar, borrar, reorderar o aplastar. No es necesario get ese hash primero.

Si es tu último compromiso, simplemente modifica la confirmación:

 git commit --amend -o -m "New commit message" 

(usando la bandera -o ( --only ) para asegurarse de cambiar solo el post de confirmación)

Si se trata de un commit enterrado, utiliza la increíble rebase interactiva :

 git rebase -i @~9 # Show the last 9 commits in a text editor 

Encuentre el compromiso que desea, cambie pick to r ( reword ) y guarde y cierre el file. ¡Hecho!


Tutorial de vim en miniatura (o, cómo volver a establecer la base con solo 8 teclas 3j cw r Esc ZZ ):

  • Ejecuta vimtutor si tienes time
  • h j k l corresponden a teclas de movimiento
  • Todos los commands pueden ser prefijados con un "range", por ej. 3j mueve hacia abajo 3 líneas
  • Para ingresar al modo de inserción, el text que escriba aparecerá en el file
  • Esc o Ctrl c para salir del modo de inserción y volver al modo "normal"
  • u para deshacer
  • Ctrl r para rehacer
  • dd , dw , dl para eliminar una línea, palabra o letra, respectivamente
  • cc , cw , cl para cambiar una línea, palabra o letra, respectivamente (igual que dd i )
  • yy , yw , yl para copyr ("arrastrar") una línea, palabra o letra, respectivamente
  • p o P para pegar después o antes de la position actual, respectivamente
  • :w Enter para save (escribir) un file
  • :q! Ingrese para salir sin save
  • :wq Enter o ZZ para save y salir

Si edita mucho text, cambie a la distribución de keyboard de Dvorak, aprenda a tocar y aprenda vim. ¿Vale la pena el esfuerzo? Sí.


ProTip ™: no tengas miedo de experimentar con commands "peligrosos" que reescriban el historial * – Git no borra tus commits por 90 días por defecto; puedes encontrarlos en el reflog:

 $ git reset @~3 # go back 3 commits $ git reflog c4f708b HEAD@{0}: reset: moving to @~3 2c52489 HEAD@{1}: commit: more changes 4a5246d HEAD@{2}: commit: make important changes e8571e4 HEAD@{3}: commit: make some changes ... earlier commits ... $ git reset 2c52489 ... and you're back where you started 

* Tenga cuidado con opciones como --hard y --force though – pueden descartar datos.
* Además, no reescriba el historial en las sucursales en las que está queueborando.

Wow, entonces hay muchas forms de hacer esto.

Otra forma de hacerlo es eliminar el último compromiso, pero conserve sus cambios para que no pierda su trabajo. Luego puede hacer otra confirmación con el post corregido. Esto se vería así:

 git reset --soft HEAD~1 git commit -m 'New and corrected commit message' 

Siempre hago esto si olvido agregar un file o hacer un cambio.

Recuerde especificar --soft lugar de --hard , de lo contrario, perderá esa confirmación por completo.

Si solo quieres editar el último uso de commit:

 git commit --amend 

o

 git commit --amend -m 'one line message' 

Pero si quiere editar varias confirmaciones seguidas, debe usar el rebase en su lugar:

 git rebase -i <hash of one commit before the wrong commit> 

git rebase editing

En un file como el anterior, escriba edit / e o una de las otras opciones y presione save y salir.

Ahora estarás en el primer compromiso incorrecto. Realice cambios en los files y se organizarán automáticamente por usted. Tipo

 git commit --amend 

save y salir eso y escribir

 git rebase --continue 

para pasar a la siguiente selección hasta que termine con todas sus selects.

Tenga en count que estas cosas cambian todos sus hashes SHA después de esa confirmación particular.

Si solo quieres cambiar tu último post, debes usar la bandera --only o su atajo – o con commit --amend :

 git commit --amend -o -m "New commit message" 

Esto asegura que no aumente accidentalmente su compromiso con cosas preparadas. Por supuesto, es mejor tener una configuration $EDITOR adecuada. Luego puede dejar la opción -m fuera, y git completará previamente el post de confirmación con el anterior. De esta manera, se puede editar fácilmente.

Para cualquiera que esté buscando una GUI de Windows / Mac para editar algo más que el último post (para commits sin apresurar ), recomendaría SourceTree .

Actualización: descubrí que el procedimiento a continuación se describe con más detalle, con mejores capturas de pantalla y pasos adicionales para cuando las confirmaciones se hayan insertado en esta respuesta .

Rebase interactivo de SourceTree

Procedimiento:

  1. Asegúrese de haber confirmado o guardado todos los cambios actuales (es decir, para que no haya files listdos en la pestaña "Estado del file"; de lo contrario, no funcionará).
  2. En la pestaña "Log / History", haga clic con el button derecho en la input con una línea contigua en el gráfico, una debajo de la (s) confirmación (es) que desea editar y select "Rebase hijos de <commit ref> interactively …"
  3. Seleccione la fila completa para el post de confirmación que desea cambiar ( es decir, click la columna "Mensaje" ).
  4. Haga clic en el button "Editar post".
  5. Edite el post como desee en el cuadro de dialog que aparece y click Aceptar.
  6. Repita los pasos 3 y 4 si hay otros posts para cambiar.
  7. Haga clic en Aceptar – comenzará el rebasamiento – si todo está bien, la salida finalizará "Completada exitosamente".

Actualice su último post de confirmación incorrecto con un nuevo post de confirmación en una línea:

 git commit --amend -m "your new commit message" 

O bien, intente restablecer git como a continuación:

 # You can reset your head to n number of commit # NOT a good idea for changing last commit message # but you can get an idea to split commit into multiple commits git reset --soft HEAD^ # it will reset you last commit. Now, you # can re-commit it with new commit message. 

Usar el restablecimiento para dividir los commits en commits más pequeños

git reset puede ayudarlo a dividir una confirmación en varias confirmaciones también:

 # reset your head. I am resetting to last commits: git reset --soft HEAD^ # (you can reset multiple commit by doing HEAD~2(no. of commits) # Now, reset your head for splitting it to multiple commits git reset HEAD # add and commit your files seperately to make multiple commits: eg git add app/ git commit -m "add all files in app directory" git add config/ git commit -m "add all files in config directory" 

Aquí ha roto con éxito su último compromiso en dos commits.

En esta pregunta hay muchas respuestas, pero ninguna de ellas explica en gran detalle cómo cambiar los posts de confirmación anteriores usando VIM. Estaba atrapado tratando de hacer esto yo mismo, así que aquí voy a escribir en detalle cómo lo hice especialmente para las personas que no tienen experiencia en VIM.

Quise cambiar mis cinco últimas confirmaciones que ya envié al server. Esto es bastante "peligroso" porque si alguien más ya ha sacado esto, puede estropearlo cambiando los posts de confirmación. Sin embargo, cuando estás trabajando en tu pequeña twig y estás seguro de que nadie la ha sacado, puedes cambiarla así:

Digamos que quiere cambiar sus cinco últimos commits, luego tipea esto en la terminal:

git rebase -i HEAD~5 * Donde 5 es el número de posts de confirmación que desea cambiar. (por lo tanto, si desea cambiar el 10º al último compromiso, escriba 10)

Este command te llevará a VIM allí, puedes 'editar' tu historial de commits. Verás tus últimos 5 commits en la parte superior así:

pick <commit hash> commit message

En lugar de pick , necesitas escribir la reword . Puede hacer esto en VIM escribiendo i , que lo hace entrar en modo INSERT. (Verá que está en el modo de inserción con la palabra INSERTAR en la parte inferior). Para las confirmaciones que desea cambiar, escriba en reword en lugar de pick

Luego debe save y salir de esta pantalla; para ello, vaya primero al 'modo de command' presionando el button esc. (puede verificar que está en modo command si la palabra INSERTAR en la parte inferior ha desaparecido) Luego puede escribir un command escribiendo : el command para save y salir es wq . Entonces, si :wq estás en el path correcto.

Luego, VIM revisará cada post de confirmación que desee volver a networkingactar, aquí puede cambiar los posts de confirmación. Hará esto yendo al modo INSERT, cambiando el post de confirmación, entrando en el modo de command y guardando y cerrando. Hazlo 5 veces y ya no estás en VIM.

Entonces, si ya presionó sus commits incorrectos, necesita git push --force para sobrescribirlos. Restring que git push --force es algo bastante peligroso, así que asegúrate de que nadie haya sacado del server desde que presionaste tus commits incorrectos.

¡Ahora ha cambiado sus posts de compromiso!

(Como ve, no soy tan experimentado en VIM, así que si utilicé una "jerga" incorrecta para explicar lo que está sucediendo, ¡no dude en corregirme!)

He agregado el alias de reci , recm para recommit (amend) , ahora puedo hacerlo con git recm o git recm -m .

 $ vim ~/.gitconfig [alias] ...... cm = commit reci = commit --amend recm = commit --amend ...... 

Puedes usar git-rebase-reword

Está diseñado para editar cualquier confirmación (no solo la última) de la misma manera que commit --amend

 $ git rebase-reword <commit-or-refname> 

Se nombra después de la acción en rebase interactive para modificar una confirmación: "reword". Vea esta publicación y el modo interactivo de la sección man-

Ejemplos:

 $ git rebase-reword b68f560 $ git rebase-reword HEAD^ 

I realised that I had pushed a commit with a typo in it. In order to undo, I did the following:

 git commit --amend -m "T-1000, advanced prototype" git push --force 

Warning: force pushing your changes will overwrite the remote branch with your local one. Make sure that you aren't going to be overwriting anything that you want to keep. Also be cautious about force pushing an amended (rewritten) commit if anyone else shares the branch with you, because they'll need to rewrite their own history if they have the old copy of the commit that you've just rewritten.

I like to use the following:

  1. git status
  2. git add --all
  3. git commit -am "message goes here about the change"
  4. git pull <origin master>
  5. git push <origin master>

If you have not pushed the code to your remote branch ( GitHub / Bitbucket ) you can change the commit message on the command line as below.

  git commit --amend -m "Your new message" 

If you're working on a specific branch do this:

 git commit --amend -m "BRANCH-NAME: new message" 

If you've already pushed the code with the wrong message, and you need to be careful when changing the message. That is, after you change the commit message and try pushing it again, you end up with having issues. To make it smooth, follow these steps.

Please read my entire answer before doing it.

 git commit --amend -m "BRANCH-NAME : your new message" git push -f origin BRANCH-NAME # Not a best practice. Read below why? 

Important note: When you use the force push directly you might end up with code issues that other developers are working on the same branch. So to avoid those conflicts, you need to pull the code from your branch before making the force push :

  git commit --amend -m "BRANCH-NAME : your new message" git pull origin BRANCH-NAME git push -f origin BRANCH-NAME 

This is the best practice when changing the commit message, if it was already pushed.