Comment annuler 'git add' avant de valider?

J'ai par erreur ajouté des fichiers à Git en utilisant la commande:

git add myfile.txt

Je n'ai pas encore couru git commit. Existe-t-il un moyen d'annuler cela, afin que ces fichiers ne soient pas inclus dans la validation?

Vous pouvez annuler git addavant de valider avec

git reset <file>

ce qui le supprimera de l'index en cours (la liste "sur le point d'être validé") sans rien changer d'autre.

Vous pouvez utiliser

git reset

sans aucun nom de fichier pour annuler toutes les modifications dues. Cela peut être utile lorsqu'il y a trop de fichiers pour être répertoriés un par un dans un délai raisonnable.

Dans les anciennes versions de Git, les commandes ci-dessus sont équivalentes à git reset HEAD <file>et git reset HEADrespectivement, et échoueront si HEADelles ne sont pas définies (parce que vous n'avez encore effectué aucune validation dans votre référentiel) ou ambiguë (parce que vous avez créé une branche appelée HEAD, ce qui est stupide) que vous ne devriez pas faire). Cela a été changé dans Git 1.8.2 , cependant, donc dans les versions modernes de Git, vous pouvez utiliser les commandes ci-dessus avant même de faire votre premier commit:

"git reset" (sans options ni paramètres) utilisé pour l'erreur lorsque vous n'avez aucun commit dans votre historique, mais il vous donne maintenant un index vide (pour correspondre à un commit inexistant sur lequel vous n'êtes même pas).

Tu veux:

git rm --cached <added_file_to_undo>

Raisonnement:

Quand j'étais nouveau dans ce domaine, j'ai d'abord essayé

git reset .

(pour annuler l'intégralité de mon ajout initial), uniquement pour obtenir ce message (pas si) utile:

fatal: Failed to resolve 'HEAD' as a valid ref.

Il s'avère que c'est parce que la référence HEAD (branche?) N'existe qu'après le premier commit. Autrement dit, vous rencontrerez le même problème de débutant que moi si votre flux de travail, comme le mien, était quelque chose comme:

1. cd dans mon super nouveau répertoire de projet pour essayer Git, la nouvelle hotness
2. git init
3. git add .

4. git status

   ... beaucoup de parchemins de merde par ...

   => Merde, je ne voulais pas ajouter tout ça.

5. google "annuler git ajouter"

   => trouver Stack Overflow - yay

6. git reset .

   => fatal: échec de la résolution de 'HEAD' en tant que référence valide.

Il s'avère en outre qu'il y a un bogue enregistré contre l'inefficacité de cela dans la liste de diffusion.

Et que la bonne solution était juste là dans la sortie d'état Git (que, oui, j'ai glissée comme «merde)

...
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
...

Et la solution est en effet d'utiliser git rm --cached FILE.

Notez les avertissements ailleurs ici - git rmsupprime votre copie de travail locale du fichier, mais pas si vous utilisez --cached . Voici le résultat de git help rm:

--cached Utilisez cette option pour annuler la mise en scène et supprimer des chemins uniquement de l'index. Les fichiers d'arborescence de travail, modifiés ou non, seront conservés.

Je passe à utiliser

git rm --cached .

pour tout supprimer et recommencer. Cela n'a pas fonctionné cependant, car bien que add .récursif, il s'avère rmnécessaire -rde rechuter. Soupir.

git rm -r --cached .

Bon, maintenant je suis de retour à l'endroit où j'ai commencé. La prochaine fois, je vais utiliser -npour faire un essai à sec et voir ce qui sera ajouté:

git add -n .

J'ai tout zippé dans un endroit sûr avant de faire confiance git help rmà --cachedne rien détruire (et si je l'ai mal orthographié).

Si vous tapez:

git status

Git vous dira ce qui est mis en scène, etc., y compris des instructions sur la façon de mettre en scène:

use "git reset HEAD <file>..." to unstage

Je trouve que Git fait un très bon travail en me poussant à faire ce qu'il faut dans des situations comme celle-ci.

Remarque: les versions récentes de Git (1.8.4.x) ont changé ce message:

(use "git rm --cached <file>..." to unstage)

Pour clarifier: git adddéplace les modifications du répertoire de travail actuel vers la zone de transfert (index).

Ce processus est appelé mise en scène . La commande la plus naturelle pour mettre en scène les modifications (fichiers modifiés) est donc la plus évidente:

git stage

git add est juste un alias plus facile à taper pour git stage

Dommage qu'il n'y ait git unstagepas de git unaddcommandes ni . La question pertinente est plus difficile à deviner ou à retenir, mais elle est assez évidente:

git reset HEAD --

Nous pouvons facilement créer un alias pour cela:

git config --global alias.unadd 'reset HEAD --'
git config --global alias.unstage 'reset HEAD --'

Et enfin, nous avons de nouvelles commandes:

git add file1
git stage file2
git unadd file2
git unstage file1

Personnellement, j'utilise des alias encore plus courts:

git a # For staging
git u # For unstaging

En plus de la réponse acceptée, si votre fichier ajouté par erreur était énorme, vous remarquerez probablement que, même après l'avoir supprimé de l'index avec ' git reset', il semble toujours occuper de l'espace dans le .gitrépertoire.

Ce n'est rien à craindre; le fichier est en effet toujours dans le référentiel, mais uniquement comme un "objet lâche". Il ne sera pas copié dans d'autres référentiels (via clone, push), et l'espace sera finalement récupéré - mais peut-être pas très bientôt. Si vous êtes anxieux, vous pouvez exécuter:

git gc --prune=now

Mise à jour (ce qui suit est ma tentative de dissiper une certaine confusion qui peut résulter des réponses les plus votées):

Alors, qui est le véritable undo de git add?

git reset HEAD <file> ?

ou

git rm --cached <file>?

À proprement parler, et si je ne me trompe pas: aucun .

git add ne peut pas être annulé - en toute sécurité, en général.

Rappelons d'abord ce que git add <file>fait réellement:

1. S'il <file>n'a pas été suivi auparavant , l' git add ajoute au cache , avec son contenu actuel.

2. Si <file>a déjà été suivi , git add enregistre le contenu actuel (instantané, version) dans le cache. Dans Git, cette action est toujours appelée add , (pas simplement la mettre à jour ), car deux versions différentes (instantanés) d'un fichier sont considérées comme deux éléments différents: par conséquent, nous ajoutons effectivement un nouvel élément au cache, pour être finalement commis plus tard.

À la lumière de cela, la question est légèrement ambiguë:

J'ai par erreur ajouté des fichiers en utilisant la commande ...

Le scénario de l'OP semble être le premier (fichier non suivi), nous voulons que le "défaire" supprime le fichier (pas seulement le contenu actuel) des éléments suivis. Si tel est le cas, vous pouvez exécuter git rm --cached <file>.

Et nous pourrions également courir git reset HEAD <file>. C'est généralement préférable, car cela fonctionne dans les deux scénarios: il effectue également l'annulation lorsque nous avons ajouté à tort une version d'un élément déjà suivi.

Mais il y a deux mises en garde.

Premièrement: il n'y a (comme indiqué dans la réponse) qu'un seul scénario dans lequel git reset HEADcela ne fonctionne pas, mais git rm --cachedfonctionne: un nouveau référentiel (pas de commit). Mais, vraiment, c'est un cas pratiquement hors de propos.

Deuxièmement: sachez que git reset HEAD vous ne pouvez pas récupérer par magie le contenu du fichier précédemment mis en cache, il le resynchronise simplement à partir de HEAD. Si notre erreur a git addremplacé une version précédente non validée par étapes, nous ne pouvons pas la récupérer. C'est pourquoi, à proprement parler, nous ne pouvons pas annuler [*].

Exemple:

$ git init
$ echo "version 1" > file.txt
$ git add file.txt   # First add of file.txt
$ git commit -m 'first commit'
$ echo "version 2" > file.txt
$ git add  file.txt   # Stage (don't commit) "version 2" of file.txt
$ git diff --cached file.txt
-version 1
+version 2
$ echo "version 3" > file.txt
$ git diff  file.txt
-version 2
+version 3
$ git add  file.txt    # Oops we didn't mean this
$ git reset HEAD file.txt  # Undo?
$ git diff --cached file.txt  # No dif, of course. stage == HEAD
$ git diff file.txt   # We have irrevocably lost "version 2"
-version 1
+version 3

Bien sûr, ce n'est pas très critique si nous suivons simplement le flux de travail paresseux habituel de faire `` git add '' uniquement pour ajouter de nouveaux fichiers (cas 1), et nous mettons à jour le nouveau contenu via la git commit -acommande commit , .

^{* (Edit: ce qui précède est pratiquement correct, mais il peut toujours y avoir des moyens légèrement hack / alambiqués pour récupérer des modifications qui ont été mises en scène, mais non validées puis écrasées - voir les commentaires de Johannes Matokic et iolsmit)}

Annuler un fichier qui a déjà été ajouté est assez simple avec Git. Pour réinitialiser myfile.txt, qui ont déjà été ajoutés, utilisez:

git reset HEAD myfile.txt

Explication:

Après avoir organisé les fichiers indésirables, vous pouvez annuler git reset. Headest la tête de votre fichier dans le local et le dernier paramètre est le nom de votre fichier.

J'ai créé les étapes dans l'image ci-dessous pour plus de détails pour vous, y compris toutes les étapes qui peuvent se produire dans ces cas:

git rm --cached . -r

"supprimera" tout ce que vous avez ajouté de votre répertoire actuel de manière récursive

Courir

git gui

et supprimez tous les fichiers manuellement ou en les sélectionnant tous et en cliquant sur le bouton « Unstage from commit» .

Git a des commandes pour chaque action imaginable, mais il a besoin de connaissances approfondies pour bien faire les choses et à cause de cela, il est contre-intuitif au mieux ...

Ce que vous avez fait auparavant:

• Changé un fichier et utilisé git add ., ou git add <file>.

Ce que tu veux:

• Supprimez le fichier de l'index, mais conservez-le versionné et laissez les modifications non validées dans la copie de travail:

  git reset head <file>
  

• Réinitialisez le fichier dans le dernier état de HEAD, annulant les modifications et les supprimant de l'index:

  # Think `svn revert <file>` IIRC.
  git reset HEAD <file>
  git checkout <file>
  
  # If you have a `<branch>` named like `<file>`, use:
  git checkout -- <file>

  Ceci est nécessaire car git reset --hard HEADne fonctionnera pas avec des fichiers uniques.

• Supprimer <file>de l'index et du versionnage, en conservant le fichier non versionné avec des modifications dans la copie de travail:

  git rm --cached <file>
  

• Supprimer <file>complètement de la copie de travail et du versioning:

  git rm <file>
  

La question n'est pas clairement posée. La raison en est que cela git adda deux significations:

1. ajouter un nouveau fichier à la zone de transit, puis annuler avecgit rm --cached file .
2. en ajoutant un fichier modifié à la zone de transit, puis annulez avec git reset HEAD file.

En cas de doute, utilisez

git reset HEAD file

Parce qu'il fait la chose attendue dans les deux cas.

Attention: si vous faites git rm --cached filesur un fichier qui a été modifié (un fichier qui existait auparavant dans le référentiel), alors le fichier sera supprimé surgit commit ! Il existera toujours dans votre système de fichiers, mais si quelqu'un d'autre tire votre commit, le fichier sera supprimé de leur arborescence de travail.

git statusvous dira si le fichier était un nouveau fichier ou modifié :

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

    new file:   my_new_file.txt
    modified:   my_modified_file.txt

Si vous êtes sur votre commit initial et que vous ne pouvez pas l'utiliser git reset, déclarez simplement "Git faillite" et supprimez le .gitdossier et recommencez

Comme bon nombre des autres réponses, vous pouvez utiliser git reset

MAIS:

J'ai trouvé ce super petit post qui ajoute en fait la commande Git (enfin, un alias) pour git unadd: voir git unadd pour plus de détails ou ..

Simplement,

git config --global alias.unadd "reset HEAD"

Maintenant vous pouvez

git unadd foo.txt bar.txt

Utilisez git add -ipour supprimer les fichiers que vous venez d'ajouter de votre prochain commit. Exemple:

Ajout du fichier que vous ne vouliez pas:

$ git add foo
$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       new file:   foo
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
# [...]#

Entrer dans l'ajout interactif pour annuler votre ajout (les commandes tapées à git ici sont "r" (revert), "1" (la première entrée de la liste affiche revert), 'return' pour abandonner le mode revert et "q" (quitter):

$ git add -i
           staged     unstaged path
  1:        +1/-0      nothing foo

*** Commands ***
  1: [s]tatus     2: [u]pdate     3: [r]evert     4: [a]dd untracked
  5: [p]atch      6: [d]iff       7: [q]uit       8: [h]elp
What now> r
           staged     unstaged path
  1:        +1/-0      nothing [f]oo
Revert>> 1
           staged     unstaged path
* 1:        +1/-0      nothing [f]oo
Revert>> 
note: foo is untracked now.
reverted one path

*** Commands ***
  1: [s]tatus     2: [u]pdate     3: [r]evert     4: [a]dd untracked
  5: [p]atch      6: [d]iff       7: [q]uit       8: [h]elp
What now> q
Bye.
$

C'est ça! Voici votre preuve, montrant que "foo" est de retour sur la liste non suivie:

$ git status
# On branch master
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
# [...]
#       foo
nothing added to commit but untracked files present (use "git add" to track)
$

git removeou git rmpeut être utilisé pour cela, avec le --cacheddrapeau. Essayer:

git help rm

Voici un moyen d'éviter ce problème vexant lorsque vous démarrez un nouveau projet:

• Créez le répertoire principal de votre nouveau projet.
• Courir git init .
• Créez maintenant un fichier .gitignore (même s'il est vide).
• Validez votre fichier .gitignore.

Git le rend vraiment difficile à faire git resetsi vous n'avez aucun commit. Si vous créez un minuscule commit initial juste pour le plaisir d'en avoir un, après cela, vous pouvez git add -Aet git resetautant de fois que vous le souhaitez pour que tout soit correct.

Un autre avantage de cette méthode est que si vous rencontrez des problèmes de fin de ligne plus tard et devez actualiser tous vos fichiers, c'est facile:

• Découvrez ce commit initial. Cela supprimera tous vos fichiers.
• Vérifiez à nouveau votre dernier commit. Cela récupérera de nouvelles copies de vos fichiers, en utilisant vos paramètres de fin de ligne actuels.

Peut-être que Git a évolué depuis que vous avez posé votre question.

$> git --version
git version 1.6.2.1

Maintenant, vous pouvez essayer:

git reset HEAD .

Cela devrait être ce que vous recherchez.

Notez que si vous ne spécifiez pas de révision, vous devez inclure un séparateur. Exemple de ma console:

git reset <path_to_file>
fatal: ambiguous argument '<path_to_file>': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions

git reset -- <path_to_file>
Unstaged changes after reset:
M    <path_to_file>

(Git version 1.7.5.4)

Pour supprimer de nouveaux fichiers de la zone de transit (et uniquement en cas de nouveau fichier), comme suggéré ci-dessus:

git rm --cached FILE

Utilisez rm --cached uniquement pour les nouveaux fichiers ajoutés accidentellement.

Pour réinitialiser chaque fichier dans un dossier particulier (et ses sous-dossiers), vous pouvez utiliser la commande suivante:

git reset *

Utilisez la *commande pour gérer plusieurs fichiers à la fois:

git reset HEAD *.prj
git reset HEAD *.bmp
git reset HEAD *gdb*

etc.

Il suffit de taper git resetpour revenir en arrière et c'est comme si vous n'aviez jamais tapé git add .depuis votre dernier commit. Assurez-vous que vous vous êtes déjà engagé.

Supposons que je crée un nouveau fichier newFile.txt:

Supposons que j'ajoute le fichier accidentellement git add newFile.txt:

Maintenant , je veux défaire ce module, avant de commettre, git reset newFile.txt:

Pour un fichier spécifique:

• git reset my_file.txt
• git checkout my_file.txt

Pour tous les fichiers ajoutés:

• git reset.
• git checkout.

Remarque: l' extraction modifie le code dans les fichiers et passe au dernier état mis à jour (validé). réinitialiser ne change pas les codes; il réinitialise simplement l'en-tête.

Cette commande décompose vos modifications:

git reset HEAD filename.txt

Vous pouvez aussi utiliser

git add -p 

pour ajouter des parties de fichiers.

Il existe également un mode interactif:

git add -i

Choisissez l'option 3 pour annuler l'ajout de fichiers. Dans mon cas, je veux souvent ajouter plus d'un fichier, et avec le mode interactif, vous pouvez utiliser des chiffres comme celui-ci pour ajouter des fichiers. Cela prendra tout sauf 4: 1, 2, 3 et 5

Pour choisir une séquence, tapez simplement 1-5 pour prendre tout de 1 à 5.

Fichiers de transfert Git

Pour annuler git add, utilisez:

git reset filename

git reset filename.txt

Supprime un fichier nommé filename.txt de l'index en cours, la zone "sur le point d'être validé", sans rien changer d'autre.

git add myfile.txt # Cela ajoutera votre fichier à la liste à valider

Tout à fait à l'opposé de cette commande,

git reset HEAD myfile.txt  # This will undo it.

vous serez donc dans l'état précédent. Spécifié sera à nouveau dans la liste non suivie (état précédent).

Il réinitialisera votre tête avec ce fichier spécifié. donc, si votre tête n'en a pas les moyens, il la réinitialisera simplement.

Dans Sourcetree, vous pouvez le faire facilement via l'interface graphique. Vous pouvez vérifier quelle commande Sourcetree utilise pour supprimer un fichier.

J'ai créé un nouveau fichier et l'ai ajouté à Git. Ensuite, je l'ai mis en scène en utilisant l'interface graphique de Sourcetree. Voici le résultat:

Suppression des fichiers [08/12/15 10:43] git -c diff.mnemonicprefix = false -c core.quotepath = false -c credential.helper = sourcetree reset -q - chemin / vers / fichier / nomfichier.java

Sourcetree utilise resetpour décompresser de nouveaux fichiers.

git reset filename.txt  

Supprime un fichier nommé filename.txt de l'index en cours, la zone "sur le point d'être validé", sans rien changer d'autre.