Supprimer les fichiers de Git commit
J'utilise Git et j'ai engagé quelques fichiers avec
git commit -a
Plus tard, j'ai découvert qu'un fichier avait été ajouté par erreur au commit.
Comment puis-je supprimer un fichier du dernier commit?
Je pense que d’autres réponses sont fausses, car il s’agit de déplacer les fichiers validés par erreur vers la zone de stockage intermédiaire du commit précédent, sans annuler les modifications qui leur ont été apportées. Cela peut être fait comme suggéré par Paritosh Singh:
git reset --soft HEAD^
ou
git reset --soft HEAD~1
Puis réinitialisez les fichiers indésirables pour les exclure de la validation:
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 précédente validation et le conserver sur le disque, lisez la réponse de juzzlin juste au-dessus.
S'il s'agit de votre dernière validation et que vous voulez supprimer complètement le fichier de votre référentiel local et distant, vous pouvez:
- supprimer le fichier
git rm <file> - commettre avec le drapeau de modification:
git commit --amend
Le drapeau amende dit à git de commettre à nouveau, mais "fusionne" (pas dans le sens de la fusion de deux branches), cette validation avec la dernière validation.
Comme indiqué dans les commentaires, utiliser git rm ici revient à utiliser la commande rm elle-même!
Les réponses existantes parlent toutes de supprimer les fichiers indésirables delastcommit.
Si vous souhaitez supprimer des fichiers indésirables d'unoldcommit (même poussé) et que vous ne voulez pas créer de nouveau commit, ce qui est inutile, à cause de l'action:
1.
Recherchez le commit auquel vous voulez que le fichier se conforme.
git checkout <commit_id> <path_to_file>
vous pouvez le faire plusieurs fois si vous souhaitez supprimer plusieurs fichiers.
2.
git commit -am "remove unwanted files"
3.
Recherchez 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. Le nom par défaut est vim.
Déplacez le dernier commit, qui devrait être "supprimer les fichiers indésirables", vers la ligne suivante du commit incorrect ("35c23c2" dans notre cas), et définissez la commande sur fixup:
pick 35c23c2 the first commit
fixup 0d78b28 remove unwanted files
Vous devriez être bon après avoir sauvegardé le fichier.
Pour finir :
git Push -f
Si vous obtenez 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 simple de le faire serait de garder le commit et de simplement supprimer les fichiers modifiés.
git reset HEAD^ -- path/to/file
git commit --amend --no-edit
Le git reset prendra le fichier tel qu'il était dans la précédente validation, et le place dans l'index. Le fichier dans le répertoire de travail est inchangé.
Le git commit sera ensuite validé et écrasera l'index dans le commit en cours.
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 aucun changement net et le fichier est donc effectivement supprimé du commit.
Si vous n'avez pas transmis les modifications sur le serveur, vous pouvez utiliser
git reset --soft HEAD~1
Il va réinitialiser tous les changements et revenir à un commit
Si vous avez poussé vos modifications, suivez les étapes indiquées par @CharlesB
Supprimer le fichier en utilisant rm le supprimera!
Vous ajoutez toujours à un commit en place plutôt que de le supprimer, aussi, dans ce cas, rétablissez le fichier dans l'état dans lequel il se trouvait avant le premier commit (il peut s'agir d'une action delete 'rm' si le fichier est nouveau) re-commettre et le fichier ira.
Pour ramener le fichier à un état antérieur:
git checkout <commit_id> <path_to_file>
ou pour le remettre à l'état situé à la tête HEAD 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 non supprimé de votre disque!)
git checkout HEAD~ path/to/file
git commit --amend
Ce qui suit va décaler le fichier que vous vouliez, ce que l’opérateur a demandé.
git reset HEAD^ /path/to/file
Vous verrez quelque chose comme ce qui suit ...
Changements à valider: (utilisez "git reset HEAD ..." pour décompresser)
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 du 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, une révision annulera la modification du fichier dans votre branche.
- "Modifications non planifiées pour la validation" correspond aux modifications que vous avez validées et à l'état actuel du fichier.
À ce stade, vous pouvez faire ce que vous voulez pour le fichier, par exemple en réinitialisant une version différente.
Lorsque vous êtes prêt à vous engager:
git commit --amend -a
ou (si vous avez d'autres modifications en cours que vous ne voulez pas encore valider)
git commit add /path/to/file
git commit --amend
Je vais vous expliquer par l'exemple.
Soit A, B, C trois validations successives. Valider 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>
Si vous voulez 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 voulez uniquement supprimer le fichier du commit, mais pas du référentiel entièrement:
git checkout Origin/<remote-branch> <filename>
git commit --amend
L'utilisation de l'interface graphique de git peut simplifier la suppression d'un fichier de la précédente validation.
En supposant que cela ne soit pas une branche partagée et que cela ne vous dérange pas de réécrire l'historique , puis exécutez:
git gui citool --amend
Vous pouvez décocher le fichier qui a été commis par erreur, puis cliquer sur "Valider".
Le fichier est supprimé de la validation, mais sera conservé sur le disque. Ainsi, si vous désélectionnez le fichier après l'avoir ajouté par erreur, il apparaîtra dans la liste des fichiers non suivis (et si vous désélectionnez le fichier après l'avoir modifié par erreur, il apparaîtra dans les modifications non mises en scène pour la liste de validation).
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 le fichier localement non plus, 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 pour avoir un historique vierge, je pense qu'un moyen 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 alors terminer la création de base facilement sans avoir à mémoriser autant de commandes plus complexes, ni à commettre un message, ni à taper autant.
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é!
git reset --soft HEAD^ récupère votre commit et lorsque vous tapez git status, il vous indique quoi faire:
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
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 voulez supprimer dans l'autre commit, vérifiez les autres
$ git commit --amend // or stash and rebase to <commit_id> to amend changes
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 la tête ~ 4, jusqu'où vous voulez aller)
et ensuite, au lieu de "pick", utilisez "edit" . Je ne réalisais pas à quel point "edit" était puissant.
https://www.youtube.com/watch?v=2dQosJaLN18
J'espère que vous le trouverez utile.
Avait le même problème où j'ai des changements dans une branche locale où je voulais restaurer 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 vers laquelle je veux appliquer mes modifications)}
(feature/staging est ma branche de stockage temporaire où je vais appliquer toutes les modifications souhaitées, à l'exception de la modification de ce fichier)}
Créer une branche locale à partir de mon origine/fonctionnalité/target_branch - appelée ainsi fonctionnalité/staging
Fusion de ma branche locale active feature/target_branch avec la branche feature/staging
Extrait fonctionnalité/mise en scène puis réinitialisation git --soft ORIG_HEAD _ (Maintenant, toutes les modifications de la fonction/mise en scène 'seront mises en scène mais non validées.)
Unstaged le fichier que j'ai précédemment archivé avec des modifications inutiles
Modification de la branche en amont de feature/staging en Origin/feature/target_branch _
Validé le reste des modifications planifiées et poussé en amont sur ma télécommande Origin/feature/target_branch
Si vous avez accidentellement ajouté un fichier à votre commit, vous pouvez faire quelque chose comme:
git rm --cached path_to_file
méfiez-vous de --cached sinon votre fichier serait également supprimé de votre projet.
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/Forcer le remplacement de la sauvegarde avec -f
Il suffit de supprimer les sauvegardes de références sur votre dépôt local
$ rm -rf .git/refs/original/refs
Si vous utilisez GitHub et que vous n'avez pas encore poussé le commit, GitHub Desktop résout facilement ce problème:
- Choisissez Référentiel -> Annuler la plus récente validation
- 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.
- Appuyez sur le bouton Commit!
J'ai copié les fichiers actuels dans un autre dossier, puis je me suis débarrassé de toutes les modifications non impossibles en:
git reset --hard @{u}
Puis recopiez les choses. Commit, Push.
si vous n'utilisez pas encore vos modifications dans git
git reset --soft HEAD~1
Il réinitialisera toutes les modifications et reviendra à un commit
S'il s'agit de la dernière validation que vous avez effectuée et que vous souhaitez supprimer le fichier des référentiels local et distant, essayez ceci:
git rm <file>
git commit --amend
ou même mieux:
réinitialiser en premier
git reset --soft HEAD~1
réinitialiser le fichier indésirable
git reset HEAD path/to/unwanted_file
commettre à nouveau
git commit -c ORIG_HEAD
Cela a fonctionné pour moi pour supprimer le fichier du dépôt de seau de bits 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
Si vous n'avez plus besoin de ce fichier, vous pouvez le faire
git rm file
git commit --amend
git Push Origin branch