¿Cómo puedo guardar solo uno de los múltiples archivos modificados en mi sucursal?

Descargo de responsabilidad : la siguiente respuesta es para git antes de git 2.13. Para git 2.13 y más, mira otra respuesta más abajo .

Advertencia

Como se señaló en los comentarios, esto pone todo en el alijo, tanto en escena como en escena. --Keep-index solo deja el índice solo después de que se realiza el escondite. Esto puede causar conflictos de fusión cuando más tarde revienta el alijo.

Esto esconderá todo lo que no haya agregado previamente. Solo git addlas cosas que desea conservar, luego ejecútelo.

git stash --keep-index

Por ejemplo, si desea dividir una confirmación anterior en más de un conjunto de cambios, puede utilizar este procedimiento:

1. git rebase -i <last good commit>
2. Marcar algunos cambios como edit.
3. git reset HEAD^
4. git add <files you want to keep in this change>
5. git stash --keep-index
6. Arregle las cosas según sea necesario. No te olvides de git addningún cambio.
7. git commit
8. git stash pop
9. Repita, desde el n. ° 5, según sea necesario.
10. git rebase --continue

También puedes usar git stash save -p "my commit message". De esta manera, puede seleccionar qué trozos se deben agregar al alijo, también se pueden seleccionar archivos completos.

Se te indicarán algunas acciones para cada trozo:

   y - stash this hunk
   n - do not stash this hunk
   q - quit; do not stash this hunk or any of the remaining ones
   a - stash this hunk and all later hunks in the file
   d - do not stash this hunk or any of the later hunks in the file
   g - select a hunk to go to
   / - search for a hunk matching the given regex
   j - leave this hunk undecided, see next undecided hunk
   J - leave this hunk undecided, see next hunk
   k - leave this hunk undecided, see previous undecided hunk
   K - leave this hunk undecided, see previous hunk
   s - split the current hunk into smaller hunks
   e - manually edit the current hunk
   ? - print help

Dado que git se trata fundamentalmente de administrar un contenido e índice de todo el repositorio (y no uno o varios archivos), las git stashofertas, no sorprendentemente,con todo el directorio de trabajo.

En realidad, desde Git 2.13 (Q2 2017), puede guardar archivos individuales con git stash push:

git stash push [--] [<pathspec>...]

Cuando pathspecse le da a ' git stash push', el nuevo alijo registra los estados modificados solo para los archivos que coinciden con la especificación de la ruta. Consulte " Cambios del alijo a archivos específicos " para obtener más información.

Ejemplo simplificado:

 git stash push path/to/file

El caso de prueba para esta función muestra algunas opciones más desactivadas:

test_expect_success 'stash with multiple pathspec arguments' '
    >foo &&
    >bar &&
    >extra &&
    git add foo bar extra &&

    git stash push -- foo bar &&   

    test_path_is_missing bar &&
    test_path_is_missing foo &&
    test_path_is_file extra &&

    git stash pop &&
    test_path_is_file foo &&
    test_path_is_file bar &&
    test_path_is_file extra

La respuesta original (a continuación, junio de 2010) fue sobre seleccionar manualmente lo que desea guardar.

CasebashComentarios de :

Este el stash --patch solución original) es buena, pero a menudo modifico muchos archivos, por lo que usar parche es molesto

bukzor 's respuesta (upvoted, noviembre de 2011) sugiere una solución más práctica, en base a
git add+git stash --keep-index .
Ve a ver y vota su respuesta, que debería ser la oficial (en lugar de la mía).

Sobre esa opción, chhh señala un flujo de trabajo alternativo en los comentarios:

deberías " git reset --soft" después de un alijo para recuperar tu puesta en escena clara:
para llegar al estado original, que es un área de puesta en escena clara y con solo algunas modificaciones seleccionadas sin puesta en escena, uno podría restablecer suavemente el índice para obtener (sin cometer algo como tú, bukzor, lo hizo).

(Respuesta original de junio de 2010: alijo manual)

Sin embargo, git stash save --patchpodría permitirte lograr el alijo parcial que buscas:

Con --patch, puede seleccionar interactivamente trozos en la diferencia entre HEAD y el árbol de trabajo que se va a guardar.
La entrada oculta se construye de manera tal que su estado de índice es el mismo que el estado de índice de su repositorio, y su árbol de trabajo contiene solo los cambios que seleccionó interactivamente. Los cambios seleccionados se revierten de su árbol de trabajo.

Sin embargo, eso guardará el índice completo (que puede no ser lo que desea, ya que podría incluir otros archivos ya indexados) y un árbol de trabajo parcial (que podría parecerse al que desea guardar).

git stash --patch --no-keep-index

podría ser una mejor opción.

Si --patch no funciona, un proceso manual podría:

Para uno o varios archivos, una solución intermedia sería:

• copiarlos fuera del repositorio de Git
  (en realidad, eleotlecram propone una alternativa interesante )
• git stash
• copiarlos de nuevo
• git stash # esta vez, solo se guardan los archivos que deseas
• git stash pop stash@{1} # vuelve a aplicar todas las modificaciones de tus archivos
• git checkout -- afile # restablecer el archivo al contenido HEAD, antes de cualquier modificación local

Al final de ese proceso bastante engorroso, solo tendrá uno o varios archivos escondidos.

Cuando git stash -p(o git add -pcon stash --keep-index) sería demasiado engorroso, me resultó más fácil de usar diff, checkoutyapply :

Para "esconder" solo un archivo / directorio particular:

git diff path/to/dir > stashed.diff
git checkout path/to/dir

Luego después

git apply stashed.diff

Uso git stash push, así:

git stash push [--] [<pathspec>...]

Por ejemplo:

git stash push -- my/file.sh

Está disponible desde Git 2.13, lanzado en la primavera de 2017.

Digamos que tienes 3 archivos

a.rb
b.rb
c.rb

y desea guardar solo b.rb y c.rb pero no a.rb

puedes hacer algo como esto

# commit the files temporarily you don't want to stash
git add a.rb
git commit -m "temp" 

# then stash the other files
git stash save "stash message"

# then undo the previous temp commit
git reset --soft HEAD^
git reset

Y ya está! HTH

Otra forma de hacer esto:

# Save everything
git stash 

# Re-apply everything, but keep the stash
git stash apply

git checkout <"files you don't want in your stash">

# Save only the things you wanted saved
git stash

# Re-apply the original state and drop it from your stash
git stash apply stash@{1}
git stash drop stash@{1}

git checkout <"files you put in your stash">

Se me ocurrió esto después de que (una vez más) llegué a esta página y no me gustaron las dos primeras respuestas (la primera respuesta simplemente no responde la pregunta y no me gustó mucho trabajar con el -pmodo interactivo).

La idea es la misma que lo que @VonC sugirió usar archivos fuera del repositorio: guarda los cambios que desea en algún lugar, elimina los cambios que no desea en su escondite y luego vuelve a aplicar los cambios que quitó del camino. Sin embargo, utilicé el escondite de git como "en alguna parte" (y como resultado, hay un paso adicional al final: eliminar los depósitos que colocaste en el escondite, porque también los quitaste del camino).

Actualización (14/02/2015) - Reescribí el script un poco, para manejar mejor el caso de conflictos, que ahora deberían presentarse como conflictos no fusionados en lugar de archivos .rej.

A menudo me resulta más intuitivo hacer lo contrario del enfoque de @bukzor. Es decir, organizar algunos cambios y luego esconder solo esos cambios organizados.

Desafortunadamente, git no ofrece una reserva de git: solo index o similar, así que preparé un script para hacer esto.

#!/bin/sh

# first, go to the root of the git repo
cd `git rev-parse --show-toplevel`

# create a commit with only the stuff in staging
INDEXTREE=`git write-tree`
INDEXCOMMIT=`echo "" | git commit-tree $INDEXTREE -p HEAD`

# create a child commit with the changes in the working tree
git add -A
WORKINGTREE=`git write-tree`
WORKINGCOMMIT=`echo "" | git commit-tree $WORKINGTREE -p $INDEXCOMMIT`

# get back to a clean state with no changes, staged or otherwise
git reset -q --hard

# Cherry-pick the index changes back to the index, and stash.
# This cherry-pick is guaranteed to succeed
git cherry-pick -n $INDEXCOMMIT
git stash

# Now cherry-pick the working tree changes. This cherry-pick may fail
# due to conflicts
git cherry-pick -n $WORKINGCOMMIT

CONFLICTS=`git ls-files -u`
if test -z "$CONFLICTS"; then
    # If there are no conflicts, it's safe to reset, so that
    # any previously unstaged changes remain unstaged
    #
    # However, if there are conflicts, then we don't want to reset the files
    # and lose the merge/conflict info.
    git reset -q
fi

Puede guardar el script anterior como en git-stash-indexalgún lugar de su ruta y luego invocarlo como git stash-index

# <hack hack hack>
git add <files that you want to stash>
git stash-index

Ahora el alijo contiene una nueva entrada que solo contiene los cambios que había organizado, y su árbol de trabajo aún contiene los cambios no organizados.

En algunos casos, los cambios del árbol de trabajo pueden depender de los cambios del índice, por lo que cuando oculta los cambios del índice, los cambios del árbol de trabajo tienen un conflicto. En este caso, obtendrá los conflictos no fusionados habituales que puede resolver con git merge / git mergetool / etc.

Si no desea especificar un mensaje con sus cambios escondidos, pase el nombre del archivo después de un doble guión.

$ git stash -- filename.ext

Si se trata de un archivo nuevo / sin seguimiento, primero deberá organizarlo.

Este método funciona en git versiones 2.13+

Dado que crear ramas en Git es trivial, puede crear una rama temporal y verificar los archivos individuales en ella.

Simplemente puedes hacer esto:

git stash push "filename"

o con un mensaje opcional

git stash push -m "Some message" "filename"

Guarde el siguiente código en un archivo, por ejemplo, llamado stash. El uso es stash <filename_regex>. El argumento es la expresión regular para la ruta completa del archivo. Por ejemplo, para guardar a / b / c.txt, stash a/b/c.txto stash .*/c.txt, etc.

$ chmod +x stash
$ stash .*.xml
$ stash xyz.xml

Código para copiar en el archivo:

#! /usr/bin/expect --
log_user 0
set filename_regexp [lindex $argv 0]

spawn git stash -p

for {} 1 {} {
  expect {
    -re "diff --git a/($filename_regexp) " {
      set filename $expect_out(1,string)
    }
    "diff --git a/" {
      set filename ""
    }
    "Stash this hunk " {
      if {$filename == ""} {
        send "n\n"
      } else {
        send "a\n"
        send_user "$filename\n"
      }
    }
    "Stash deletion " {
      send "n\n"
    }
    eof {
      exit
    }
  }
}

En caso de que realmente quiera decir cambios de descarte cada vez que usa git stash(y realmente no usa git stash para guardarlo temporalmente), en ese caso puede usar

git checkout -- <file>

[ NOTA ]

Esa git stashes solo una alternativa más rápida y simple para ramificarse y hacer cosas.

El problema con la solución `` intermedia '' de VonC de copiar archivos al exterior del repositorio de Git es que pierde la información de ruta, lo que hace que copiar un montón de archivos más tarde sea una molestia.

A resulta más fácil usar tar (herramientas similares probablemente lo harán) en lugar de copiar:

• tar cvf /tmp/stash.tar ruta / a / some / file ruta / a / some / other / file (... etc.)
• ruta de pago git / a / some / file ruta / a / some / other / file
• escondite
• tar xvf /tmp/stash.tar
• etc. (ver la sugerencia 'intermedia' de VonC)

A veces he realizado un cambio no relacionado en mi rama antes de comprometerlo, y quiero moverlo a otra rama y confirmarlo por separado (como maestro). Hago esto:

git stash
git checkout master
git stash pop
git add <files that you want to commit>
git commit -m 'Minor feature'
git stash
git checkout topic1
git stash pop
...<resume work>...

Tenga en cuenta que lo primero stashy stash poppuede eliminarse, puede llevar todos sus cambios a la mastersucursal cuando realice el pago, pero solo si no hay conflictos. Además, si está creando una nueva rama para los cambios parciales, necesitará el alijo.

Puede simplificarlo suponiendo que no haya conflictos ni una nueva rama:

git checkout master
git add <files that you want to commit>
git commit -m 'Minor feature'
git checkout topic1
...<resume work>...

El escondite ni siquiera es necesario ...

Esto se puede hacer fácilmente en 3 pasos usando SourceTree.

1. Compromete temporalmente todo lo que no quieres guardar.
2. Agregue todo lo demás, luego guárdelo.
3. Pop su confirmación temporal ejecutando git reset, apuntando a la confirmación antes de su temporal.

Todo esto se puede hacer en cuestión de segundos en SourceTree, donde puede hacer clic en los archivos (o incluso en las líneas individuales) que desea agregar. Una vez agregado, simplemente compromételos a una confirmación temporal. Luego, haga clic en la casilla de verificación para agregar todos los cambios, luego haga clic en esconder para guardar todo. Con los cambios ocultos fuera del camino, eche un vistazo a su lista de confirmación y observe el hash para la confirmación antes de su confirmación temporal, luego ejecute 'git reset hash_b4_temp_commit', que es básicamente como "hacer estallar" la confirmación restableciendo su rama al comprometerse justo antes de eso. Ahora, te quedan solo las cosas que no querías guardar.

Me gustaría utilizar git stash save --patch. No creo que la interactividad sea molesta porque hay opciones durante la misma para aplicar la operación deseada a archivos completos.

Cada respuesta aquí es tan complicada ...

¿Qué pasa con esto para "esconder":

git diff /dir/to/file/file_to_stash > /tmp/stash.patch
git checkout -- /dir/to/file/file_to_stash

Esto para hacer estallar el cambio de archivo:

git apply /tmp/stash.patch

Exactamente el mismo comportamiento que guardar un archivo y volverlo a colocar.

He revisado las respuestas y comentarios para esto y una serie de hilos similares. Tenga en cuenta que ninguno de los siguientes comandos son correctos con el fin de poder ocultar cualquier archivo específico rastreado / no rastreado :

• git stash -p (--patch): seleccione trozos manualmente, excluyendo archivos no rastreados
• git stash -k (--keep-index): esconde todos los archivos rastreados / no rastreados y mantenlos en el directorio de trabajo
• git stash -u (--include-untracked): esconde todos los archivos rastreados / no rastreados
• git stash -p (--patch) -u (--include-untracked): comando inválido

Actualmente, el método más razonable para poder almacenar cualquier archivo específico rastreado / no rastreado es:

• Confirma temporalmente los archivos que no quieres guardar
• Agregar y guardar
• Pop el commit temporal

Escribí un script simple para este procedimiento en una respuesta a otra pregunta , y aquí hay pasos para realizar el procedimiento en SourceTree .

Solución

Cambios locales:

• archivo_A (modificado) no organizado
• archivo_B (modificado) no organizado
• file_C (modificado) no organizado

Para crear un alijo "my_stash" con solo los cambios en file_C :

1. git add file_C
2. git stash save --keep-index temp_stash
3. git stash save my_stash
4. git stash pop stash@#{1}

Hecho.

Explicación

1. agregar file_C al área de preparación
2. cree un alijo temporal llamado "temp_stash" y mantenga los cambios en el archivo_C
3. cree el alijo deseado ("my_stash") con solo los cambios en file_C
4. aplique los cambios en "temp_stash" (archivo_A y archivo_B) en su código local y elimine el alijo

Puede usar el estado de git entre los pasos para ver qué está sucediendo.

Cuando intenta cambiar entre dos ramas, se produce esta situación.

Intente agregar los archivos usando " git add filepath".

Más tarde ejecuta esta línea

git stash --keep-index

Para guardar un solo archivo, use git stash --patch [file].

Esto va a indicador: Stash this hunk [y,n,q,a,d,j,J,g,/,e,?]? ?. Simplemente escriba a(guarde este trozo y todos los trozos posteriores en el archivo) y estará bien.

Situación similar. Se comprometió y se dio cuenta de que no está bien.

git commit -a -m "message"
git log -p

Basado en las respuestas esto me ayudó.

# revert to previous state, keeping the files changed
git reset HEAD~
#make sure it's ok
git diff
git status
#revert the file we don't want to be within the commit
git checkout specs/nagios/nagios.spec
#make sure it's ok
git status
git diff
#now go ahead with commit
git commit -a -m "same|new message"
#eventually push tu remote
git push

En esta situación, yo git add -p(interactivo), git commit -m blahy luego guardo lo que queda si es necesario.

No sé cómo hacerlo en la línea de comandos, solo usando SourceTree. Digamos que ha cambiado el archivo A y tiene dos cambios en el archivo B. Si desea guardar solo el segundo trozo en el archivo B y dejar todo lo demás intacto, haga lo siguiente:

1. Escenificar todo
2. Realice cambios en su copia de trabajo que deshaga todos los cambios en el archivo A. (por ejemplo, inicie la herramienta de diferencias externa y haga que los archivos coincidan).
3. Haga que el archivo B parezca que solo se le aplica un segundo cambio. (por ejemplo, inicie la herramienta de diferencia externa y deshaga el primer cambio).
4. Crea un alijo usando "Mantener cambios por etapas".
5. Desmonta todo
6. ¡Hecho!

git add .                           //stage all the files
git reset <pathToFileWillBeStashed> //unstage file which will be stashed
git stash                           //stash the file(s)
git reset .                         // unstage all staged files
git stash pop                       // unstash file(s)

Una forma complicada sería primero comprometer todo:

git add -u
git commit // creates commit with sha-1 A

Restablezca la confirmación original pero revise the_one_file desde la nueva confirmación:

git reset --hard HEAD^
git checkout A path/to/the_one_file

Ahora puedes esconder el_un_archivo:

git stash

Limpie guardando el contenido confirmado en su sistema de archivos mientras restablece la confirmación original:

git reset --hard A
git reset --soft HEAD^

Sí, algo incómodo ...

No encontré ninguna respuesta para ser lo que necesitaba y eso es tan fácil como:

git add -A
git reset HEAD fileThatYouWantToStash
git commit -m "committing all but one file"
git stash

Esto oculta exactamente un archivo.

Respuesta rápida

Para revertir un archivo modificado específico en git, puede hacer la siguiente línea:

git checkout <branch-name> -- <file-path>

Aquí hay un ejemplo real:

git checkout master -- battery_monitoring/msg_passing.py

Si desea guardar algunos archivos modificados, simplemente

Agregue los archivos que no desea guardar, en el escenario , luego ejecutegit stash save --keep-index

Guardará todos los archivos modificados sin clasificar