J'ai lu des articles similaires sur ce sujet et je ne peux pas pour la vie de moi comprendre comment le faire correctement.

J'ai archivé environ 1000 fichiers dont je ne veux pas et je préfère ne pas avoir à passer par 1by1 et à les supprimer tous du dépôt.

• J'ai une mastersuccursale éloignée .
• J'ai la mastersuccursale locale .

Ils sont tous les deux à la même révision.

Je veux restaurer ma télécommande d'un commit.

Dites que mon histoire masterest A--B--C--D--E.
Je souhaite restaurer mon fichier local sur D.
Ensuite, poussez-le sur remote pour que mon hachage actuel soit D à la fois distant et local.

J'ai des problèmes pour faire ça.
J'utilise Git Tower mais je suis à l'aise avec la ligne de commande. De l'aide?

MISE À JOUR: Grands commentaires ci-dessous. L'utilisation d'une réinitialisation semble être partiellement déconseillée, surtout si le référentiel est partagé avec d'autres utilisateurs. Quelle est la meilleure façon d'annuler les modifications du commit précédent sans utiliser une réinitialisation matérielle ? Y a-t-il un moyen?

Si personne n'a encore retiré votre repo distant, vous pouvez changer votre branche HEAD et forcer le pousser vers ledit repo distant:

git reset --hard HEAD^ 
git push -f 

(ou, si vous avez un accès direct au repo distant, vous pouvez modifier sa référence HEAD même s'il s'agit d'un repo nu )

Notez, comme commenté par alien-technology dans les commentaires ci - dessous , sous Windows (session CMD), vous auriez besoin de ^^:

git reset --hard HEAD^^
git push -f 

Mise à jour depuis 2011: l'
utilisation git push --force-with-lease( que je présente ici , introduite en 2013 avec Git 1.8.5) est plus sûre.

Voir la réponse de Schwern pour illustration.

Et si quelqu'un a déjà retiré le repo? Que ferais-je alors?

Ensuite, je suggérerais quelque chose qui ne réécrit pas l'histoire:

• git revert localement votre dernier commit (création d'un nouveau commit qui inverse ce que le commit précédent a fait)
• pousser le 'retour' généré par git revert.

Définissez la branche locale une révision en arrière ( HEAD^signifie une révision en arrière):

git reset --hard HEAD^

Poussez les modifications à l'origine:

git push --force

Vous devrez forcer le push car sinon, git reconnaîtrait que vous êtes en retard originpar un commit et rien ne changera.

Le faire avec --forcedit à git d'écraserHEAD dans le référentiel distant sans respecter aucune avancée.

Si vous voulez revenir au dernier commit écoutez:

Étape 1:

Vérifiez vos engagements locaux avec des messages

$ git log

Étape 2:

Supprimer le dernier commit sans réinitialiser les modifications de la branche locale (ou du maître)

$ git reset HEAD^

OU si vous ne voulez pas que les derniers fichiers de commit et les mises à jour écoutent

$ git reset HEAD^ --hard

Étape 3:

Nous pouvons mettre à jour les fichiers et les codes et à nouveau besoin de pousser avec force, cela supprimera le commit précédent. Il conservera un nouveau commit.

$ git push origin branch -f

C'est tout!

En entrant la commande ci-dessous, vous pouvez voir votre historique de validation git -

$ git log

Disons que votre historique sur cette branche particulière est comme - commit_A, commit_B, commit_C, commit_D. Où, commit_D est le dernier commit et c'est là que HEAD reste. Maintenant, pour supprimer votre dernier commit local et distant, vous devez procéder comme suit:

Étape 1: supprimer le dernier commit localement par -

$ git reset --hard HEAD ~

Cela changera votre commit HEAD en commit_C

Étape 2: Poussez votre changement pour un nouveau commit HEAD à distance

$ git push origin + HEAD

Cette commande supprimera le dernier commit de la télécommande.

PS cette commande est testée sur Mac OSX et devrait également fonctionner sur d'autres systèmes d'exploitation (sans prétendre à d'autres OS)

Pour les machines Windows, utilisez:

git reset HEAD~1  #Remove Commit Locally

Voici une version mise à jour de la procédure qui est plus sûre.

git reset --hard HEAD^ 
git push --force-with-lease

git push -fremplacera sans discernement le référentiel distant par vos propres modifications. Si quelqu'un d'autre a poussé des changements, ils seront perdus.git push --force-with-leasene poussera votre rebase que si le référentiel est comme prévu. Si quelqu'un d'autre a déjà poussé, votre push échouera.

Voir –force considérée comme nuisible; comprendre git's –force-with-bail .

Je recommande d'aliaser ceci comme repush = push --force-with-lease.

Et si quelqu'un a déjà retiré le repo? Que ferais-je alors?

Dites-leur git pull --rebase=merges. Au lieu d'un git fetch originet git merge origin/masteril le fera git fetch originet git rebase -r origin/master. Cela réécrira tous leurs changements locaux masteren plus du nouveau rebasé origin/master. -rconservera toutes les fusions qu'ils ont pu effectuer.

Je recommande d'en faire le comportement par défaut pour tirer. Il est sûr, gère le rebasage des autres et entraîne moins de fusions inutiles.

[pull]
        rebase = merges

J'ai résolu un problème comme le vôtre par ces commandes:

git reset --hard HEAD^
git push -f <remote> <local branch>:<remote branch> 

Si vous avez un accès direct au référentiel distant, vous pouvez toujours utiliser:

git reset --soft HEAD^

Cela fonctionne car il n'y a aucune tentative de modifier le répertoire de travail inexistant. Pour plus de détails, veuillez consulter la réponse originale:

Comment puis-je annuler la validation du dernier commit dans un dépôt nu git?

Je voulais juste supprimer le dernier commit de l'historique des commit distant et effacer également. Ce qui suit a fonctionné comme un charme

git reset --hard HEAD^ 
git push -f 

La façon de réinitialiser la tête et de revenir au commit précédent est de

$ git reset HEAD^ --hard
$ git push <branchname> -f

Mais parfois, cela peut ne pas être accepté dans la branche distante:

To ssh:<git repo>
 ! [rejected]        develop -> develop (non-fast-forward)
error: failed to push some refs to 'ssh:<git repo>'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. Integrate the remote changes (e.g.
hint: 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

alors l'autre façon de faire est

git revert HEAD
git push <remote branch>

Cela fonctionne très bien.

REMARQUE: rappelez-vous si l' git push -f <force>échec et que vous essayez de revenir en arrière. Faites un git pullavant, pour que la télécommande et le local soient synchronisés, puis essayez git revert.
Vérifiez avec git logpour vous assurer que le distant et le local sont au même point de validation avec le même SHA1.

git revert 
A --> B --> C -->D
A--> B --> C --> D --> ^D(taking out the changes and committing reverted diffs)

sur le maître local

git reflog
-- this will list all last commit
  e.g Head@{0} -- wrong push
      Head@{1} -- correct push  
git checkout Head@{1} .
  -- this will reset your last modified files

git status 
git commit -m "reverted to last best"
git push origin/master

Pas besoin de s'inquiéter si l'autre a tiré ou non.

Terminé!

Si vous souhaitez uniquement supprimer le dernier commit du référentiel distant sans gâcher votre référentiel local, voici un one-liner:

git push origin +origin/master~:master

Cela utilise la syntaxe suivante:

git push <remote> <refspec>

Voici, <remote>est originet <refspec>a la structure suivante:

+origin/master~:master

Les détails peuvent être trouvés dans git-push(1). La précédente +signifie "forcer cette ref", et l'autre partie signifie "de origin/master~à master(de la télécommande origin)". Il n'est pas difficile de savoir que origin/master~c'est le dernier commit avant origin/master, non?

pour moi fonctionne ces deux commandes:

git checkout commit_id
git push origin +name_of_branch

Vous pouvez également faire ceci:

git reset --hard <commit-hash>
git push -f origin master

et faites réinitialiser tous les autres utilisateurs qui ont reçu les derniers mauvais commits:

git reset --hard origin/master