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

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

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.

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 .

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.

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

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

Mon favori est

git checkout -p

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

Voir également:

git add -p

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.

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.

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.

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

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

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.

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

par exemple git checkout -- .

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

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.

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}

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.

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

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 :)

Pour effectuer un rejet permanent: git reset --hard

Pour enregistrer les modifications pour plus tard: git stash

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

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

cd path_to_project_folder  # take you to your project folder/working directory 
git checkout .             # removes all unstaged changes in working directory

À 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.

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.

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).

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.

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;)

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:

• https://github.com/GitAlias/gitalias

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