Confirmar solo parte de un archivo en Git

Cuando realizo cambios en un archivo en Git, ¿cómo puedo confirmar solo algunos de los cambios?

Por ejemplo, ¿cómo podría confirmar solo 15 líneas de 30 líneas que se han cambiado en un archivo?

Puede usar git add --patch <filename>(o -ppara abreviar), y git comenzará a dividir su archivo en lo que cree que son "trozos" razonables (partes del archivo). Luego le indicará esta pregunta:

Stage this hunk [y,n,q,a,d,/,j,J,g,s,e,?]?

Aquí hay una descripción de cada opción:

• y organizar este trozo para la próxima confirmación
• n no organices este trozo para el próximo commit
• qdejar; no pongas en escena este trozo ni ninguno de los trozos restantes
• a escenifique este trozo y todos los trozos posteriores en el archivo
• d no ponga en escena este trozo ni ninguno de los trozos posteriores en el archivo
• g seleccione un trozo para ir a
• / buscar un trozo que coincida con la expresión regular dada
• j deja este trozo indeciso, mira el siguiente trozo indeciso
• J deja este trozo indeciso, mira el siguiente trozo
• k deja este trozo indeciso, mira el trozo indeciso anterior
• K deja este trozo indeciso, mira el trozo anterior
• s dividir el trozo actual en trozos más pequeños
• e editar manualmente el trozo actual
• ? ayuda de impresión hunk

Si el archivo aún no está en el repositorio, primero puede hacerlo git add -N <filename>. Después puedes continuar git add -p <filename>.

Después, puedes usar:

• git diff --staged para comprobar que realizaste los cambios correctos
• git reset -p para desentrañar trozos añadidos por error
• git commit -v para ver su confirmación mientras edita el mensaje de confirmación.

Tenga en cuenta que esto es muy diferente al git format-patchcomando, cuyo propósito es analizar los datos de confirmación en un .patcharchivo.

Referencia para el futuro: Git Tools - Puesta en escena interactiva

Puede usar git add --interactiveo , y luego ( no ); vea Modo interactivo en la página de manual de git-add , o simplemente siga las instrucciones.git add -p <file>git commit git commit -a

Modern Git también tiene git commit --interactive(y git commit --patch, que es la opción de acceso directo a parche en confirmación interactiva).

Si prefiere hacerlo desde la GUI, puede usar git-gui . Simplemente puede marcar fragmentos que desea incluir en commit. Personalmente me resulta más fácil que usar git add -i. Otras GUI de git, como QGit o GitX, también pueden tener esta funcionalidad.

git gui proporciona esta funcionalidad en la vista de diferencias. Simplemente haga clic con el botón derecho en la (s) línea (s) que le interese y debería ver un elemento de menú "organizar esta línea para confirmar".

Creo que esa git add -e myfilees la forma más fácil (mi preferencia al menos) ya que simplemente abre un editor de texto y le permite elegir qué línea desea poner en escena y qué línea no. En cuanto a los comandos de edición:

contenido agregado:

El contenido agregado está representado por líneas que comienzan con "+". Puede evitar la organización de las líneas de adición eliminándolas.

contenido eliminado:

El contenido eliminado se representa con líneas que comienzan con "-". Puede evitar que su eliminación se convierta en etapas convirtiendo el "-" en un "" (espacio).

contenido modificado:

El contenido modificado se representa con líneas "-" (eliminando el contenido anterior) seguido de líneas "+" (agregando el contenido de reemplazo). Puede evitar organizar la modificación al convertir las líneas "-" en "" y eliminar las líneas "+". Tenga en cuenta que modificar solo la mitad del par probablemente introducirá cambios confusos en el índice.

Todos los detalles sobre git addestán disponibles engit --help add

Si está utilizando vim, es posible que desee probar el excelente complemento llamado fugitivo .

Puede ver la diferencia de un archivo entre la copia de trabajo y el índice con :Gdiff, y luego agregar líneas o trozos al índice usando los comandos clásicos de vim diff como dp. Guarde las modificaciones en el índice y confirme con :Gcommit, y ya está.

Muy buenas presentaciones introductorias aquí (ver especialmente la parte 2 ).

Recomiendo encarecidamente usar SourceTree de Atlassian. (Es gratis.) Hace que esto sea trivial. Puede organizar trozos de código individuales o líneas de código individuales rápida y fácilmente.

Vale la pena señalar que para usar git add --patchpara un nuevo archivo , primero debe agregar el archivo para indexar con git add --intent-to-add:

git add -N file
git add -p file

Cuando tenga muchos cambios y termine creando algunas confirmaciones a partir de los cambios, entonces quiero guardar mi punto de partida temporalmente antes de organizar las cosas.

Me gusta esto:

$ git stash -u
Saved working directory and index state WIP on master: 47a1413 ...
$ git checkout -p stash
... step through patch hunks
$ git commit -m "message for 1st commit"
$ git checkout -p stash
... step through patch hunks
$ git commit -m "message for 2nd commit"
$ git stash pop

La respuesta de Whymarrh es lo que suelo hacer, excepto que a veces hay muchos cambios y puedo decir que podría cometer un error al organizar las cosas, y quiero un estado comprometido al que pueda recurrir para un segundo pase.

Si usa emacs, eche un vistazo a Magit , que proporciona una interfaz git para emacs. Es compatible con la organización de trozos (partes de archivos) bastante bien.

Intellij IDEA (y supongo que todos los demás productos de la serie) ha incorporado soporte para confirmaciones parciales desde v2018.1

Para aquellos que usan extensiones Git :

En la ventana Confirmar, seleccione el archivo que desea confirmar parcialmente, luego seleccione el texto que desea confirmar en el panel derecho, luego haga clic derecho en la selección y elija 'Etapa de líneas seleccionadas' en el menú contextual.

Al igual que la respuesta de jdsumsion, también puede esconder su trabajo actual, pero luego usar una herramienta difftool como meld para extraer los cambios seleccionados del alijo. De esa manera, incluso puede editar los trozos manualmente de manera muy fácil, lo que es un poco molesto cuando está en git add -p:

$ git stash -u
$ git difftool -d -t meld stash
$ git commit -a -m "some message"
$ git stash pop

El uso del método de ocultación le brinda la oportunidad de probar, si su código aún funciona, antes de confirmarlo.

Agregando una respuesta anterior, si prefiere usar la línea de comando, ingresar git add -e myfilele da la opción de elegir línea por línea lo que desea confirmar porque este comando abrirá un editor con las diferencias, así:

Como puede saber, las líneas que comienzan con +son adiciones, las líneas que comienzan con -son eliminaciones. Entonces:

• Para no realizar una adición, simplemente elimine esa línea.
• Para no organizar una eliminación, simplemente reemplácela -con espacio .

Esto es lo que git add -hdice acerca de agregar archivos de esta manera (parchear archivos):

contenido agregado El contenido agregado se representa mediante líneas que comienzan con "+". Puede evitar la organización de las líneas de adición eliminándolas.

contenido eliminado: el contenido eliminado se representa mediante líneas que comienzan con "-". Puede evitar que su eliminación se convierta en etapas convirtiendo el "-" en un "" (espacio).

contenido modificado: el contenido modificado se representa con líneas "-" (eliminando el contenido anterior) seguido de líneas "+" (agregando el contenido de reemplazo). Puede evitar organizar la modificación convirtiendo las líneas "-" en "" y eliminando las líneas "+". Tenga en cuenta que modificar solo la mitad del par probablemente introducirá cambios confusos en el índice.

Precaución: no cambie el contenido del archivo, este no es un buen lugar para hacerlo. Simplemente cambie los operadores de las líneas eliminadas o agregadas.

El complemento vim-gitgutter puede organizar a los trozos sin salir del editor vim usando

:GitGutterStageHunk

Además de esto, proporciona otras características interesantes como una columna de signo de diferencia como en algunos IDE modernos

Si solo una parte del trozo se escenificara vim-fugitiva

:Gdiff

permite la selección del rango visual en ese momento :'<,'>diffputo :'<,'>diffgetpara organizar / revertir cambios de línea individuales.

Probé git add -p filename.x, pero en una Mac, encontré que gitx ( http://gitx.frim.nl/ o https://github.com/pieter/gitx ) es mucho más fácil de comprometer exactamente las líneas que quería.

Con TortoiseGit:

haga clic derecho sobre el archivo y úselo Context Menu → Restore after commit. Esto creará una copia del archivo tal como está. Luego puede editar el archivo, por ejemplo, en TortoiseGitMerge y deshacer todos los cambios que no desea confirmar. Después de guardar esos cambios, puede confirmar el archivo.

Han pasado 10 años desde que se hizo esta pregunta. Y espero que esta respuesta sea útil para alguien. Como se menciona en la respuesta aquí , donde GUI no es una opción, la extensión de crecord de Andrew Shadura ayuda a abrir una ventana ncurses en la que podemos seleccionar las líneas para confirmar.

Configure la extensión de la siguiente manera:

git clone https://github.com/andrewshadura/git-crecord
cd git-crecord
./setup.py install
ln -s $PWD/git-crecord ~/.local/bin/git-crecord

cd a su repositorio git e invocarlo de la siguiente manera:

git crecord

Esto abriría la interfaz ncurses que se puede usar como se muestra a continuación. Al presionar las siguientes teclas en la ventana ncurses se realizarán ciertas acciones:

f       hunk toggle fold (arrow keys can also be used)
space   toggle hunk selection
a       toggle commit or amend
c       confirm and open commit window

Screencast que muestra un uso de muestra

Para los usuarios de Atom , el paquete github incluye puesta en escena interactiva, al estilo de git gui. Para accesos directos, consulte la documentación del paquete .

El uso de Atom permite trabajar con un tema que tiene un fondo oscuro (de forma predeterminada, git guitiene un fondo blanco).

Para emacs también hay gitsum

git-meld-index - citando del sitio web:

git-meld-index ejecuta meld, o cualquier otro git difftool (kdiff3, difuso, etc.), para permitirle organizar de manera interactiva los cambios en el índice git (también conocido como el área de preparación de git).

Esto es similar a la funcionalidad de git add -p y git add --interactive. En algunos casos, meld es más fácil / rápido de usar que git add -p. Esto se debe a que meld te permite, por ejemplo:

• ver más contexto
• ver diferencias entre líneas
• edite a mano y vea actualizaciones de diferencias 'en vivo' (actualizadas después de cada pulsación de tecla)
• navegue a un cambio sin decir 'n' a cada cambio que desee omitir

Uso

En un repositorio de git, ejecute:

git meld-index

Verás meld (o tu git difftool configurado) emergente con:

IZQUIERDA : directorio temporal que continúa archivos copiados de su árbol de trabajo

DERECHA : directorio temporal con el contenido del índice. Esto también incluye archivos que aún no están en el índice pero que están modificados o no se encuentran en la copia de trabajo; en este caso, verá el contenido del archivo de HEAD.

Edite el índice (lado derecho) hasta que esté satisfecho. Recuerde guardar cuando sea necesario.

Cuando haya terminado, cierre meld, y git-meld-index actualizará el índice para que coincida con el contenido del directorio temporal en el lado derecho de meld que acaba de editar.

Si está en la Windowsplataforma, en mi opinión git guies una herramienta muy buena para stage/ commitpocas líneas del unstagedarchivo

1. Hunk sabio:

• Seleccione el archivo de la unstagged Changessección
• Haga clic con el botón derecho en un fragmento de código que debe organizarse
• Seleccione Stage Hunk for commit

2. Línea sabia:

• Seleccione el archivo de la unstagged Changessección
• Seleccione la línea / líneas a organizar
• Haga clic derecho y seleccione Stage Lines for commit

3. Si desea organizar el archivo completo excepto un par de líneas:

• Seleccione el archivo de la unstagged Changessección
• prensa Ctrl+T (Stage file to commit)
• El archivo seleccionado ahora se mueve a la Staged ChangesSección
• Seleccione la línea / líneas que se organizarán
• Haga clic derecho y seleccione UnStage Lines for commit

Como muestra una respuesta anterior, puede usar git add --patch filename.txt

o la forma corta git add -p filename.txt

... pero para los archivos que ya están en su repositorio, existe una mejor opción para usar s --patch flag en el comando commit directamente (si está utilizando una versión de git lo suficientemente reciente): git commit --patch filename.txt

... o, de nuevo, la forma corta git commit -p filename.txt

... y luego usando las teclas mencionadas, (s / n, etc.), para elegir las líneas que se incluirán en la confirmación.

git-cola es una gran GUI y también tiene esta característica incorporada. Simplemente seleccione las líneas para escenificar y presione S. Si no se realiza ninguna selección, se organiza el trozo completo.