Comment puis-je pousser modifié s'engager à la distance dépôt Git?

Quand j'ai travaillé un peu avec mon code source, j'ai fait mon truc habituel commettre et puis j'ai poussé à un dépôt distant. Mais ensuite, j'ai remarqué que j'ai oublié d'organiser mon importations dans le code source. Je fais donc de la modifier de commande pour remplacer la précédente livraison:

> git commit --amend

Malheureusement, la validation ne peut pas être poussé vers le dépôt. Il est rejeté comme ceci:

> git push origin
To //my.remote.repo.com/stuff.git/
 ! [rejected]        master -> master (non-fast forward)
error: failed to push some refs to '//my.remote.repo.com/stuff.git/'

Que dois-je faire? (Je peux accéder au dépôt distant.)

Que faire si mon --amend a plus qu'à changer le message de commit? De toute façon à modifier le dernier message de commit seule, si elle a déjà été poussé à distance? Je l'ai fait sur Github et j'ai obtenu le même message au sujet de la non rapide vers l'avant. Puis j'ai appliqué une solution ci-dessous, mais la fusion juste ajouté plus de messages de commit sur le dessus..
Je pense que c'est une FAQ. Un message de validation est haché avec le commettre, alors chaning ça change de la revid (hash). Si elle n'est pas claire: non, vous ne le peut pas. IIRC pouvez stocker out-of-band info dans les notes (de sorte que vous pouvez annoter existants s'engage sans les modifier). Étiquette spécifique s'engage, utiliser les tags
Vous allez bientôt (git1.8.5, T4 2013) être en mesure de faire un git push -force plus attentivement.
Ici est le style cow-boy. N'apprenez pas tout plus ou ne chasse pas les moyens pour annuler la dernière git modifier. Juste ajouter un peu de code de l'espace réservé, je veux dire, Ajouter quelques commentaires, le Nettoyage un peu de code ou simplement ajouté quelques dash dash dash.... Maintenant faire une réelle s'engager et de le pousser à distance. Fait !
Si votre -modifier l'a été seulement de changer le message de commit et que vous n'avez pas fait de supplémentaires locale s'engage depuis, vous pouvez réinitialiser votre succursale locale de la télécommande s'engager à ce que vous avez poussé avant de modifier le message de commit.

InformationsquelleAutor Spoike | 2008-10-31

485

Je l'ai fait une fois poussé avec --force et .git le référentiel et l'ai grondé par Linus GRAND TEMPS. En général, cela va créer beaucoup de problèmes pour d'autres personnes. Une réponse simple est "Ne pas faire".

Je vois les autres a donné la recette pour le faire de toute façon, donc je ne vais pas les répéter ici. Mais voici une astuce pour récupérer à partir de la situation après vous ont poussé hors de la version modifiée de s'engager avec --force (ou +master).
1. Utilisation git reflog de trouver l'ancien commit que vous avez modifié (appeler old, et nous allons l'appeler le nouveau commit que vous avez créé en modifiant new).
2. Créer une fusion entre old et new de l'enregistrement de l'arbre de new, comme git checkout new && git merge -s ours old.
3. Le fusionner à votre maître avec git merge master
4. Mise à jour de votre maître, avec le résultat avec git push . HEAD:master
5. Pousser la conséquence.
Les gens qui ont la malchance d'avoir fondé leur travail sur la validation vous effacée en modifiant et en forçant un push voit le résultat de la fusion verrez que vous en faveur d' new sur old. Plus tard leur fusions de ne pas voir les conflits entre old et new qui résulte de votre modifiant, de sorte qu'ils n'ont pas à subir.
- J'en suis très conscient de ce qui se passe quand vous la force de pousser une version modifiée de la commettre (par la destruction de l'histoire). Heureusement, j'étais le seul développeur sur le projet avec la télécommande pensions être sur un lecteur de réseau, il n'est donc pas que les grandes d'un accord. Je n'ai jamais pensé à propos de la fusion d'un modifier commettre, alors je vais upvote ce.
- Dans notre société, nous avons la force de pousser assez régulièrement... sur les branches développées par les individus.
- La réprimande de Linus était parce que vous avez effacé de l'histoire avec l'option force, non pas parce que vous ne devriez pas le faire. GabrielleV la solution fonctionne très bien, car il n'a pas changer l'histoire.
- nous faisons la même chose, il conserve l'historique de git beaucoup plus propre
- Quant à la force de pousser à une branche, ne devrait-il pas être considéré comme OK si vous travaillez hors personnel branche? L'histoire que vous êtes à l'écrasement est seulement de votre propre que vous êtes pleinement conscient de. Par exemple, les membres de mon équipe et j'ai le nom de personnels branches en conséquence, par exemple develop_<fonction>_<développeur nom de l'>. C'est le point de l'ensemble des distribué de gestion de la révision, nous pouvons faire ce que voulez sur notre propre bac à sable, il suffit de ne pas jouer avec l'histoire dans la canalisation principale.
- Maintenant Linus pouvez utiliser l'un de github caractéristiques et de protéger le maître de la force de pousser.
- S'il vous plaît, puisque l'auteur (gitster) de cette réponse semble ne pas exister de plus, quelqu'un pourrait-il contribuer à préciser le numéro de l'article 1: trouver l'ancien commit. Si vous n'avez pas de sauvegarde, où aimeriez-vous trouver? Modifier et à force de pousser ne serait pas détruit? Peut-être qu'il est en se référant à l'obtenir à partir d'un ami ou le collaborateur qui en ont encore dans l'arbre?
- Dr Breco vous pouvez utiliser git reflog pour le trouver
- doit avoir grondé lui-même pour ne pas trouver un moyen de rattacher automatiquement détaché têtes.
InformationsquelleAutor
260

Vous voyez un Git dispositif de sécurité. Git refuse de mettre à jour la branche à distance avec votre direction, parce que votre succursale de la tête de s'engager n'est pas un descendant direct de l'actuel chef de commit de la branche qui vous poussent à.

Si ce n'était pas le cas, alors deux personnes en le poussant vers la même référentiel, à la même époque ne serait pas savoir qu'il y avait un nouveau commit à venir dans le même temps, et celui qui a poussé dernier perdrait le travail de la précédente poussoir sans eux, la réalisation de ce.

Si vous savez que vous êtes la seule personne qui pousse et vous souhaitez faire une modification de commettre ou de pousser un commit qui serpente le dos de la direction générale, vous pouvez "forcer" Git pour la mise à jour de la branche à distance à l'aide de la -f commutateur.
```
git push -f origin master
```
Même cela peut ne pas fonctionner comme Git permet à des dépôts distants de refuser non-fastforward pousse à l'extrême fin à l'aide de la variable de configuration receive.denynonfastforwards. Si c'est le cas, le rejet de la raison ressemblera à ceci (notez la distance rejeté " partie):
```
 ! [remote rejected] master -> master (non-fast forward)
```
Pour contourner ce problème, vous devez modifier soit le dépôt distant de configuration ou comme un sale hack vous pouvez la supprimer et la recréer la direction générale ainsi:
```
git push origin :master
git push origin master
```
En général, le dernier paramètre à git push utilise le format <local_ref>:<remote_ref>, où local_ref est le nom de la branche sur le dépôt local et remote_ref est le nom de la branche sur le dépôt distant. Cette commande paire utilise deux abréviations. :master a une valeur null local_ref qui signifie pousser un null branche sur le côté distant master, c'est à dire supprimer la branche distante. Un nom de branche sans : signifie pousser la branche locale avec le nom donné à la branche à distance avec le même nom. master dans cette situation est court pour master:master.
- cela ne fonctionne pas avec github, il m'a donné le message suivant: [remote rejeté] maître (suppression de l'actuelle direction de l'interdit)
- Je ne voulais pas la force de pousser (dont je savais qu'il allait régler le problème), mais maintenant, je suppose que je n'ai pas le choix.
- C'est la seule solution qui a fonctionné pour mon repo accueilli avec assembla.
- la suppression de la distance branche master permettra de libérer de l'espace dans la distance repo ?
- Pas immédiatement, mais après un git gc une fois le reflogs ont expiré vieux objets seront élagués. Personne qui clone le dépôt d'obtenir tous les objets qui ne sont plus accessibles dès que le service a été mis à jour.
- Cela a fonctionné pour moi, et montre que 1 (correctement modifié) s'engager dans git log et dans Bitbucket. Cependant, mon ticket Jira montre deux commits. Le premier a un autre SHA que ce que je vois dans Bitbucket et a la version non amendée commettre. La seconde a la même SHA avec la version modifiée de la commettre. Donc je suppose que la version non amendée s'engager à ne jamais s'en va, il est juste caché par git et les autres clients. Comment puis-je voir la version non amendée s'engage avec git log?
InformationsquelleAutor CB Bailey
206

Rapide coup de gueule: Le fait que personne n'a posté la réponse la plus simple ici est la preuve que les désespérés de l'utilisateur de l'hostilité manifestée par le Git de la CLI.

De toute façon, le "évident" façon de le faire, en supposant que vous n'avez pas essayé de forcer la poussée, est de tirer en premier. Ce tire la modification que vous avez modifié (et donc n'ont plus), de sorte que vous avez à nouveau.

Une fois que vous avez résolu tous les conflits, vous pouvez pousser à nouveau.

Donc:
```
git pull
```
Si vous obtenez des erreurs en tirer, peut-être que quelque chose est incorrect dans votre dépôt local de configuration (j'ai eu un mal de ref dans le .git/config direction de la section).

Et après
```
git push
```
Peut-être vous obtenez un supplément de s'engager avec le sujet en racontant un "Trivial de fusion".
- Oui, j'ai écrit à ce sujet, voir stackoverflow.com/questions/253055/... 😉
- Cela ne marche pas comme je l'attendais. Il crée deux nouveaux commits. Celui qui est une réplique de l'ancien, mais avec la version modifiée de changements. Et une fusion s'engager avec un vide diff. Tout en laissant l'ancien commit inchangé, éventuellement révéler des données sensibles que j'ai essayé de modifier loin. Je crois git push -f ou git reset est la seule façon d'aller ici.
- Bien que, techniquement, de répondre au problème, il n'a pas vraiment d'aborder la question. Comme vous l'avez dit, il va générer un supplément de commettre, mais la principale raison pour laquelle les gens de modifier un commit est pour éviter d'en créer un nouveau. Donc, si les affiches ont été de suivre vos instructions, il ne serait pas obtenir le résultat souhaité. Il serait tout autant les sens pour ne pas modifier l'engagement dans la première place.
InformationsquelleAutor
99

Réponse courte: Ne poussez pas modifié s'engage à un public de pensions.

Réponse longue: quelques commandes Git, comme git commit --amend et git rebase, en fait réécrire l'histoire graphique. C'est très bien aussi longtemps que vous n'avez pas publié vos modifications, mais une fois que vous faites, vous ne devriez pas être curage autour de l'histoire, parce que si quelqu'un a déjà eu vos modifications, puis, quand ils essaient de tirer de nouveau, elle peut échouer. Au lieu de modifier un commit, vous devriez juste faire un nouveau commit avec les changements.

Toutefois, si vous avez vraiment, vraiment envie de pousser une version modifiée de s'engager, vous pouvez le faire comme ceci:
```
$ git push origin +master:master
```
Le premier + signe de la force de la pousser à se produire, même s'il n'a pas dans un "fast-forward" s'engager. (Un fast-forward commettre se produit lorsque les modifications sont en train de pousser sont un descendant direct des changements déjà dans le public des pensions.)
- Comment est-ce différent ( le meilleur ou le pire) de la commande git push -f ? Merci!
- C'est essentiellement la même chose que git push -f.
InformationsquelleAutor mipadi
50

Ici est très simple et propre façon de pousser vos modifications après que vous avez déjà fait un commit --amend:
```
git reset --soft HEAD^
git stash
git push -f origin master
git stash pop
git commit -a
git push origin master
```
Qui effectue les opérations suivantes:
- Réinitialiser chef de la direction générale des parents d'commettre.
- La planque de ce dernier commit.
- De la Force de pousser à distance. La distance maintenant ne pas avoir le dernier commit.
- Pop de votre cachette.
- Commettre proprement.
- Pousser à distance.
N'oubliez pas de changer "l'origine" et "maître", si l'application d'une autre branche ou à distance.
- 2 remarques : - assurez-vous de changer la dénomination de la succursale si vous travaillez sur un autre - j'ai eu à utiliser git add avant mon engager à inclure les modifications.
- Dans Windows CMD, la première commande doit être échappé: git reset --soft "HEAD^". Le reste fonctionne très bien.
- "un très simple et propre.. cit. Cette procédure comprend forcé de pousser. Dans les lumières de toutes les critisims dans les Réponses ci-dessus, je ne suis pas sûr si cette procédure est en fait un propre.
InformationsquelleAutor Faiza
23

J'ai résolu en supprimant mon local modifiée de s'engager et d'en ajouter de nouveaux changements sur le dessus:
```
# Rewind to commit before conflicting
git reset --soft HEAD~1

# Pull the remote version
git pull

# Add the new commit on top
git add ...
git commit
git push
```
- C'est la version la plus simple!
- L'ajout d'un autre "changement" commit est mieux que de jouer avec la réécriture de l'histoire. Je suis d'accord avec @mknaf
InformationsquelleAutor bara

J'ai eu le même problème.

Accidentellement modifiées le dernier commit qui a déjà poussé
Fait beaucoup de changements localement, commis quelque cinq fois
Essayé de pousser, eu une erreur, pris de panique, fusionné à distance, a obtenu beaucoup de pas-mes-fichiers, poussé, échec, etc.

Comme un Git-débutant, je pensais que c'était complet FUBAR.

Solution: un Peu comme @bara suggéré + créé une sauvegarde locale de la branche

# Rewind to commit just before the pushed-and-amended one.
# Replace <hash> with the needed hash.
# --soft means: leave all the changes there, so nothing is lost.
git reset --soft <hash>

# Create new branch, just for a backup, still having all changes in it.
# The branch was feature/1234, new one - feature/1234-gone-bad
git checkout -b feature/1234-gone-bad

# Commit all the changes (all the mess) not to lose it & not to carry around
git commit -a -m "feature/1234 backup"

# Switch back to the original branch
git checkout feature/1234

# Pull the from remote (named 'origin'), thus 'repairing' our main problem
git pull origin/feature/1234

# Now you have a clean-and-non-diverged branch and a backup of the local changes.
# Check the needed files from the backup branch
git checkout feature/1234-gone-bad -- the/path/to/file.php

C'est peut-être pas un rapide et propre solution, et j'ai perdu mon histoire (1 commit au lieu de 5), mais il a sauvé une journée de travail.

InformationsquelleAutor davisca

6

Si vous n'avez pas poussé le code de votre télécommande branche (GitHub/Bitbucket) vous pouvez modifier le message de commit sur la ligne de commande comme ci-dessous.
```
 git commit --amend -m "Your new message"
```
Si vous travaillez sur une branche spécifique, faites ceci:
```
git commit --amend -m "BRANCH-NAME: new message"
```
Si vous avez déjà poussé le code avec un mauvais message, alors vous devez être prudent lors de la modification du message. j'.e fois que vous modifiez le message de commit et essayer de pousser à nouveau, vous retrouver avec des problèmes. Pour la rendre lisse suivre les étapes suivantes.

Veuillez lire l'intégralité de la réponse avant de le faire
```
git commit --amend -m "BRANCH-NAME : your new message"

git push -f origin BRANCH-NAME                # Not a best practice. Read below why?
```
Remarque importante: Lorsque vous utilisez la force de pousser directement, vous pourriez vous retrouver avec des problèmes de code que d'autres développeurs travaillent sur la même branche. Donc, pour éviter ces conflits, vous avez besoin pour tirer le code de votre branche avant de faire le force de pousser:
```
 git commit --amend -m "BRANCH-NAME : your new message"
 git pull origin BRANCH-NAME
 git push -f origin BRANCH-NAME
```
C'est la meilleure pratique lors de la modification du message de validation, si elle a déjà poussé.
- Si vous avez réussi à tiré vers l'arrière de la validation de votre dernier exemple, pourquoi avez-vous besoin de la force de pousser? Ne serait pas un push standard suffit-il? Merci
- Question posée par Thomas est en fait tout à fait valable. Moi-même n'ai pas besoin de forcer la poussée suivante tirer.
- S'il vous plaît ne pas appeler la "meilleure pratique", car il est un moyen de contourner --force, voir la accepté de répondre à
InformationsquelleAutor Prabhakar Undurthi
5

Si vous savez que personne n'a tiré votre non-modifié commettre, utilisez le --force-with-lease option de git push.

Dans TortoiseGit, vous pouvez faire la même chose sous "Pousser..." options "de la Force: Peut jeter" et en cochant "changements".

Force (Peut jeter des changements connus) permet le dépôt distant à accepter une sécurité non-avance rapide push. Cela peut entraîner le dépôt distant à perdre s'engage; utiliser avec prudence. Cela peut éviter de perdre de changements inconnus à partir d'autres personnes sur la télécommande. Il vérifie si le serveur de points de branchement à la même livraison que la distance de suivi de branche (changements connus). Si oui, une force de poussée sera effectuée. Sinon il sera rejeté. Depuis git n'a pas à distance de suivi de balises, les balises ne peuvent pas être écrasées à l'aide de cette option.

InformationsquelleAutor ShawnFeatherly
4

Vous obtenez cette erreur, parce que le Git remote a ces commit des fichiers. Vous avez à force de pousser la branche pour que cela fonctionne:
```
git push -f origin branch_name
```
Assurez-vous également que vous tirez sur le code de la télécommande comme quelqu'un d'autre sur votre équipe peut avoir poussé à la même branche.
```
git pull origin branch_name
```
C'est un des cas où nous avons à force de pousser la validation à distance.
- Pourquoi pas cette réponse soit prise en compte des grandes commentaires soulevés dans les réponses précédentes?
InformationsquelleAutor Praveen Dhawan
2

Ici est très simple et propre façon de pousser vos modifications après que vous avez déjà fait un git add "your files" et git commit --amend:
```
git push origin master -f
```
ou:
```
git push origin master --force
```
- J'ai entendu dire que du mal, et je suis sûr qu'il est. Il y a une (bonne) raison pour git à l'échec par défaut (et nécessitent --force), j'en suis sûr.
InformationsquelleAutor craken
1

J'ai eu à résoudre ce problème avec la traction à partir de la télécommande pensions et de traiter les conflits de fusion qui se pose, s'engager et de pousser ensuite. Mais je me sens comme il ya une meilleure façon.
- Pas vraiment. Le problème peut être que vous n'avez pas mis à jour votre copie locale de la distance des pensions. Git ne pousserons pas parce que vous aurez à faire avec fusionne manuellement. Dans mon autre réponse, j'ai une commande (et explication) qui va forcer un push -- mais attention c'est peut supprimer des changements dans la télécommande.
InformationsquelleAutor Spoike
1

J'ai juste continué à faire ce que Git m'a dit de faire. Donc:
- Ne peut pas pousser en raison de la modification de la commettre.
- Je faire un pull comme le suggère.
- Fusion échoue. j'ai donc corrigé manuellement.
- Créer un nouveau commit (étiqueté
  "fusion") et de le pousser à.
- Il semble fonctionner!
Remarque: La version modifiée de commettre était la dernière.
- J'avais downvote, si j'avais plus de points de réputation, donc je vais juste demander poliment, que celui qui a été vous de ceux qui souffrent? Celui qui a modifié? L'un, qui a tiré et a travaillé sur une branche modifié engager? Avant de le modifier, ou après? J'ai juste supprimé la modification de la mienne parce que j'ai mal compris... Heureusement il n'y avait pas grand-chose...
InformationsquelleAutor Rolf
0

Ici, Comment j'ai résolu de faire une modification dans une précédente livraison:
1. Sauvegarder votre travail.
2. Ranger vos modifications à l'écart pour l'instant, si fait: git stash Maintenant votre copie de travail est propre à l'état de votre dernier commit.
3. La réalisation des modifications et des corrections.
4. Valider les modifications dans "modifier" mode: git commit --all --amend
5. Votre éditeur demandant pour un message de log (par défaut, le vieux message de log). Enregistrez et quittez l'éditeur lorsque vous êtes heureux avec elle.
  
  Les nouveaux changements sont ajoutés à l'ancien commit. Voir pour vous-même avec git log et git diff HEAD^
6. Ré-appliquer votre planqué changements, si elle est faite: git stash apply
InformationsquelleAutor Harshal Wani

Vous devez vous connecter pour publier un commentaire.