Annuler les modifications d'une copie de travail d'un fichier dans Git?

git checkout <commit> <filename>

j'ai utilisé aujourd'hui car j'ai réalisé que mon favicon avait été écrasé quelques engage, j'upgrated drupal 6.10, j'ai donc dû le récupérer. Voici ce que j'ai fait:

git checkout 088ecd favicon.ico

il suffit d'utiliser

git checkout filename

remplace le nom de fichier par la dernière version de la branche courante.

attention: vos modifications seront rejetées - aucune sauvegarde n'est conservée.

si votre fichier est déjà mis en scène (se produit lorsque vous faites un ajout git etc Après que le fichier est édité) pour décélérer vos modifications.

Utiliser

git reset HEAD <file>

puis

git checkout <file>

Si ce n'est déjà mis en scène, il suffit d'utiliser

git checkout <file>

si vous voulez simplement annuler les modifications de commit précédentes dans ce fichier, vous pouvez essayer ceci:

git checkout branchname^ filename

ceci va vérifier le fichier tel qu'il était avant la dernière propagation. Si vous voulez faire quelques autres commits en arrière, Utilisez la notation branchname~n .

je suis toujours confondu avec cela, donc voici un cas de test de rappel; disons que nous avons ce bash script pour tester git :

set -x
rm -rf test
mkdir test
cd test
git init
git config user.name test
git config user.email test@test.com
echo 1 > a.txt
echo 1 > b.txt
git add *
git commit -m "initial commit"
echo 2 >> b.txt
git add b.txt
git commit -m "second commit"
echo 3 >> b.txt

à ce point, le changement n'est pas mis en scène dans le cache, donc git status est:

$ git status
On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

    modified:   b.txt

no changes added to commit (use "git add" and/or "git commit -a")

si à partir de ce point, nous faisons git checkout , le résultat est le suivant:

$ git checkout HEAD -- b.txt
$ git status
On branch master
nothing to commit, working directory clean

si à la place nous faisons git reset , le résultat est:

$ git reset HEAD -- b.txt
Unstaged changes after reset:
M   b.txt
$ git status
On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

    modified:   b.txt

no changes added to commit (use "git add" and/or "git commit -a")

donc, dans ce cas - ci-si les changements ne sont pas mis en scène, git reset ne fait aucune différence, tandis que git checkout annule les changements.

maintenant, disons que le dernier changement du script ci-dessus est mis en scène/caché, c'est-à-dire que nous avons aussi fait git add b.txt à la fin.

dans ce cas, git status à ce point est:

$ git status
On branch master
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    modified:   b.txt

si de cette point, nous faisons git checkout , le résultat est celui-ci:

$ git checkout HEAD -- b.txt
$ git status
On branch master
nothing to commit, working directory clean

si nous faisons git reset , le résultat est:

$ git reset HEAD -- b.txt
Unstaged changes after reset:
M   b.txt
$ git status
On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

    modified:   b.txt

no changes added to commit (use "git add" and/or "git commit -a")

donc, dans ce cas - ci - si les changements sont échelonnés, git reset fera essentiellement des changements échelonnés dans des changements non étalés-tandis que git checkout écrasera les changements complètement.

je restaure mes fichiers en utilisant le code, ce que je fais est git checkout <sha hash id> <file name>

j'ai fait par git bash:

(use "git checkout -- <file>..." to discard changes in working directory)

1. git status. [nous avons donc vu un fichier wad modifié.]
2. git checkout -- index.html [j'ai changé dans index.fichier html :
3. git status ]

cette réponse est pour la commande nécessaire pour les modifications locales non alignées qui se trouvent dans plusieurs fichiers spécifiques dans le même ou plusieurs dossiers(ou répertoires). Cette réponse répond spécifiquement à la question où un utilisateur a plus d'un fichier, mais l'utilisateur ne veut pas annuler tous les changements locaux:

si vous avez un ou plusieurs fichiers, vous pouvez appliquer la samne de commande ( git checkout -- file ) chacun de ces dossiers en énumérant chacun de leur emplacement séparé par espace comme dans:

git checkout -- name1/name2/fileOne.ext nameA/subFolder/fileTwo.ext

l'esprit de l'espace abve entre nom1/nom2/fileOne.ext nameA/subFolder / fileTwo.poste 151950920"

Pour plusieurs fichiers dans le même dossier:

si vous avez besoin d'écarter des modifications pour tous les fichiers dans un certains répertoires, utilisez la caisse git comme suit:

git checkout -- name1/name2/*

l'astérisque au-dessus fait le truc de défaire tous les fichiers à cet endroit sous name1 / name2.

et, de même, ce qui suit peut annuler les changements dans tous les fichiers pour plusieurs dossiers:

git checkout -- name1/name2/* nameA/subFolder/*

rappelez-vous l'espace entre name1 / name2/ * nameA/ sous-dossier / * dans le surtout.

Note: name1, name2, nameA, sous - dossier- tous ces exemples de noms de dossiers indiquent le dossier ou le paquet où le les dossiers en question peuvent être conservés.

si vous n'avez pas encore poussé ou partagé votre commit:

git diff --stat HEAD^...HEAD | \
fgrep filename_snippet_to_revert | cut -d' ' -f2 | xargs git checkout HEAD^ --
git commit -a --amend

pour moi seulement celui-ci a fonctionné

git checkout -p filename

S'il est déjà engagé, vous pouvez revenir sur le changement pour le fichier et le propager, puis écraser new commit avec last commit.