Jak zignorować błąd w 'git pull', że moje lokalne zmiany zostaną nadpisane przez merge?

Jeśli chcesz usunąć wszystkie lokalne zmiany-w tym pliki, które nie są śledzone przez git - z twojej kopii roboczej, po prostu ukryj je:

git stash push --include-untracked

Jeśli już ich nie potrzebujesz, teraz możesz upuścić ten Schowek: {]}

git stash drop

Jeśli nie chcesz ukrywać zmian, które już wstawiłeś - np. za pomocą git add - Dodaj opcję --keep-index. Zauważ jednak, że to nadal uniemożliwi scalanie, jeśli te zmiany etapowe zderzą się z tymi z pierwotnego źródła.

Jeśli chcesz tylko nadpisać konkretne części twoich lokalnych zmian, są dwie możliwości:

1. Zatwierdź wszystko, czego nie chcesz nadpisać i użyj powyższej metody do reszty.

2. Użyj git checkout path/to/file/to/revert dla zmian, które chcesz nadpisać. Upewnij się, że plik nie jest przechowywany przez git reset HEAD path/to/file/to/revert.

To działa dla mnie, aby nadpisać wszystkie lokalne zmiany i nie wymaga tożsamości:

git reset --hard
git pull

Oto rozwiązanie, które odrzuca zmiany:

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

Możesz albo zatwierdzić zmiany przed połączeniem, albo je ukryć:

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

Jeśli chcesz odrzucić lokalne zmiany w jednym pliku, możesz wykonać następujące czynności:

git checkout -- <file>

Wtedy możesz nadpisać plik [s] najnowszą wersją wykonując tylko:

git pull

Tak wiele odpowiedzi tutaj, że nienawidzę dodawać kolejne, ale wszystkie powyższe są clunkier niż muszą być. Muszę to robić cały czas, ponieważ Git wydaje się być zdezorientowany i mówi, że zmodyfikowałem pliki, które się nie zmieniły (nie mogę przywrócić, ponieważ się nie zmieniły, ale nie mogę wyciągnąć, ponieważ rzekomo się zmieniły) najprostsze i najszybsze, jakie do tej pory znalazłem to:

git stash
git stash drop
git pull

Zawiadomienie: local zmiany zostaną utracone

Jeśli Twoje repozytorium zawiera kilka plików, które zostały usunięte z master:

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

Czasami nic z tych rzeczy nie działa. Irytujące, ze względu na to, co myślę, że LF zadziała, to usunięcie Plików, następnie ściągnięcie. Nie żebym polecał To rozwiązanie, ale jeśli plik nie istnieje, git nie poinformuje cię, że Twoje zmiany (które mogą nawet nie być zmianami) zostaną nadpisane i pozwoli Ci kontynuować.

Używaj na własne ryzyko.

git stash save --keep-index nie zadziałało na mnie.

Poniższe polecenie działało zgodnie z oczekiwaniami.

git reset --hard
git pull

Zastępuje wszystkie lokalne zmiany, jeśli ich nie potrzebujesz.

W ostatnim Git, możesz dodać -r/--rebase na pull polecenie rebase bieżącej gałęzi na górze gałęzi upstream Po pobraniu. Ostrzeżenie powinno zniknąć, ale istnieje ryzyko, że pojawią się konflikty, które będziesz musiał rozwiązać.

Alternatywnie możesz wymeldować inną gałąź z siłą, a następnie wrócić do master ponownie, np.:

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

Następnie pociągnij ponownie jak zwykle:

git pull origin master

Korzystanie z tej metody może zaoszczędzić czas od przechowywania (git stash) i potencjalne problemy z uprawnieniami, Resetowanie plików (git reset HEAD --hard), usuwanie plików (git clean -fd) itp. Również powyższe jest łatwiejsze do zapamiętania.

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

Nie wiem, dlaczego jeszcze na to nie udzielono odpowiedzi, ale rozwiązanie, jak widzicie, jest proste. Wszystkie odpowiedzi sugerują to samo: aby usunąć / zapisać swoje lokalne zmiany i zastosować je pod prąd, a następnie (jeśli save) zastosować swoje lokalne zmiany na górze.

Co git pull --rebase --autostash robi krok po kroku:

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

Moja sprawa (prawdopodobnie twoja też):

Mam zmiany lokalne (zmiany w katalogu roboczym):

Kiedy próbuję aby ściągnąć zdalne zmiany dostaję błąd:

Te zmiany nie przecinają się ze zmianami lokalnymi:

Więc kiedy pull --rebase --autostash lokalne zmiany zapisywane i stosowane bez żadnego problemu automatycznie

Teraz moje lokalne zmiany są trochę niższe:

Problem polega na tym, że dokonałeś zmian lokalnie w plikach i te same pliki istnieją ze zmianami w repozytorium Git, więc przed pull / push będziesz potrzebował stash lokalnych zmian:

Aby nadpisać lokalne zmiany pojedynczego pliku:

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

Aby nadpisać wszystkie lokalne zmiany (zmiany we wszystkich plikach):

git stash
git pull
git stash pop

Również ten problem może być spowodowany tym, że znajdujesz się na gałęzi, która nie jest połączona z gałęzią master.

git reset --hard && git clean -df

Uwaga: spowoduje to zresetowanie i usunięcie wszystkich nie śledzonych plików.

Możesz użyć tego do nadpisania pliku

git checkout file_to_overwrite

Najlepszym sposobem rozwiązania tego problemu jest:

git checkout -- <path/file_name>

Następnie możesz nadpisać plik przez:

git pull origin master

Pomogło mi to odrzucić zmiany na zdalnym serwerze live i pobrać je z kontrolki źródłowej GitHub:

git reset --hard
git pull origin master

Oto moja strategia rozwiązania problemu.

Problem Statement

Musimy wprowadzić zmiany w więcej niż 10 plikach. Próbowaliśmy PULL (git pull origin master), ale Git krzyknął:

Błąd: Twoje lokalne zmiany w następujących plikach zostaną nadpisane przez scalanie: proszę, zatwierdź zmiany lub schowaj je, zanim będziesz mógł / align = "left" /

Próbowaliśmy wykonać commit, a potem pull, ale też nie zadziałały.

Rozwiązanie

We w rzeczywistości były w etapie dirty , Ponieważ pliki były w "Staging Area" vel "Index Area", a niektóre były w " Head Area "vel"local Git directory". I chcieliśmy wyciągnąć zmiany z serwera.

Sprawdź ten link, aby uzyskać informacje na temat różnych etapów Gita w jasny sposób: GIT Stages

Wykonaliśmy następujące kroki

• git stash (dzięki temu nasz katalog roboczy jest czysty. Twoje zmiany są przechowywane na stack by Git).
• W tym celu należy pobrać zmiany z serwera.]}
• git stash apply (zastosowano wszystkie zmiany ze stosu)
• git commit -m 'message' (popełniono zmiany)
• Na serwerze nie ma żadnych zmian.]}
• git stash drop (upuść stos)

Zrozummy, kiedy i dlaczego trzeba przechowywać

Jeśli znajdujesz się w stanie dirty , oznacza to, że dokonujesz zmian w swoich plikach, a następnie jesteś zmuszony, z jakiegokolwiek powodu, do pull or switch to another branch for some very pilny work, so at this point you can ' t pull or switch until you commit your change. Polecenie stash jest tutaj jako pomocna dłoń.

Z książki ProGIT , wydanie II:

Często, gdy pracujesz nad częścią swojego projektu, rzeczy są w niechlujny stan i chcesz przełączyć gałęzie na trochę do pracy coś innego. Problem w tym, że nie chcesz popełnić połowa roboty, żebyś mógł wrócić do tego punktu później. Na odpowiedzią na ten problem jest polecenie git stash. Stashing takes the brudny stan twojego katalogu roboczego – czyli Twój zmodyfikowany plików i wystawionych zmian – i zapisuje je na stosie niedokończonych zmiany, które możesz zastosować ponownie w dowolnym momencie.

Jeśli chcesz nadpisać konkretne zmiany, musisz w jakiś sposób powiedzieć, które z nich chcesz zapomnieć.

Możesz spróbować selektywnie schować zmiany, które chcesz porzucić, używając git stash --patch, a następnie upuścić ten Schowek za pomocą git stash drop. Następnie możesz pobrać zdalne zmiany i połączyć je w normalny sposób.

Jeśli chcesz zachować zmiany produkcyjne na serwerze, po prostu połącz się z nową pozycją konfiguracyjną. Metoda przetwarzania jest następująca:

git stash
git pull
git stash pop

Najprostszym rozwiązaniem jest:

git reset --hard && git pull

Błąd "Twoje lokalne zmiany w następujących plikach zostaną nadpisane przez scalenie" pojawia się, ponieważ masz pewne zmiany w lokalnym repo, które nie zostały jeszcze zatwierdzone, więc przed pobraniem ze zdalnego repo po prostu zatwierdź zmiany w lokalnym repo.

Powiedzmy, że Twój zdalny repo ma jakąś gałąź xyz i chcesz, aby zdalna gałąź repo xyz została scalona w (skopiowaną do) lokalną gałąź 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
}

Miałem specjalny przypadek tego: miałem Plik z -- assume-unchanged na nim. Było to trudne do zlokalizowania, ponieważ polecenie git status nie pokazywało żadnych zmian

Ignorowałem plik w repo i kiedy zrobiłem git pull upstream master otrzymałem następujący błąd:

Błąd: Twoje lokalne zmiany w następujących plikach zostaną nadpisane przez scalanie: myfile.js Proszę zatwierdź zmiany lub ukryj je przed połączeniem. Przerywanie

Aby go rozwiązać zrobiłem następujące

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

Potem zrobiłem git status i dostałem tę wiadomość

Na gałęzi master twoja gałąź jest za 'origin/master' przez 4 commity, i może być szybkie przekierowanie. (użyj "git pull", aby zaktualizować swój lokalny branch)

Zmiany nie wystawione dla commit: (użyj "git add ..."do aktualizacji co zostanie popełnione) (użyj "git checkout -- ..."do wyrzucenia zmiany w katalogu roboczym)

Modified: myfile.js

Brak zmian w zatwierdzeniu (użyj "git add" i/lub "git commit-a")

Potem zrobiłem git checkout myfile.js a potem git pull upstream master. Tym razem operacja git pull zakończyła się sukcesem.

Natknąłem się na to, wyciągając z mistrza.

Sposób, w jaki sobie z tym poradziłem, używając Visual Studio;

1. najpierw wykonałem Undo commit na moim rozwiązaniu.
2. potem zrobiłem proces Git pull.

Mam nadzieję, że to pomoże!

Próbowałem i to z powodzeniem, przed wyciągnięciem, niech zatwierdzić wszystkie pliki, które nie zostały popełnione, wtedy nie otrzymasz tych wiadomości od AS.

Jestem nowy w git i nie wiem, czy moje rozwiązanie jest dobrym pomysłem.

Przetestowałem wszystkie odpowiedzi i żadna z nich nie zadziałała na mnie!

Ale znalazłem inne rozwiązanie:

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

Moim rozwiązaniem było delete Pliki spoza IDE, które zostaną nadpisane, a następnie pull.

(zawsze możesz wykonać kopię zapasową i ręcznie połączyć nieprzetworzone dane)

Jeśli ten błąd jest spowodowany zakończeniami linii,

git add
git checkout mybranch

Dla Pycharm, możesz wykonać Git-- > Revert, a następnie pull.