Comment dois-je jeter unstaged changements dans Git?

https://stackoverflow.com/questions/52704

09-06-2019
|

Question

Comment puis-je annuler les modifications dans la copie de travail qui ne sont pas dans l'index?

La solution

Un autre moyen plus rapide est:

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

Vous n'avez pas besoin d'inclure --include-untracked si vous ne voulez pas être approfondie à ce sujet.

Après cela, vous pouvez déposer que stash avec un git stash drop commande si vous le souhaitez.

Autres conseils

Pour tous les unstaged fichiers dans le répertoire de travail en cours d'utilisation:

git checkout -- .

Pour un fichier spécifique d'utilisation:

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

-- ici pour les supprimer argument ambiguation.

Il semble que la solution complète est:

git clean -df
git checkout -- .

git clean supprime tous les sans traces (fichiers deavertissement:bien qu'il ne supprimez pas les fichiers ignorés mentionné directement dans .gitignore, il peut supprimer les fichiers ignorés résidant dans des dossiers) et git checkout efface tous les unstaged changements.

Ce qui vérifie l'indice actuel du répertoire courant, de jeter toutes les modifications dans les fichiers à partir du répertoire courant vers le bas.

git checkout .

ou ce qui vérifie tous les fichiers de l'index, de l'écrasement de travail de l'arborescence de fichiers.

git checkout-index -a -f

git clean -df

Nettoie l'arbre de travail par récursivement de la suppression des fichiers qui ne sont pas sous contrôle de version, en commençant à partir du répertoire courant.

-d:Retirer sans traces répertoires en plus sans traces de fichiers

-f:La Force (qui peut ne pas être nécessaire en fonction de la clean.requireForce réglage)

Exécuter git help clean voir le manuel

Mon préféré est

git checkout -p

Qui vous permet de manière sélective revenir les morceaux.

Voir aussi:

git add -p

Depuis pas de réponse suggère l'exacte option de combinaison que j'utilise, elle est ici:

git clean -dfx
git checkout .

C'est à l'aide en ligne de texte pour l'utilisé git clean options:

-d

Retirer sans traces répertoires en plus sans traces de fichiers.Si un sans traces répertoire est géré par un autre dépôt Git, il n'est pas retiré par défaut.Utilisation -f option deux fois si vous voulez vraiment supprimer ce répertoire.

-f

Si la variable de configuration de Git clean.requireForce n'est pas définie à false, Git propre refusera de supprimer des fichiers ou des répertoires, à moins que -f, -n, ou -i.Git va refuser de supprimer des répertoires à l'intérieur de la .git sous-répertoire ou un fichier, à moins d'une seconde -f est donné.

-x

N'utilisez pas l'ignorer les règles de .gitignore (par répertoire) et $GIT_DIR/info/exclude, mais ne utilisez encore l'ignorer des règles avec -e des options.Cela permet de supprimer tous les sans traces de fichiers, y compris les produits de construction.Ceci peut être utilisé (éventuellement en collaboration avec des git reset) pour créer un magnifique répertoire de travail pour tester une nouvelle version.

Aussi, git checkout . doit être fait dans la racine de l'opération.

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

Il y a deux cas différents:

Si vous n'avez pas mis en scène le fichier, puis vous utilisez git checkout.La commande "mise à jour des fichiers dans l'arbre de travail pour correspondre à la version de l'index".Si les fichiers n'ont pas été mis en scène (aka ajoutés à l'index)...cette commande vous essentiellement revenir les fichiers à ce que votre dernier commit a été.

git checkout -- foo.txt
Si vous avez mis en scène le fichier, puis utiliser git reset.Réinitialiser les modifications de l'index pour correspondre à un commit.

git reset -- foo.txt

Je soupçonne que l'utilisation d' git stash est un choix populaire, car il est un peu moins dangereux.Vous pouvez toujours revenir en arrière si vous avez accidentellement coup trop loin lors de l'utilisation de git reset.Reset est récursive par défaut.

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

La façon la plus simple de le faire est par l'utilisation de 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, cachant sans traces de fichiers est atteint par l'utilisation de:

git stash -u

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

Si vous ne souhaitez pour supprimer des changements à des fichiers existants, utilisation checkout (documenté ici).

git checkout -- .

Aucune branche n'est spécifié, alors il vérifie la branche courante.
Le double tiret (--) indique à Git que ce qui suit doit être pris comme deuxième argument (chemin), que vous avez sauté la spécification d'une branche.
La période (.) indique tous les chemins.

Si vous voulez pour supprimer les fichiers ajoutés depuis votre dernière validation, utilisation clean (documenté ici):

git clean -i

L' -i option lance interactive clean, pour éviter trompe suppressions.
Une poignée d'autres options sont disponibles pour le plus rapide d'exécution;consultez la documentation.

Si vous le souhaitez pour déplacer des modifications à une exploitation de l'espace pour un accès ultérieur, utilisation stash (documenté ici):

git stash

Toutes les modifications seront déplacés vers Git s Stash, pour le plus tard possible l'accès.
Une poignée d'options sont disponibles pour le plus nuancée accrocher;consultez la documentation.

Si vous n'êtes pas intéressé à garder le unstaged changements (surtout si la mise en scène changements sont de nouveaux fichiers), j'ai trouvé cette pratique:

git diff | git apply --reverse

Comme vous le type git status, (utilisez "git checkout -- ..." pour annuler les modifications dans le répertoire de travail) est indiqué.

par exemple git checkout -- .

git checkout -f

man git-checkout:

-f, --force

Lors de la commutation de branches, aller de l'avant même si l'indice ou de l'arbre de travail diffère de la TÊTE.Ce est utilisé pour jeter les modifications locales.

Lors de la vérification des chemins de l'index, ne manquent pas sur non fusionné les entrées;au lieu de cela, non fusionné entrées sont ignorées.

Vous pouvez utiliser git stash - si quelque chose va mal, vous pouvez toujours revenir à la cachette.Semblable à une autre réponse ici, mais celui-ci supprime également tous les unstaged fichiers et aussi tous les unstaged supprime:

git add .
git stash

si vous vérifiez que tout est OK, jeter le ranger:

git stash drop

La réponse de Bilal Maqsood avec git clean a également travaillé pour moi, mais avec la réserve que j'ai plus de contrôle - si-je faire qqch accidentellement, je peux encore faire mes modifications

Mise à JOUR

Je pense qu'il est de 1 à plus de changements (je ne sais pas pourquoi cela a fonctionné pour moi avant):

git add . -A au lieu de git add .

sans l' -A les fichiers supprimés ne seront pas mis en scène

Au lieu de jeter les changements, j'ai réinitialisé mon distance à l'origine.Remarque - cette méthode est de restaurer complètement votre dossier à celui de la pension".

Donc ce que je fais pour être sûr de ne pas s'asseoir là quand j'ai git reset (plus tard, à l'exclusion du gitignores sur l'Origine/branchname)

NOTE:Si vous souhaitez conserver les fichiers non encore identifiés, mais pas dans GITIGNORE vous pouvez sauter cette étape, car elle va effacer ces sans traces de fichiers ne se trouvent pas sur votre dépôt distant (merci @XtrmJosh).

git add --all

Puis J'Ai

git fetch --all

Puis-je réinitialiser à l'origine

git reset --hard origin/branchname

Qui va le remettre à la place une.Tout comme RE-Clonage de la branche, tout en gardant toutes mes gitignored fichiers en local et en place.

Mise à jour par l'utilisateur commentaire ci-dessous:La Variation de réinitialiser le à quelle que soit la branche courante, l'utilisateur est sur.

git reset --hard @{u}

J'ai essayé toutes les solutions ci-dessus, mais ne pouvait toujours pas se débarrasser de nouvelles, unstaged fichiers.

Utilisation git clean -f pour supprimer ces nouveaux fichiers - avec prudence tout de même! Remarque l'option force.

simplement dire

git stash

Il va supprimer toutes vos modifications locales.Vous pouvez également utiliser plus tard en disant:

git stash apply

ou git stash pop

Utilisez simplement:

git stash -u

Fait.Facile.

Si vous vraiment de soins au sujet de votre cachette de la pile, alors vous pouvez suivre avec git stash drop.Mais à ce stade, vous êtes mieux de les utiliser (à partir de Mariusz Nowak):

git checkout -- .
git clean -df

Néanmoins, j'aime git stash -u le meilleur parce qu'il "rejette" toutes les marques et sans traces des changements dans la juste une commande.Encore git checkout -- . seuls les rejets de suivi des modifications, et git clean -df seuls les rejets sans traces de changements...et de taper les deux commandes est loin trop de travail :)

Cela fonctionne même dans des répertoires qui sont;à l'extérieur de la normale de git autorisations.

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

M'est arrivé récemment

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

N'importe quel état de votre dépôt est, vous pouvez toujours réinitialiser pour toute livraison antérieure:

git reset --hard <commit hash>

Cela va annuler toutes les modifications qui ont été faites après que s'engager.

Une autre façon de se débarrasser de nouveaux fichiers que est plus spécifique que git propre -df (il vous permettra de vous débarrasser de certains fichiers qui ne sont pas nécessairement tous), est d'ajouter les nouveaux fichiers de l'indice d'abord, puis les ranger, puis déposez la cachette.

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

À mon avis,

git clean -df

devrait faire l'affaire.Comme par Git documentation sur git propre

git-propre - Retirer sans traces de fichiers à partir de l'arbre de travail

Description

Nettoie l'arbre de travail de manière récursive par la suppression des fichiers ne sont pas sous contrôle de version, en commençant à partir du répertoire courant.

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

Si aucune option ...les arguments sont donnés, seuls les chemins sont touchées.

Options

-d Retirer sans traces répertoires en plus sans traces de fichiers.Si un sans traces répertoire est géré par un autre dépôt Git, il est n'est pas éliminé par défaut.L'option-f deux fois si vous voulez vraiment supprimer un répertoire.

-f --force Si le Git variable de configuration propre.requireForce est pas défini à false, git propre refuse de fonctionner, à moins que l'option-f, -n ou-je.

Ce qui suit n'est vraiment qu'une solution si vous travaillez avec une fourchette d'un référentiel où vous régulièrement synchroniser (par ex.pull request) avec un autre repo.Réponse courte:supprimer la fourche et refork, mais lire les mises en garde sur github.

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

J'ai serait ont souvent git status message (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 remarquera que ces fichiers ont des dopplegangers une seule lettre dans le cas off.En quelque sorte, et je n'ai aucune idée de ce qui m'a amené sur cette voie pour commencer (comme je l'ai été de ne pas travailler avec ces fichiers moi-même de l'amont repo), j'avais mis ces fichiers.Essayez les nombreuses solutions listées sur cette page (et les autres pages) ne semble pas aider.

J'ai été en mesure de résoudre le problème par la suppression de mon fourche dépôt et les dépôts locales, et reforking.Ce n'était pas suffisant;en amont a pour renommer les fichiers en question pour de nouveaux noms de fichiers. Tant que vous n'avez pas de uncommited de travail, pas de wikis, et pas de questions qui divergent à partir de l'amont du référentiel, vous devriez être bien.En amont peut ne pas être très heureux avec vous, pour dire le moins.Comme pour mon problème, c'est sans doute une erreur de l'utilisateur, comme je ne suis pas compétent avec git, mais le fait qu'il est loin d'être facile à fixer des points à un problème avec git en tant que bien.

Si vous voulez transférer d'une cachette à 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

[edit] comme le faisait remarquer, il le possible nom de caches.Eh bien, utilisez-le si vous voulez partager votre cachette ;)

Vous pouvez créer vos propres alias qui explique comment le faire d'une manière descriptive.

J'ai utiliser la prochaine alias pour ignorer les changements.

Annuler les modifications dans un (liste des) fichier(s) dans l'arbre de travail

discard = checkout --

Ensuite, vous pouvez l'utiliser comme prochaine pour annuler tous les changements:

discard .

Ou tout simplement un fichier:

discard filename

Sinon, si vous souhaitez annuler toutes les modifications et aussi la sans traces de fichiers, j'utilise un mélange de caisse et nettoyage:

Nettoyer et éliminer les modifications et sans traces des fichiers dans l'arbre de travail

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

Ainsi, l'utilisation est simple comme suivant:

cleanout

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

https://github.com/GitAlias/gitalias

Si toutes les mises en scène des fichiers ont été effectivement commise, alors que la direction générale peut simplement être réinitialisé par exempleà partir de votre interface graphique avec environ trois clics de souris: Branche, Réinitialiser, Oui!

Donc, ce que je fais souvent, dans la pratique, pour revenir indésirables des changements locaux, c'est commettre toutes les bonnes choses, et puis réinitialiser la branche.

Si les bonnes choses est engagé dans un seul commit, vous pouvez utiliser le bouton "modifier le dernier commit" pour le ramener à être mis en scène ou unstaged si vous voulez, à terme, de s'engager un peu différemment.

Cela pourrait ne pas être la solution technique que vous recherchez pour votre problème, mais je trouve une solution très pratique.Il vous permet d'ignorer unstaged les modifications de manière sélective, en réinitialisant les changements que vous n'aimez pas et de garder ceux qui vous plaisent.

Donc en résumé, je n'ai tout simplement s'engager, direction générale de réinitialisation, et modifier le dernier commit.

Si vous êtes dans le cas de sous-module et pas d'autres solutions à essayer:

Pour vérifier quel est le problème (peut-être un "sale" affaire) utilisation:

git diff
Pour supprimer cachette

git submodule update

J'ai eu une drôle de situation où un fichier est toujours unstaged, cela m'aide à résoudre.

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

Si c'est presque impossible de déterminer les modifications des fichiers, avez-vous envisagé de les ignorer?Si cette déclaration est à droite et vous ne touchez pas à ces fichiers au cours de votre développement, cette commande peut être utile:

git update-index --assume-unchanged file_to_ignore

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow