Comment ignorer une erreur sur «git pull» à propos de mes modifications locales qui seraient écrasées par la fusion?

Comment ignorer le message d'erreur suivant sur Git Pull?

Vos modifications locales dans les fichiers suivants seraient écrasées par la fusion

Et si je veux les écraser?

J'ai essayé des choses comme git pull -f, mais rien ne fonctionne.

Pour être clair, je veux seulement écraser des modifications spécifiques, pas tout.

Si vous souhaitez supprimer toutes les modifications locales - y compris les fichiers non suivis par git - de votre copie de travail, il vous suffit de les ranger:

git stash push --include-untracked

Si vous n'en avez plus besoin, vous pouvez maintenant laisser tomber cette réserve:

git stash drop

Si vous ne voulez pas cacher les modifications que vous avez déjà mises en place - par exemple avec git add- alors ajoutez l'option --keep-index. Notez cependant que cela empêchera toujours la fusion si ces modifications par étapes entrent en collision avec celles en amont.

Si vous souhaitez remplacer uniquement des parties spécifiques de vos modifications locales, il existe deux possibilités:

1. Validez tout ce que vous ne voulez pas écraser et utilisez la méthode ci-dessus pour le reste.

2. Utilisez git checkout path/to/file/to/revertpour les modifications que vous souhaitez remplacer. Assurez-vous que le fichier n'est pas transféré via git reset HEAD path/to/file/to/revert.

D'accord avec l'aide des deux autres réponses, j'ai trouvé une solution directe:

git checkout HEAD^ file/to/overwrite
git pull

Cela fonctionne pour moi pour remplacer toutes les modifications locales et ne nécessite pas d'identité:

git reset --hard
git pull

Voici une solution qui supprime les modifications par étapes:

git reset file/to/overwrite
git checkout file/to/overwrite

Vous pouvez soit valider vos modifications avant d'effectuer la fusion, soit les cacher:

1. git stash save
2. git merge origin/master
3. git stash pop

Si vous souhaitez supprimer vos modifications locales sur un fichier, vous pouvez procéder comme suit:

git checkout -- <file>

Ensuite, vous pouvez remplacer le fichier [s] par la dernière version en faisant simplement:

git pull

Si votre référentiel contient quelques fichiers qui sont supprimés de master:

1. git checkout master
2. git fetch origin
3. git reset --hard origin/master
4. git checkout -b newbranch

Parfois, rien de tout cela ne fonctionne. De façon ennuyeuse, en raison de la chose LF, je pense que ce qui fonctionnera est la suppression des fichiers, puis la traction. Ce n'est pas que je recommande cette solution, mais si le fichier n'existe pas, git ne vous informera pas inutilement que vos modifications (qui ne sont peut-être même pas des modifications) seront annulées et vous permettront de continuer.

À utiliser à vos risques et périls.

git stash save --keep-index n'a pas fonctionné pour moi.

la commande ci-dessous a fonctionné comme prévu.

git reset --hard
git pull

Il remplace toutes les modifications locales si vous n'en avez pas besoin.

Tellement de réponses ici que je déteste en ajouter une autre, mais toutes les réponses ci-dessus sont plus maladroites qu'elles ne devraient l'être. Je dois le faire tout le temps car Git semble devenir confus et dit que j'ai modifié des fichiers qui n'ont pas changé (ne peut pas revenir en arrière parce qu'ils n'ont pas changé, mais je ne peux pas tirer parce qu'ils sont censés avoir changé) Plus simple et le plus rapide que j'ai trouvé jusqu'à présent est:

git stash
git stash drop
git pull

Dans le récent Git, vous pouvez ajouter la commande -r/ --rebaseon pullpour rebaser votre branche actuelle au-dessus de la branche en amont après la récupération. L'avertissement devrait disparaître, mais il y a un risque que vous ayez des conflits que vous devrez résoudre.

Vous pouvez également extraire différentes branches avec force, puis revenir à masternouveau, par exemple:

git checkout origin/master -f
git checkout master -f

Tirez-le à nouveau comme d'habitude:

git pull origin master

L'utilisation de cette méthode peut vous faire économiser du temps de stashing ( git stash) et d'éventuels problèmes d'autorisation, de réinitialisation de fichiers ( git reset HEAD --hard), de suppression de fichiers ( git clean -fd), etc.

Ce problème est dû au fait que vous avez modifié localement les fichiers / s et que les mêmes fichiers existent avec les modifications dans le référentiel Git, donc avant de tirer / pousser, vous aurez besoin de cacher les modifications locales:

Pour remplacer les modifications locales d'un seul fichier:

git reset file/to/overwrite
git checkout file/to/overwrite

Pour écraser toutes les modifications locales (modifications dans tous les fichiers):

git stash
git pull
git stash pop

Ce problème peut également être dû au fait que vous êtes sur une branche qui n'est pas fusionnée avec la branche principale.

git reset --hard && git clean -df

Attention : Cela réinitialisera et supprimera tous les fichiers non suivis.

Vous pouvez l'utiliser pour remplacer le fichier

git checkout file_to_overwrite

La meilleure façon de résoudre ce problème est:

git checkout -- <path/file_name>

Après cela, vous pouvez remplacer le fichier par:

git pull origin master

Cela a fonctionné pour moi pour annuler les modifications sur le serveur distant en direct et tirer du contrôle de source GitHub:

git reset --hard
git pull origin master

Voici ma stratégie pour résoudre le problème.

Énoncé du problème

Nous devons apporter des modifications à plus de 10 fichiers. Nous avons essayé PULL (git pull origin master), mais Git a crié:

erreur: vos modifications locales aux fichiers suivants seraient écrasées par la fusion: veuillez valider vos modifications ou les cacher avant de pouvoir les fusionner.

Nous avons essayé d'exécuter commitet puis pull, mais ils n'ont pas fonctionné non plus.

Solution

Nous étions dans le sale étape, parce que les fichiers se trouvaient dans la "zone de transit" alias "zone d'index" et certains étaient dans la "zone de tête" alias "répertoire Git local". Et nous voulions retirer les modifications du serveur.

Consultez ce lien pour obtenir des informations claires sur les différentes étapes de Git: GIT Stages

Nous avons suivi les étapes suivantes

• git stash (cela a rendu notre répertoire de travail propre. Vos modifications sont stockées sur la pile par Git).
• git pull origin master (Tirez les modifications du serveur)
• git stash apply (Appliqué toutes les modifications de la pile)
• git commit -m 'message' (Validé les modifications)
• git push origin master (Poussé les modifications sur le serveur)
• git stash drop (Déposez la pile)

Comprenons quand et pourquoi vous avez besoin de ranger

Si vous êtes dans un état sale , cela signifie que vous apportez des modifications dans vos fichiers et que vous êtes obligé, pour une raison quelconque, de tirer ou de basculer vers une autre branche pour un travail très urgent, donc à ce stade, vous ne pouvez pas tirer ou basculez jusqu'à ce que vous validiez votre changement. La stashcommande est ici comme un coup de main.

Extrait du livre ProGIT , 2e édition:

Souvent, lorsque vous travaillez sur une partie de votre projet, les choses sont dans un état désordonné et vous voulez changer de branche pour travailler un peu sur autre chose. Le problème est que vous ne voulez pas faire un commit de travail à moitié fait juste pour pouvoir revenir à ce point plus tard. La réponse à ce problème est la commande git stash. Le stashing prend l'état sale de votre répertoire de travail - c'est-à-dire vos fichiers suivis modifiés et les changements intermédiaires - et l'enregistre sur une pile de changements inachevés que vous pouvez réappliquer à tout moment.

Si vous souhaitez remplacer des modifications spécifiques, vous avez besoin d'un moyen de lui indiquer celles que vous souhaitez oublier.

Vous pouvez essayer de masquer de manière sélective les modifications que vous souhaitez abandonner git stash --patch, puis de les supprimer git stash drop. Vous pouvez ensuite récupérer les modifications à distance et les fusionner normalement.

TL; DR;

git pull --rebase --autostash

  -r, --rebase[=false|true|merges|preserve|interactive]
       When true, rebase the current branch on top of the upstream branch after
       fetching. If there is a remote-tracking branch corresponding to the upstream

  --autostash, --no-autostash
       Before starting rebase, stash local modifications away if
       needed, and apply the stash entry when done

Je ne sais pas pourquoi cela n'est pas encore répondu, mais la solution, comme vous pouvez le voir, est simple. Toutes les réponses ici suggèrent la même chose: pour supprimer / enregistrer vos modifications locales et appliquer en amont, puis (si voussave ) appliquez vos modifications locales par-dessus.

Que git pull --rebase --autostashfait étape par étape:

1. your local changes saved by `--autostash`
2. your local commits saved by `--rebase`
3. commits from upstream applied to your branch
4. your local commits are restored on top of upstream
5. your local changes are restored to working directory

Mon cas (probablement le vôtre aussi):

J'ai des changements locaux (changements dans le répertoire de travail):

Lorsque j'essaie de tirer des modifications à distance, j'obtiens une erreur:

Ces changements n'entrecoupent pas les changements locaux:

Donc, lorsque je pull --rebase --autostashchange localement les modifications enregistrées et appliquées sans aucun problème automatiquement

Maintenant, mes changements locaux sont légèrement inférieurs:

J'avais un cas particulier: j'avais un fichier avec --assume-inchangé dessus. Il était difficile à localiser, car la git statuscommande ne montrait aucun changement

Si vous souhaitez conserver les modifications de production sur le serveur, fusionnez-les simplement dans un nouvel élément de configuration. La méthode de traitement est la suivante:

git stash
git pull
git stash pop

Peut-être que vous n'exécutez pas toutes les opérations. Vous pouvez savoir ce que vous pouvez faire ensuite.

J'ignorais un fichier dans mon référentiel et quand je l'ai fait, git pull upstream masterj'ai eu l'erreur suivante:

erreur: vos modifications locales dans les fichiers suivants seraient écrasées par fusion: myfile.js Veuillez valider vos modifications ou les cacher avant de pouvoir fusionner. Abandon

Pour le résoudre, j'ai fait ce qui suit

git update-index --no-assume-unchanged myfile.js

Je l'ai ensuite fait git statuset j'ai reçu ce message

Sur le maître de branche Votre branche est derrière «origine / maître» par 4 validations et peut être avancée rapidement. (utilisez "git pull" pour mettre à jour votre branche locale)

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é: myfile.js

aucune modification ajoutée pour valider (utilisez "git add" et / ou "git commit -a")

Ensuite, j'ai git checkout myfile.jssuivi git pull upstream master. Cette fois, l'opération git pull a réussi.

J'ai rencontré cela en tirant du maître.

La façon dont je l'ai géré, en utilisant Visual Studio;

1. Tout d'abord, j'ai effectué la validation d'annulation sur ma solution.
2. Ensuite, j'ai fait le processus Git Pull.

J'espère que cela t'aides!

La solution la plus simple est:

git reset --hard && git pull

Je suis nouveau dans git et je ne sais pas si ma solution est une bonne idée.

J'ai testé TOUTES les réponses et aucune n'a fonctionné pour moi!

Mais j'ai trouvé une autre solution:

1. Backup both of local and repository versions of the file.
2. Delete the file from repository.
3. git add .
4. git commit
5. git push

J'espère que cela t'aides.

L'erreur «Vos modifications locales aux fichiers suivants seraient écrasées par la fusion» vient du fait que vous avez des modifications dans le référentiel local qui n'ont PAS encore été validées, donc avant de retirer du référentiel distant, validez simplement les modifications dans le référentiel local.

Disons que votre référentiel distant a une branche xyz et que vous souhaitez que cette branche distante xyz soit fusionnée (copiée dans) la branche locale repo xyz,

{
git checkout xyz                  //check out to the respective branch in local repo
git commit -m "commiting message" //commit changes if any, in local repo branch xyz
git pull                          //it pulls remote xyz branch into local xyz branch
}

Si cette erreur est due à des fins de ligne,

git add
git checkout mybranch

marchera. Je ne sais pas vraiment pourquoi cela fonctionne.

Pour Pycharm, vous pouvez faire Git -> Revert puis tirer.

Ce message peut également se produire si git-lfs est utilisé et qu'un pointeur de fichier a été remplacé par un fichier réel.

alors vous utilisez:

git stash
git lfs migrate import
git pull

sortie complète de mon cas

λ git stash
Saved working directory and index state WIP on master: 5d4ad47 Merge branch 'feature/...' into 'master'
Encountered 1 file(s) that should have been pointers, but weren't:
        public/apple-touch-icon.png

λ git pull
Updating 5a4ad44..b25f79d
error: Your local changes to the following files would be overwritten by merge:
        public/apple-touch-icon.png
Please commit your changes or stash them before you merge.
Aborting

λ git lfs migrate import
migrate: Fetching remote refs: ..., done
migrate: Sorting commits: ..., done
migrate: Rewriting commits: 100% (0/0), done
migrate: Updating refs: ..., done
migrate: checkout: ..., done


λ git pull
Updating 5d4ad47..a25c79a
Fast-forward
 public/apple-touch-icon.png | Bin 2092 -> 130 bytes
 public/favicon.ico          | Bin 6518 -> 1150 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)

voir https://github.com/git-lfs/git-lfs/issues/2839

J'ai essayé et avec succès, avant de tirer, laissez valider tous les fichiers que vous n'avez pas validés, alors vous ne recevrez pas ces messages d'AS.