Supprimer des fichiers de Git commit

J'utilise Git et j'ai engagé quelques fichiers en utilisant

git commit -a

Plus tard, j'ai découvert qu'un fichier avait été ajouté par erreur à la validation.

Comment supprimer un fichier du dernier commit?

Je pense que d'autres réponses ici sont fausses, car il s'agit de déplacer les fichiers validés par erreur dans la zone de transfert à partir de la validation précédente, sans annuler les modifications qui leur ont été apportées. Cela peut être fait comme l'a suggéré Paritosh Singh:

git reset --soft HEAD^ 

ou

git reset --soft HEAD~1

Réinitialisez ensuite les fichiers indésirables afin de les exclure du commit:

git reset HEAD path/to/unwanted_file

Maintenant, validez à nouveau, vous pouvez même réutiliser le même message de validation:

git commit -c ORIG_HEAD  

ATTENTION ! Si vous souhaitez uniquement supprimer un fichier de votre commit précédent et le conserver sur le disque , lisez la réponse de juzzlin juste au-dessus.

S'il s'agit de votre dernier commit et que vous souhaitez supprimer complètement le fichier de votre référentiel local et distant , vous pouvez:

1. supprimer le fichier git rm <file>
2. valider avec modifier le drapeau: git commit --amend

Le drapeau de modification indique à git de recommencer, mais "fusionner" (pas dans le sens de fusionner deux branches) cette validation avec la dernière validation.

Comme indiqué dans les commentaires, utiliser git rmici, c'est comme utiliser la rmcommande elle-même!

Les réponses existantes parlent toutes de la suppression des fichiers indésirables du dernier commit.

Si vous souhaitez supprimer des fichiers indésirables d'un ancien commit (même poussé) et ne souhaitez pas créer un nouveau commit, ce qui n'est pas nécessaire, en raison de l'action:

1.

Recherchez le commit auquel vous souhaitez que le fichier soit conforme.

git checkout <commit_id> <path_to_file>

vous pouvez le faire plusieurs fois si vous souhaitez supprimer de nombreux fichiers.

2.

git commit -am "remove unwanted files"

3.

Trouvez le commit_id du commit sur lequel les fichiers ont été ajoutés par erreur , disons "35c23c2" ici

git rebase 35c23c2~1 -i  // notice: "~1" is necessary

Cette commande ouvre l'éditeur en fonction de vos paramètres. La valeur par défaut est vim.

Déplacez le dernier commit, qui devrait être "supprimer les fichiers indésirables", à la ligne suivante du commit incorrect ("35c23c2" dans notre cas), et définissez la commande comme suit fixup:

pick 35c23c2 the first commit
fixup 0d78b28 remove unwanted files

Vous devriez être bon après avoir enregistré le fichier.

Pour finir :

git push -f

Si vous rencontrez malheureusement des conflits, vous devez les résoudre manuellement.

Comme l'indique la réponse acceptée, vous pouvez le faire en réinitialisant l'intégralité du commit. Mais c'est une approche plutôt lourde.
Une façon plus propre de le faire serait de conserver la validation et de simplement en supprimer les fichiers modifiés.

git reset HEAD^ -- path/to/file
git commit --amend --no-edit

Le git resetprendra le fichier tel qu'il était lors de la validation précédente et le mettra en scène dans l'index. Le fichier dans le répertoire de travail est intact.
Le git commitva ensuite valider et écraser l'index dans le commit actuel.

Cela prend essentiellement la version du fichier qui était dans la validation précédente et l'ajoute à la validation actuelle. Cela n'entraîne aucune modification nette et le fichier est donc effectivement supprimé de la validation.

Si vous n'avez pas poussé les modifications sur le serveur, vous pouvez utiliser

git reset --soft HEAD~1

Il réinitialisera toutes les modifications et reviendra à un seul commit

Si vous avez poussé vos modifications, suivez les étapes comme indiqué par @CharlesB

La suppression du fichier à l'aide de rm le supprimera!

Vous ajoutez toujours à un commit dans git plutôt que de le supprimer, donc dans ce cas, remettez le fichier dans l'état où il était avant le premier commit (cela peut être une action de suppression de 'rm' si le fichier est nouveau), puis recommencez et le fichier disparaîtra.

Pour ramener le fichier à un état antérieur:

    git checkout <commit_id> <path_to_file>

ou pour le remettre à l'état sur la TETE distante:

    git checkout origin/master <path_to_file>

puis modifiez le commit et vous devriez trouver que le fichier a disparu de la liste (et qu'il n'a pas été supprimé de votre disque!)

git checkout HEAD~ path/to/file
git commit --amend

Ce qui suit mettra en scène uniquement le fichier que vous vouliez, ce que l'OP a demandé.

git reset HEAD^ /path/to/file

Vous verrez quelque chose comme ce qui suit ...

Modifications à valider: (utilisez "git reset HEAD ..." pour annuler la mise en scène)

modifié: / chemin / vers / fichier

Modifications non planifiées pour la validation: (utilisez "git add ..." pour mettre à jour ce qui sera validé) (utilisez "git checkout - ..." pour ignorer les modifications dans le répertoire de travail)

modifié: / chemin / vers / fichier

• "Modifications à valider" est la version précédente du fichier avant la validation. Cela ressemblera à une suppression si le fichier n'a jamais existé. Si vous validez cette modification, il y aura une révision qui annulera la modification du fichier dans votre branche.
• "Modifications non planifiées pour la validation" est la modification que vous avez validée et l'état actuel du fichier

À ce stade, vous pouvez faire tout ce que vous voulez dans le fichier, comme réinitialiser une version différente.

Lorsque vous êtes prêt à vous engager:

git commit --amend -a

ou (si vous avez d'autres changements en cours que vous ne voulez pas encore valider)

git commit add /path/to/file
git commit --amend

Je vais vous expliquer avec exemple.
Soit A, B, C 3 commits successifs. La validation B contient un fichier qui n'aurait pas dû être validé.

git log  # take A commit_id
git rebase -i "A_commit_ID" # do an interactive rebase
change commit to 'e' in rebase vim # means commit will be edited
git rm unwanted_file
git rebase --continue
git push --force-with-lease <branchName>    

Vous pouvez simplement essayer.

git reset --soft HEAD~1

et créez un nouveau commit.

Cependant, il existe un logiciel génial "gitkraken". ce qui facilite le travail avec git.

git rm --cached <file_to_remove_from_commit_<commit_id>_which_added_file>
git commit -m "removed unwanted file from git"

vous laissera toujours le fichier local. Si vous ne voulez pas non plus le fichier localement, vous pouvez ignorer l'option --cached.

Si tout le travail est sur votre branche locale, vous devez conserver le fichier dans un commit ultérieur, et comme avoir un historique propre, je pense qu'une façon plus simple de le faire pourrait être:

git rm --cached <file_to_remove_from_commit_<commit_id>_which_added_file>
git commit --squash <commit_id>
git add <file_to_remove_from_commit_<commit_id>_which_added_file>
git commit -m "brand new file!"
git rebase --interactive <commit_id>^

et vous pouvez ensuite terminer facilement le rebasage sans avoir à vous souvenir de commandes plus complexes ou à valider un message ou à taper autant.

L'utilisation de git GUI peut simplifier la suppression d'un fichier de la validation précédente.

En supposant que ce n'est pas une branche partagée et que cela ne vous dérange pas de réécrire l'historique , exécutez:

git gui citool --amend

Vous pouvez décocher le fichier qui a été validé par erreur, puis cliquer sur "Valider".

Le fichier est supprimé de la validation, mais sera conservé sur le disque . Donc, si vous avez décoché le fichier après l'avoir ajouté par erreur, il s'affichera dans votre liste de fichiers non suivis (et si vous avez décoché le fichier après l'avoir modifié par erreur, il s'affichera dans vos modifications non mises en scène pour la liste de validation).

Si vous souhaitez conserver votre commit (peut-être avez-vous déjà passé un certain temps à écrire un message de commit détaillé et que vous ne voulez pas le perdre) et que vous souhaitez uniquement supprimer le fichier du commit, mais pas du référentiel:

git checkout origin/<remote-branch> <filename>
git commit --amend

Effectuez une séquence des commandes suivantes:

//to remove the last commit, but preserve changes  
git reset --soft HEAD~1

//to remove unneded file from the staging area  
git reset HEAD `<your file>` 

//finally make a new commit  
git commit -m 'Your message'

Je voulais juste compléter la première réponse car je devais exécuter une commande supplémentaire:

git reset --soft HEAD^
git checkout origin/master <filepath>

À votre santé!

Quelque chose qui a fonctionné pour moi, mais pense toujours qu'il devrait y avoir une meilleure solution:

$ git revert <commit_id>
$ git reset HEAD~1 --hard

Laissez simplement le changement que vous souhaitez supprimer dans l'autre commit, vérifiez les autres

$ git commit --amend // or stash and rebase to <commit_id> to amend changes

git reset --soft HEAD^annule votre commit, et lorsque vous tapez git status, il vous indique quoi faire:

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

En fait, je pense qu'un moyen plus rapide et plus simple consiste à utiliser le mode interactif git rebase.

git rebase -i head~1  

(ou dirigez-vous ~ 4, jusqu'où vous voulez aller)

puis, au lieu de «choisir», utilisez «modifier». Je ne savais pas à quel point le «montage» est puissant.

https://www.youtube.com/watch?v=2dQosJaLN18

J'espère que vous le trouverez utile.

Eu le même problème où j'ai des changements dans une branche locale où je voulais revenir à un seul fichier. Ce qui a fonctionné pour moi était -

( feature / target_branch ci-dessous est l'endroit où j'ai toutes mes modifications, y compris celles que je voulais annuler pour un fichier spécifique)

( origin / feature / target_branch est la branche distante où je veux pousser mes modifications)

( fonctionnalité / staging est ma branche de staging temporaire où je vais pousser de toutes mes modifications souhaitées à l'exception de la modification de ce fichier)

1. Créer une branche locale à partir de mon origine / fonction / branche_branche - appelée fonction / mise en scène

2. Fusionné ma branche locale travaillant fonction / target_branch à la fonction / mise en scène branche

3. Extrait de la fonctionnalité / mise en scène puis réinitialisation de git --soft ORIG_HEAD (Maintenant, toutes les modifications de la fonction / mise en scène seront mises en place mais non validées.)

4. Unstaged le fichier que j'ai précédemment archivé avec des modifications inutiles

5. Changement de la branche amont pour fonction / mise en scène d' origine / fonction / target_branch

6. Validé le reste des modifications par étapes et poussé en amont vers mon origine / fonctionnalité / branche_branchée distante

Si vous n'avez plus besoin de ce fichier, vous pouvez le faire

git rm file
git commit --amend
git push origin branch

Si vous utilisez GitHub et n'avez pas encore poussé la validation, GitHub Desktop résout facilement ce problème:

1. Choisissez Référentiel -> Annuler la validation la plus récente
2. Désélectionnez le fichier que vous avez ajouté par erreur. Votre message de validation précédent sera déjà dans la boîte de dialogue.
3. Appuyez sur le bouton Valider!

Si vous souhaitez supprimer des fichiers des validations précédentes, utilisez des filtres

git filter-branch --prune-empty --index-filter 'git rm --ignore-unmatch --cached "file_to_be_removed.dmg"'

Si vous voyez cette erreur:

Impossible de créer une nouvelle sauvegarde. Une sauvegarde précédente existe déjà dans refs / original / Force écrasant la sauvegarde avec -f

Supprimez simplement les sauvegardes de références sur votre référentiel local

$ rm -rf .git/refs/original/refs

si vous n'avez pas encore poussé vos modifications vers git

git reset --soft HEAD~1

Il réinitialisera toutes les modifications et reviendra à un seul commit

S'il s'agit du dernier commit que vous avez effectué et que vous souhaitez supprimer le fichier du référentiel local et distant, essayez ceci:

git rm <file>
 git commit --amend

ou encore mieux:

réinitialiser d'abord

git reset --soft HEAD~1

réinitialiser le fichier indésirable

git reset HEAD path/to/unwanted_file

engager à nouveau

git commit -c ORIG_HEAD  

Cela a fonctionné pour moi pour supprimer le fichier du dépôt de bit bit que j'ai poussé le fichier pour créer une branche initialement.

git checkout origin/develop <path-to-file>
git add <path-to-file>
git commit -m "Message"
git push

J'ai copié les fichiers actuels dans un dossier différent, puis je me suis débarrassé de toutes les modifications non poussées en:

git reset --hard @{u}

Recopiez ensuite les choses. Validez, poussez.

Vous pouvez simplement utiliser cette commande:

git restore --staged <file>

Here is the step to remove files from Git Commit.

>git reset --soft HEAD^1(either commitid ) -- now files moved to the staging area.
>git rm --cached filename(it will removed the file from staging area)
>git commit -m 'meaningfull message'(Now commit the required files)

À l'heure actuelle, aucune des réponses n'est raisonnable. Il semble que la demande soit suffisante pour qu'une véritable solution soit proposée: https://github.com/git/git/blob/master/Documentation/SubmittingPatches

git --uncommit <nom de fichier>

serait bien. J'obtiens que nous ne voulons pas modifier l'historique, mais si je suis local et que j'ai accidentellement ajouté un fichier "hack" local et que je veux le supprimer du commit, ce serait super utile.