Comment supprimer les modifications non mises en scène dans Git?

4821

Comment supprimer les modifications de ma copie de travail qui ne figurent pas dans l'index?

Lecture seulement
la source
9
git-cleansupprime uniquement les fichiers non suivis de l'arborescence de travail git-scm.com/docs/git-clean
Yega
24
Clarifier le commentaire d'Asenar ci-dessus, git-clean -dfpeut être dangereux. Il supprimera les fichiers locaux non suivis (par exemple, couverts par un .gitignore). Lisez tous ci-dessous attentivement et envisagez de passer à Git. à la place
jacanterbury
15
'git clean -df' Soyez averti! J'ai essayé et perdu des dossiers clés qui ne peuvent pas être restaurés ... Aïe!
Gabe Karkanis
46
frapper git statusdonne une suggestion sur la façon de le faire! git checkout -- .
Paulo
4
@Paulo: à partir de Juillet 2019, git statusdonne la suggestion: git restore. git restoreest une nouvelle commande exactement à cet effet. Voir ma mise à jour 2019 .
prosoitos

Réponses:

2687

Un autre moyen plus rapide est:

git stash save --keep-index --include-untracked

Vous n'avez pas besoin d'inclure --include-untrackedsi vous ne voulez pas être approfondi à ce sujet.

Après cela, vous pouvez supprimer cette cachette avec une git stash dropcommande si vous le souhaitez.

Greg Hewgill
la source
122
Et pour être minutieux, vous voudriez --include-untrackedaussi.
TJ Crowder
9
@KarimSamir: La question porte spécifiquement sur les changements qui ne sont pas dans l'index . La git resetcommande supprimera également les modifications de l'index.
Greg Hewgill
146
git checkout -. est beaucoup plus rapide
Frank
38
Ni le git stash, ni aucune variété de git checkoutne supprimera les suppressions non mises en scène. Selon la sortie de git status, la vraie réponse correcte ici est un peu de saveurgit reset HEAD
Chris Warth
127
Cela pollue la pile de stockage. git checkout -- .fait le travail avec une seule commande.
Felipe Tonello
5340

Pour tous les fichiers non classés dans le répertoire de travail actuel, utilisez:

git checkout -- .

Pour un fichier spécifique, utilisez:

git checkout -- path/to/file/to/revert

--ici pour supprimer l' ambiguïté des arguments .

Tobi
la source
117
Cela semble être la voie canonique git. c'est-à-dire exactement ce que git vous dit de faire si vous tapezgit status
ABMagil
27
Ne fonctionne pas s'il existe des fichiers non suivis. Dit Git error: The following untracked working tree files would be overwritten by checkout: ....
Michael Iles
92
newbie question, qu'est-ce que "git checkout -." signifie sémantiquement?
kaid
120
@Ninjack git checkout -- .signifie la même chose que git checkout ., sauf que vous êtes explicite sur le fait que vous ne spécifiez pas le nom de la branche. Ils disent tous les deux que je vérifie la version HEAD sur la branche sur laquelle je suis actuellement. ou './'. Si vous le faites git checkout branch-name directory-or-file-nameen général, vous obtenez la version HEAD de directory-or-file-nameon branch branch-name.
akgill
23
IMO cette variante est imparfaite, car elle ne gère pas la situation lorsque votre référentiel modifié n'est pas sur la révision HEAD au moment du nettoyage des modifications et que vous NE voulez PAS le mettre à jour vers HEAD, et que vous voulez simplement nettoyer les modifications.
alexykot
1899

Il semble que la solution complète soit:

git clean -df
git checkout -- .

git cleansupprime tous les fichiers non suivis ( avertissement : bien qu'il ne supprime pas les fichiers ignorés mentionnés directement dans .gitignore, il peut supprimer les fichiers ignorés résidant dans les dossiers ) et git checkoutefface toutes les modifications non mises en scène.

Mariusz Nowak
la source
116
Les deux autres réponses ne fonctionnent pas vraiment, celle-ci l'a fait.
John Hunt
18
@dval c'est parce que la première commande a supprimé les fichiers non indexés et la seconde a supprimé les modifications non mises en scène (des fichiers indexés). Donc, si vous n'avez eu aucun changement par étapes, cela revient à revenir au dernier commit avecgit reset --hard
Amanuel Nega
3
utilisez -dff si le répertoire non suivi est un clone git.
accuya
87
Soyez prudent en exécutant git clean -df. Si vous ne comprenez pas ce qu'il fait, vous pouvez supprimer des fichiers que vous souhaitez conserver, comme robots.txt, fichiers téléchargés, etc.
ctlockey
40
Comme l'a dit @ctlockey, la première commande supprime également les répertoires s'ils ne sont composés que de fichiers ignorés ... J'ai perdu tout un tas de fichiers de configuration sur mon projet :( Attention!
Maxime Lorant
326

Cela extrait l'index en cours du répertoire en cours, supprimant toutes les modifications des fichiers du répertoire en cours vers le bas.

git checkout .

ou celui qui extrait tous les fichiers de l'index, écrasant les fichiers de l'arborescence de travail.

git checkout-index -a -f
CB Bailey
la source
28
Salut, quelle est la différence entre git checkout .et git checkout -- .?
Evan Hu
5
@Evan: Aucune différence dans ce cas.
Robert Siemer
10
@Robert Siemer et dans le cas général?
RJFalconer
2
@Evan: mauvais endroit pour poser cette question. - Elle est sans rapport avec la question du PO et sans rapport avec la réponse ici.
Robert Siemer
14
+1 Il s'agit de la RÉPONSE DROITE, car elle gère correctement le cas où certains fichiers comportent des modifications à la fois intermédiaires et non intermédiaires. Notez que cette solution REJETTE les modifications non planifiées; si vous souhaitez les conserver, vous devez utiliser la réponse de @ greg-hewgill de git stash save --keep-index.
Rhubbarb
248
git clean -df

Nettoie l'arborescence de travail en supprimant récursivement les fichiers qui ne sont pas sous contrôle de version, à partir du répertoire actuel.

-d: Supprimer les répertoires non suivis en plus des fichiers non suivis

-f: Force (peut ne pas être nécessaire selon le clean.requireForceréglage)

Courez git help cleanpour voir le manuel

Elvis Ciotti
la source
pourquoi cette réponse n'a pas tous les votes? répondu en 2011 et toujours correct.
Eugene Braginets
106

Mon favori est

git checkout -p

Cela vous permet de rétablir sélectivement des morceaux.

Voir également:

git add -p
Ben
la source
9
J'adore la possibilité de voir le changement réel avant qu'il ne soit rejeté.
Penghe Geng
C'est ce que j'utilise. git checkout -p puis "a" pour tout accepter.
Mattis
2
Je n'y ai jamais pensé. Cela -pajoute une belle couche supplémentaire de sécurité. Combinez-le avec git clean -dpour répondre réellement à OP.
Stephan Henningsen
96

Puisqu'aucune réponse ne suggère la combinaison d'options exacte que j'utilise, la voici:

git clean -dfx
git checkout .

Voici le texte d'aide en ligne pour les git cleanoptions utilisées :

-d

Supprimez les répertoires non suivis en plus des fichiers non suivis. Si un répertoire non suivi est géré par un autre référentiel Git, il n'est pas supprimé par défaut. Utilisez l' -foption deux fois si vous voulez vraiment supprimer un tel répertoire.

-f

Si la variable de configuration Git clean.requireForcen'est pas défini false, propre Git refusera de supprimer des fichiers ou des répertoires à moins donné -f, -nou -i. Git refusera de supprimer les .gitrépertoires du sous - répertoire ou du fichier, sauf si un second -fest donné.

-x

N'utilisez pas les règles Ignorer de .gitignore(par répertoire) et $GIT_DIR/info/exclude, mais utilisez toujours les règles Ignorer fournies avec les -eoptions. Cela permet de supprimer tous les fichiers non suivis, y compris les produits de construction. Cela peut être utilisé (éventuellement en conjonction avec git reset) pour créer un répertoire de travail vierge pour tester une construction propre.

En outre, git checkout .doit être fait à la racine du dépôt.

Martin G
la source
+1 pour cette solution. En ce qui concerne votre remarque selon laquelle "git checkout. Doit être fait à la racine du dépôt", vous pourriez peut-être mentionner que nous pouvons simplement le faire à la git reset --hardplace? (qui est en fait équivalent à git reset --hard HEADet devrait fonctionner quel que soit le répertoire actuel ...)
ErikMD
2
En ce qui concerne également la première commande git clean -dfx, voici une astuce que j'utilise pour être prudent avant de l'exécuter: exécutez-le git clean -d -x -navant, pour afficher la liste des fichiers à supprimer, puis confirmez l'opération en exécutant git clean -d -x -f(je mets l'argument -n, resp. -fà la fin pour pouvoir le changer rapidement dans un terminal)
ErikMD
5
Notez rapidement que cela n'est pas réversible et que si vous avez des fichiers, .gitignorevous les perdrez. Pensez donc à sauvegarder votre projet avant cela.
Rob
69

Si vous souhaitez simplement supprimer les modifications apportées aux fichiers existants , utilisez checkout( documenté ici ).

git checkout -- .
  • Aucune branche n'est spécifiée, elle vérifie donc la branche actuelle.
  • Le double trait d'union ( --) indique à Git que ce qui suit doit être pris comme deuxième argument (chemin), que vous avez ignoré la spécification d'une branche.
  • Le point ( .) indique tous les chemins.

Si vous souhaitez supprimer les fichiers ajoutés depuis votre dernier commit, utilisez clean( documenté ici ):

git clean -i 
  • L' -ioption lance une interaction cleanpour éviter les suppressions erronées.
  • Une poignée d'autres options sont disponibles pour une exécution plus rapide; voir la documentation.

Si vous souhaitez déplacer les modifications vers un espace d'attente pour un accès ultérieur , utilisez stash( documenté ici ):

git stash
  • Toutes les modifications seront déplacées vers Git's Stash, pour un éventuel accès ultérieur.
  • Une poignée d'options sont disponibles pour un stockage plus nuancé; voir la documentation.
2540625
la source
Cela convertira exactement vos modifications et supprimera les fichiers nouvellement ajoutés de la validation précédente.
Yohan Chung
a voté pour l'explication :)
Archie G. Quiñones
62

J'ai vraiment trouvé cet article utile pour expliquer quand utiliser quelle commande: http://www.szakmeister.net/blog/2011/oct/12/reverting-changes-git/

Il existe quelques cas différents:

  1. Si vous n'avez pas mis en scène le fichier, vous utilisez git checkout. Checkout "met à jour les fichiers dans l'arborescence de travail pour correspondre à la version dans l'index". Si les fichiers n'ont pas été transférés (alias ajoutés à l'index) ... cette commande ramènera essentiellement les fichiers à ce qu'était votre dernier commit.

    git checkout -- foo.txt

  2. Si vous avez organisé le fichier, utilisez git reset. Réinitialiser modifie l'index pour correspondre à une validation.

    git reset -- foo.txt

Je soupçonne que l'utilisation git stashest un choix populaire car c'est un peu moins dangereux. Vous pouvez toujours y revenir si vous soufflez trop accidentellement lors de l'utilisation de git reset. La réinitialisation est récursive par défaut.

Jetez un œil à l'article ci-dessus pour plus de conseils.

blak3r
la source
60

La façon la plus simple de le faire est d'utiliser cette commande:

Cette commande est utilisée pour annuler les modifications dans le répertoire de travail -

git checkout -- .

https://git-scm.com/docs/git-checkout

Dans la commande git, le stockage des fichiers non suivis est réalisé en utilisant:

git stash -u

http://git-scm.com/docs/git-stash

AHM Forhadul Islam
la source
19
Deux fois, je suis venu ici, j'ai lu cette réponse et j'ai oublié .la fin. Pour moi à l'avenir: la période est indispensable !
bejado
2
Je devais me débarrasser de tous les changements locaux dans un sous-répertoire, sans souffler tous les autres changements. Cette réponse a beaucoup aidé, merci
Ally
2
Veuillez décrire ce que font les deux commandes. Il est vraiment inutile de n'avoir aucune explication.
Chris Kennedy
2
excellent. la caisse fait en une seule commande ce que la plus populaire fait en deux. peut également être suivi git clean -fdpour nettoyer les fichiers qui ne sont pas dans l'index.
oligofren
49

Si vous n'êtes pas intéressé à conserver les modifications non mises en scène (surtout si les modifications mises en scène sont de nouveaux fichiers), j'ai trouvé ceci pratique:

git diff | git apply --reverse
Joshua Kunzmann
la source
44

git checkout -f


man git-checkout:

-f, --force

Lorsque vous changez de branche, procédez même si l'index ou l'arborescence de travail diffère de HEAD. Ceci est utilisé pour supprimer les modifications locales.

Lors de la vérification des chemins à partir de l'index, n'échouez pas lors des entrées non fusionnées; au lieu de cela, les entrées non fusionnées sont ignorées.

Bijan
la source
2
Cela annulerait les modifications de l'index !! (Et l'OP exige de les laisser tels
quels
44

Lorsque vous tapez git status, (utilisez "git checkout - ..." pour ignorer les modifications dans le répertoire de travail) s'affiche.

par exemple git checkout -- .

Erdem ÖZDEMİR
la source
1
Voté car il n'aide pas à éliminer rapidement tous les fichiers. Les trois points indiquent que vous devez répertorier tous les fichiers. C'est particulièrement mauvais si vous devez jeter des tonnes de fichiers à la fois, par exemple. lors d'une fusion importante après avoir mis en place toutes les modifications que vous souhaitez conserver
usr-local-ΕΨΗΕΛΩΝ
2
Bien sûr, la commande correcte est "git checkout -." un seul point. Dans le commentaire, les trois points étaient une chose grammaticale, pour indiquer qu'il y avait beaucoup d'autres options qui auraient pu être utilisées ..
Josef.B
39

Vous pouvez utiliser git stash - si quelque chose ne va pas, vous pouvez toujours revenir de la stash. Semblable à une autre réponse ici, mais celle-ci supprime également tous les fichiers non mis en scène et également toutes les suppressions non mises en scène:

git add .
git stash

si vous vérifiez que tout va bien, jetez la cachette:

git stash drop

La réponse de Bilal Maqsood a git cleanégalement fonctionné pour moi, mais avec la cachette, j'ai plus de contrôle - si je le fais accidentellement, je peux toujours récupérer mes modifications

MISE À JOUR

Je pense qu'il y a 1 changement de plus (je ne sais pas pourquoi cela a fonctionné pour moi auparavant):

git add . -A au lieu de git add .

sans les -Afichiers supprimés ne seront pas mis en scène

Asped
la source
39

Mise à jour 2019:

Depuis Juillet 2019 , il y a eu une nouvelle commande qui fait exactement ceci: git restore.

Dans git status, maintenant, Git recommande d'utiliser cette commande au lieu de git checkoutce qu'il était auparavant.

Bien que cette commande puisse également être utilisée pour restaurer l'arborescence de travail dans une validation spécifique ou pour restaurer le contenu de l'index, par défaut, l'arborescence de travail est restaurée à l'état dans l'index (ce qui est demandé ici).

Donc, afin de restaurer les fichiers correspondant à une pathspec (en se débarrassant de leurs modifications non mises en scène), vous feriez:

git restore <pathspec>

Par exemple, pour restaurer toutes les modifications non mises en scène dans le répertoire en cours, vous pouvez exécuter:

git restore .

Si vous l'exécutez à partir de la racine du projet, il restaurera toutes les modifications non mises en scène dans l'ensemble du référentiel.

Notez que, comme avec git checkout -- .(comme l'a souligné Mariusz Nowak), cela ne supprimera que les modifications apportées aux fichiers suivis par Git et ne supprimera aucun nouveau fichier non suivi. Si vous souhaitez supprimer toutes les modifications non mises en scène, y compris les nouveaux fichiers non suivis, vous pouvez exécuter un autre:

git clean -df

Soyez très prudent avec cette commande ultérieure, car vous pourriez supprimer les fichiers dont vous n'aviez pas l'intention de vous débarrasser.


Remarque git restore: comme il s'agit d'une nouvelle commande, sa page de manuel donne un avertissement:

Cette commande est expérimentale. Le comportement peut changer.

Il est donc possible que cette réponse devienne obsolète si le comportement change à l'avenir. Il pourrait donc être judicieux d'exécuter un rapide man git-restoreavant de l'utiliser.

prosoitos
la source
2
Je voulais annuler mes modifications non mises en scène uniquement sans affecter les fichiers nouvellement ajoutés, donc cela git restore .fonctionnait parfaitement. Merci.
Saurabh Misra
3
Je l'ai fait git restore <filename>et cela a parfaitement fonctionné.
Merlin
1
Ça a bien marché pour moi.
Prométhée
1
Selon la page de manuel, git restore .restaure tous les fichiers dans le répertoire actuel, pas dans tout le référentiel.
jarno
1
Tu as raison. Merci! Je viens de le tester et en effet, c'est le cas. Elle est cependant récursive. Ainsi, lorsqu'il est exécuté à partir de la racine du projet, il s'applique à l'ensemble du référentiel. Je vais modifier ma réponse.
prosoitos
35

Au lieu d'annuler les modifications, je remets ma télécommande à l'origine. Remarque - cette méthode consiste à restaurer complètement votre dossier dans celui du dépôt.

Donc, je fais cela pour m'assurer qu'ils ne restent pas là quand je réinitialise git (plus tard - exclut les gitignores sur l'origine / le nom de la branche)

REMARQUE: Si vous souhaitez conserver les fichiers non encore suivis, mais pas dans GITIGNORE, vous pouvez ignorer cette étape, car cela effacera ces fichiers non suivis introuvables sur votre référentiel distant (merci @XtrmJosh).

git add --all

Alors je

git fetch --all

Ensuite, je réinitialise à l'origine

git reset --hard origin/branchname

Cela le ramènera à la case départ. Tout comme RE-Clonage de la branche, TOUT EN gardant tous mes fichiers gitignored localement et en place.

Mise à jour par commentaire utilisateur ci-dessous: Variation pour réinitialiser la branche actuelle de l'utilisateur.

git reset --hard @{u}
pseudo
la source
C'est mon option préférée, mais pourquoi ajoutez-vous d'abord toutes les modifications? Pour autant que je sache, cela modifie simplement la liste des répertoires dans les fichiers Git, tout en utilisant git reset --hard, cela sera de toute façon perdu tandis que les répertoires seront toujours supprimés.
XtrmJosh du
Je ne le fais pas sur Mac ou Linux, Github Windows PowerShell laisse parfois les fichiers là-bas après la réinitialisation. Je pense que c'est parce que git reset remet tous les fichiers du dépôt à leur état d'origine. S'ils ne sont pas ajoutés, ils ne sont pas touchés. Le client de bureau récupérera alors le "hé ce fichier est ici et doit être validé"
Nick
Sens fait. Je n'utilise pas Windows, donc je n'ai pas vu ce problème (je n'ai pas utilisé Windows au moins ces derniers mois, je ne m'en souviens pas beaucoup avant - c'est un énorme flou regrettable). Cela pourrait valoir la peine d'être noté dans votre réponse principale :)
XtrmJosh
J'ai également rencontré ce problème sur un Mac. Si le fichier n'est pas suivi dans le Repo, parfois git reset ne le touche pas. Je ne peux pas vraiment isoler le "POURQUOI" mais quand cela se produit, si je réinitialise, et que j'ai encore 1 fichier ou deux non engagé, j'ajoute --tout et réinitialise
Nick
2
Une belle petite variation de ce que j'aime est de git reset --hard @{u}réinitialiser la branche là où se trouve la branche actuelle de suivi à distance
user2221343
31

J'ai essayé toutes les solutions ci-dessus mais je n'ai toujours pas pu me débarrasser des nouveaux fichiers non organisés.

Utilisez git clean -fpour supprimer ces nouveaux fichiers - avec prudence cependant! Notez l'option de force.

artur
la source
21

dis simplement

git stash

Il supprimera toutes vos modifications locales. Vous pouvez également utiliser plus tard en disant

git stash apply 

ou git stash pop

piyushmandovra
la source
21

Utilisez simplement:

git stash -u

Terminé. Facile.

Si vous vous souciez vraiment de votre pile de réserves, vous pouvez suivre git stash drop. Mais à ce stade, il vaut mieux utiliser (de Mariusz Nowak):

git checkout -- .
git clean -df

Néanmoins, j'aime git stash -ule meilleur car il "rejette" toutes les modifications suivies et non suivies en une seule commande . Pourtant, git checkout -- .seuls les changements suivis sont git clean -dfignorés , et seuls les changements non suivis sont ignorés ... et taper les deux commandes est beaucoup trop de travail :)

Ben Wilde
la source
Remarque: git stash -uva bientôt (Git 2.14.x / 2.15, Q3 2017) évoluer un peu: stackoverflow.com/a/46027357/6309
VonC
Si je reçois la question de l'OP correcte, les fichiers indexés doivent être conservés. Seules les modifications sans étape doivent être supprimées. Il devrait en être ainsi git stash -kà mon avis.
snap le
21

Pour effectuer un rejet permanent: git reset --hard

Pour enregistrer les modifications pour plus tard: git stash

SANGEETHA PH
la source
16

Cela fonctionne même dans les répertoires qui sont; en dehors des autorisations git normales.

sudo chmod -R 664 ./* && git checkout -- . && git clean -dfx

M'est arrivé récemment

GlassGhost
la source
Attention cependant, le contenu ignoré par git ne conservera pas ses autorisations d'origine! Par conséquent, cela peut entraîner un risque pour la sécurité.
2xjr
@twicejr Vous vous trompez, veuillez lire git help clean"-d Supprimer les répertoires non suivis en plus des fichiers non suivis."
GlassGhost
Pourquoi avez-vous défini tous vos fichiers en lecture / écriture mondiale? Pas une bonne pratique.
Ghoti
@Ghoti my bad, 664 is correct? vous pouvez également modifier la réponse.
GlassGhost
La définition de toutes les autorisations sur 664 fait beaucoup d'hypothèses sur le type d'autorisations dont le projet a besoin. Je pense que l'utilisation de cette partie de la commande entraînera des problèmes pour certaines personnes.
ianrandmckenzie
15

vous avez une commande git très simple git checkout .

khem raj regmi
la source
14
cd path_to_project_folder  # take you to your project folder/working directory 
git checkout .             # removes all unstaged changes in working directory
vivekporwal04
la source
12

À mon avis,

git clean -df

devrait faire l'affaire. Selon la documentation Git sur git clean

git-clean - Supprime les fichiers non suivis de l'arborescence de travail

La description

Nettoie l'arborescence de travail en supprimant récursivement les fichiers qui ne sont pas sous contrôle de version, à partir du répertoire actuel.

Normalement, seuls les fichiers inconnus de Git sont supprimés, mais si l'option -x est spécifiée, les fichiers ignorés sont également supprimés. Cela peut, par exemple, être utile pour supprimer tous les produits de build.

Si des arguments optionnels ... sont fournis, seuls ces chemins sont affectés.

Les options

-d Supprime les répertoires non suivis en plus des fichiers non suivis. Si un répertoire non suivi est géré par un autre référentiel Git, il n'est pas supprimé par défaut. Utilisez l'option -f deux fois si vous voulez vraiment supprimer un tel répertoire.

-f --force Si la variable de configuration Git clean.requireForce n'est pas définie sur false, git clean refusera de s'exécuter à moins d'indiquer -f, -n ou -i.

Lahiru
la source
11

Quel que soit l'état dans lequel se trouve votre dépôt, vous pouvez toujours réinitialiser n'importe quel commit précédent:

git reset --hard <commit hash>

Cela annulera toutes les modifications apportées après cette validation.

msangel
la source
2
Cela supprimera également tout ce qui se trouve dans l'index (pas seulement les choses qui ne se trouvent pas dans l'index), ce qui est au-delà de ce que l'OP demande.
Linus Arver
10

Une autre façon de se débarrasser des nouveaux fichiers qui est plus spécifique que git clean -df (cela vous permettra de vous débarrasser de certains fichiers pas nécessairement tous), est d'ajouter d'abord les nouveaux fichiers à l'index, puis de les cacher, puis de les supprimer. planque.

Cette technique est utile lorsque, pour une raison quelconque, vous ne pouvez pas facilement supprimer tous les fichiers non suivis par un mécanisme ordinaire (comme rm).

tjb
la source
9

Ce qui suit n'est vraiment qu'une solution si vous travaillez avec un fork d'un référentiel où vous vous synchronisez régulièrement (par exemple, pull request) avec un autre référentiel. Réponse courte: supprimez fork et refork, mais lisez les avertissements sur github .

J'ai eu un problème similaire, peut-être pas identique, et je suis triste de dire que ma solution n'est pas idéale, mais elle est finalement efficace.

J'avais souvent des messages d'état git comme celui-ci (impliquant au moins 2/4 fichiers):

$ git status
# Not currently on any branch.
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       modified:   doc/PROJECT/MEDIUM/ATS-constraint/constraint_s2var.dats
#       modified:   doc/PROJECT/MEDIUM/ATS-constraint/parsing/parsing_s2var.dats
#
# 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:   doc/PROJECT/MEDIUM/ATS-constraint/constraint_s2Var.dats
#       modified:   doc/PROJECT/MEDIUM/ATS-constraint/parsing/parsing_s2Var.dats

Un œil attentif notera que ces fichiers ont des dopplegangers qui sont une seule lettre au cas où. D'une manière ou d'une autre, et je n'ai aucune idée de ce qui m'a amené sur cette voie pour commencer (comme je ne travaillais pas moi-même avec ces fichiers depuis le dépôt en amont), j'avais changé ces fichiers. Essayez les nombreuses solutions répertoriées sur cette page (et d'autres pages) ne semblent pas aider.

J'ai pu résoudre le problème en supprimant mon référentiel forké et tous les référentiels locaux et en reforgeant. Cela seul ne suffisait pas; en amont a dû renommer les fichiers en question en nouveaux noms de fichiers. Tant que vous n'avez pas de travail non engagé, pas de wikis et pas de problèmes qui divergent du référentiel en amont, tout devrait bien se passer. L'amont peut ne pas être très content de vous, c'est le moins qu'on puisse dire. Quant à mon problème, c'est sans aucun doute une erreur utilisateur car je ne suis pas très compétent avec git, mais le fait qu'il soit loin d'être facile à résoudre pointe également vers un problème avec git.

bbarker
la source
7

Lorsque vous souhaitez transférer une réserve à quelqu'un d'autre:

# add files
git add .  
# diff all the changes to a file
git diff --staged > ~/mijn-fix.diff
# remove local changes 
git reset && git checkout .
# (later you can re-apply the diff:)
git apply ~/mijn-fix.diff

[modifier] comme commenté, il est possible de nommer les cachettes. Eh bien, utilisez-le si vous voulez partager votre cachette;)

deux fois
la source
5
En fait, la cachette Git peut avoir un titre. Par exemple git stash save "Feature X work in progress".
Colin D Bennett
7

Vous pouvez créer votre propre alias qui décrit comment le faire de manière descriptive.

J'utilise l'alias suivant pour ignorer les modifications.


Ignorer les modifications dans une (liste de) fichier (s) dans l'arborescence de travail

discard = checkout --

Ensuite, vous pouvez l'utiliser comme suivant pour ignorer toutes les modifications:

discard .

Ou juste un fichier:

discard filename

Sinon, si vous souhaitez supprimer toutes les modifications et également les fichiers non suivis, j'utilise un mélange de vérification et de nettoyage:

Nettoyer et ignorer les modifications et les fichiers non suivis dans l'arborescence de travail

cleanout = !git clean -df && git checkout -- .

Donc l'utilisation est simple comme prochaine:

cleanout

Maintenant est disponible dans le prochain dépôt Github qui contient beaucoup d'alias:

Pau
la source
7

J'ai eu une situation étrange où un fichier est toujours non organisé, cela m'aide à résoudre.

git rm .gitattributes
git add -A
git reset --hard

SDV
la source