Spróbuj tego:

git reset --hard HEAD
git pull

Uwaga: git clean usuwa wszystkie pliki/katalogi, których nie można cofnąć.

Czasami po prostu clean -f nie pomaga. W przypadku, gdy masz nie śledzone katalogi, potrzebna jest również opcja-d:

# WARNING: this can't be undone!

git reset --hard HEAD
git clean -f -d
git pull

Uwaga: git clean usuwa wszystkie pliki/katalogi, których nie można cofnąć.

Rozważ użycie -n (--dry-run) najpierw flaga. To pokaże ci, co zostanie usunięte bez faktycznego usuwania czegokolwiek:

git clean -n -f -d

Przykład wyjście:

Would remove untracked-file-1.txt
Would remove untracked-file-2.txt
Would remove untracked/folder
...

Jak Jeż myślę, że odpowiedzi są straszne. Ale chociaż odpowiedź Jeża może być lepsza, nie sądzę, aby była tak elegancka, jak mogłaby być. Sposób, w jaki to zrobiłem, to użycie "fetch" i "merge" z określoną strategią. Co powinno sprawić, że Twoje lokalne zmiany zostaną zachowane, o ile nie są one jednym z plików, które próbujesz wymusić nadpisanie.

Najpierw wykonaj commit swoich zmian

 git add *
 git commit -a -m "local file server commit message"

Następnie pobierz zmiany i zastąp je, jeśli jest konflikt

 git fetch origin master
 git merge -s recursive -X theirs origin/master

" - X "jest nazwą opcji, a" ich " jest wartością dla tej opcji. Decydujesz się na użycie" ich "zmian, zamiast" Twoich " zmian w przypadku konfliktu.

Zamiast robić:

git fetch --all
git reset --hard origin/master

Radzę zrobić co następuje:

git fetch origin master
git reset --hard origin/master

Nie trzeba pobierać wszystkich pilotów i gałęzi, jeśli zamierzasz zresetować gałąź origin / master, prawda?

Wygląda na to, że najlepszym sposobem jest najpierw zrobić:

git clean

, aby usunąć wszystkie Nie śledzone pliki, a następnie kontynuować zwykłą git pull...

Ostrzeżenie, wykonanie tego spowoduje trwałe usunięcie plików, jeśli w Twoim pliku gitignore znajdują się wpisy w katalogu/*.

Niektóre odpowiedzi wydają się być straszne. Straszne w sensie tego, co stało się @Lauri, podążając za sugestią Davida Avsajaniszwilego.

Raczej (git > v1.7.6):

git stash --include-untracked
git pull

Później możesz wyczyścić historię skrytki.

Ręcznie, jeden po drugim:

$ git stash list
stash@{0}: WIP on <branch>: ...
stash@{1}: WIP on <branch>: ...

$ git stash drop stash@{0}
$ git stash drop stash@{1}

Brutalnie, wszystko na raz:

$ git stash clear

Oczywiście jeśli chcesz wrócić do co schowałeś:

$ git stash list
...
$ git stash apply stash@{5}

To polecenie może okazać się pomocne w odrzuceniu lokalnych zmian:

git checkout <your-branch> -f

A następnie wykonaj czyszczenie (usuwa nie śledzone pliki z drzewa roboczego):

git clean -f

Jeśli chcesz usunąć nie śledzone katalogi oprócz Nie śledzonych plików:

git clean -fd

Zamiast scalać z git pull, spróbuj tak:

git fetch --all

, po którym następuje:

git reset --hard origin/master.

Jedyne co mi się udało to:

git reset --hard HEAD~5

To zabierze Ci pięć commitów, a następnie

git pull

Znalazłem to szukającjak cofnąć Git merge .

Problem z tymi wszystkimi rozwiązaniami polega na tym, że wszystkie są albo zbyt złożone, albo, jeszcze większy problem, polega na tym, że usuwają one wszystkie Nie śledzone pliki z serwera www, czego nie chcemy, ponieważ zawsze są potrzebne pliki konfiguracyjne, które znajdują się na serwerze, a nie w repozytorium Git.

Oto najczystsze rozwiązanie, którego używamy:

# Fetch the newest code
git fetch

# Delete all files which are being added, so there
# are no conflicts with untracked files
for file in `git diff HEAD..origin/master --name-status | awk '/^A/ {print $2}'`
do
    rm -f -- "$file"
done

# Checkout all files which were locally modified
for file in `git diff --name-status | awk '/^[CDMRTUX]/ {print $2}'`
do
    git checkout -- "$file"
done

# Finally pull all the changes
# (you could merge as well e.g. 'merge origin/master')
git pull

• Pierwsze polecenie pobiera najnowsze dane.

• Drugie polecenie sprawdza, czy są jakieś pliki które są dodawane do repozytorium i usuwają te nie śledzone pliki z lokalnego repozytorium, które mogłyby powodować konflikty.

• Trzecie polecenie sprawdza wszystkie pliki, które zostały lokalnie zmodyfikowane.

• Na koniec robimy pull, aby zaktualizować do najnowszej wersji, ale tym razem bez żadnych konfliktów, ponieważ nie śledzone pliki, które są w repo, już nie istnieją, a wszystkie lokalnie zmodyfikowane pliki są takie same jak w repozytorium.

Miałem ten sam problem. Nikt nie dał mi tego rozwiązania, ale zadziałało na mnie.

Rozwiązałem przez:

1. Usuwanie wszystkich plików. Zostawićkatalog git.
2. git reset --hard HEAD
3. git pull
4. git push

Po pierwsze, spróbuj w standardowy sposób:

git reset HEAD --hard # Remove all not committed changes

Jeśli powyższe nie pomoże i nie dbasz o swoje Nie śledzone pliki/katalogi( zrób najpierw kopię zapasową na wszelki wypadek), wykonaj następujące proste kroki:

cd your_git_repo  # where 'your_git_repo' is your git repository folder
rm -rfv *         # WARNING: only run inside your git repository!
git pull          # pull the sources again

Usunie wszystkie pliki git (Exempt .git/ dir, gdzie masz wszystkie commity) i wyciągnie je ponownie.

Dlaczego git reset HEAD --hard może zawieść w niektórych przypadkach?

1. Reguły niestandardowe w .gitattributes file

   Posiadanie eol=lf zasady w .gitattributes może powodować git modyfikuje niektóre zmiany w plikach poprzez konwersję zakończeń linii CRLF na LF w niektórych plikach tekstowych.

   Jeśli tak jest, Musisz zatwierdzić te zmiany CRLF/LF (przeglądając je w git status), lub spróbować: git config core.autcrlf false, aby tymczasowo je zignorować.

2. Niezrozumiałość systemu plików

   Gdy używasz systemu plików, który nie obsługuje atrybutów uprawnień. W przykładzie masz dwa repozytoria, jeden na Linuksie / Mac (ext3/hfs+) i jeszcze jeden na bazie FAT32/NTFS system plików.

   Jak zauważyłeś, istnieją dwa różne rodzaje systemów plików, więc ten, który nie obsługuje uprawnień uniksowych, w zasadzie nie może zresetować uprawnień do plików w systemie, który nie obsługuje tego rodzaju uprawnień, więc bez względu na to, jak --hard spróbujesz, git zawsze wykrywa pewne "zmiany".

Miałem podobny problem. Musiałem to zrobić:

git reset --hard HEAD
git clean -f
git pull

Podsumowałem inne odpowiedzi. Możesz wykonać git pull bez błędów:

git fetch --all
git reset --hard origin/master
git reset --hard HEAD
git clean -f -d
git pull

Warning : Ten skrypt jest bardzo potężny, więc możesz stracić swoje zmiany.

Bazując na moich podobnych doświadczeniach, rozwiązanie zaproponowane powyżej przez Strahinję Kustudic jest zdecydowanie najlepsze. Jak zauważyli inni, po prostu twardy reset usunie wszystkie nie śledzone pliki, które mogą zawierać wiele rzeczy, których nie chcesz usunąć, takich jak pliki konfiguracyjne. Bezpieczniej jest usunąć tylko te pliki, które mają zostać dodane, a w tym przypadku prawdopodobnie chcesz również wymeldować dowolne lokalnie zmodyfikowane pliki, które mają zostać zaktualizowane.

Że w tym celu zaktualizowałem skrypt Kustudica. Naprawiłem też literówkę (brak w oryginale).

#/bin/sh

# Fetch the newest code
git fetch

# Delete all files which are being added,
# so there are no conflicts with untracked files
for file in `git diff HEAD..origin/master --name-status | awk '/^A/ {print $2}'`
do
    echo "Deleting untracked file $file..."
    rm -vf "$file"
done

# Checkout all files which have been locally modified
for file in `git diff HEAD..origin/master --name-status | awk '/^M/ {print $2}'`
do
    echo "Checking out modified file $file..."
    git checkout $file
done

# Finally merge all the changes (you could use merge here as well)
git pull

Bonus:

Mówiąc o pull/fetch/merge w poprzednich odpowiedziach, chciałbym podzielić się ciekawą i produktywną sztuczką,

git pull --rebase

Powyższa komenda jest najbardziej użyteczną komendą w moim życiu Gita, która zaoszczędziła dużo czasu.

Przed wysłaniem nowego commita na serwer, wypróbuj to polecenie, które automatycznie zsynchronizuje ostatnie zmiany na serwerze (za pomocą fetch + merge) i umieści Twój commit na górze w Dzienniku Git. Nie ma żadnych musisz się martwić ręcznym ciągnięciem / scalaniem.

Znajdź szczegóły w co robi "git pull --rebase"?.

Uważam, że istnieją dwie możliwe przyczyny konfliktu, które muszą być rozwiązane oddzielnie, i o ile mogę powiedzieć, że żadna z powyższych odpowiedzi Nie dotyczy obu:

• Pliki lokalne, które nie są śledzone, muszą zostać usunięte, ręcznie (bezpieczniej) lub zgodnie z sugestią w innych odpowiedziach, przez git clean -f -d

• Lokalne commity, które nie znajdują się w zdalnej gałęzi, również muszą zostać usunięte. IMO najprostszym sposobem na osiągnięcie tego jest: git reset --hard origin/master (zastąp 'master' przez jakąkolwiek gałąź jesteś praca nad, i uruchomić git fetch origin pierwszy)

Łatwiej byłoby:

git checkout --theirs /path/to/file.extension
git pull origin master

To nadpisze twój lokalny plik z plikiem w git

Wygląda na to, że większość odpowiedzi jest skupiona na gałęzi master; jednak czasami pracuję nad tą samą gałęzią funkcji w dwóch różnych miejscach i chcę, aby rebase w jednym odzwierciedlał się w drugim bez wielu skoków przez obręcze.

Bazując na kombinacji odpowiedzi RNA i odpowiedzi torka na podobne pytanie , wymyśliłem to, co działa znakomicie:

git fetch
git reset --hard @{u}

Uruchom to z gałęzi, a zresetuje tylko Twoje lokalne gałąź do wersji upstream.

Można to również umieścić w aliasie git (git forcepull):

git config alias.forcepull "!git fetch ; git reset --hard @{u}"

Lub w pliku .gitconfig:

[alias]
  forcepull = "!git fetch ; git reset --hard @{u}"

Miałem ten sam problem i z jakiegoś powodu, nawet git clean -f -d by tego nie zrobił. Oto dlaczego: z jakiegoś powodu, jeśli Twój plik jest ignorowany przez Git (poprzez a .zakładam, że wpis gitignore), nadal przeszkadza w nadpisaniu tego za pomocą późniejszego pull , ale clean nie usunie go, chyba że dodasz -x.

Sam to rozwiązałem przez:

git checkout -b tmp # "tmp" or pick a better name for your local changes branch
git add -A
git commit -m 'tmp'
git pull
git checkout master # Or whatever branch you were on originally
git pull
git diff tmp

Gdzie ostatnie polecenie podaje listę lokalnych zmian. Zmodyfikuj gałąź "tmp", aż będzie ona akceptowalna, a następnie połącz z powrotem na master za pomocą:

git checkout master && git merge tmp

Następnym razem, prawdopodobnie poradzisz sobie z tym w czystszy sposób, patrząc na "gałąź Git stash", chociaż stash może sprawiać problemy przy pierwszych kilku próbach, więc zrób pierwszy eksperyment na niekrytycznym projekcie...

Mam dziwną sytuację, że ani git clean Ani git reset nie działają. Muszę usunąć plik kolidujący z git index za pomocą następującego skryptu na każdym nieprzetworzonym pliku:

git rm [file]

Te cztery polecenia działają dla mnie.

git reset --hard HEAD
git checkout origin/master
git branch -D master
git checkout -b master

Aby sprawdzić / wyciągnąć po wykonaniu tych poleceń

git pull origin master

Próbowałem wiele, ale w końcu udało mi się z tymi poleceniami.

Pomimo oryginalnego pytania, najlepsze odpowiedzi mogą powodować problemy dla osób, które mają podobny problem, ale nie chcą stracić swoich lokalnych plików. Zobacz na przykład komentarze Al-punka i crizcraiga.

Następująca wersja zatwierdza Twoje lokalne zmiany do tymczasowej gałęzi (tmp), sprawdza oryginalną gałąź (którą zakładam, że jest master) i łączy aktualizacje. Możesz to zrobić za pomocą stash, ale odkryłem, że zwykle łatwiej jest po prostu użyć gałęzi / merge podejdźcie.

git checkout -b tmp
git add *; git commit -am "my temporary files"
git checkout master

git fetch origin master
git merge -s recursive -X theirs origin master

Gdzie zakładamy, że inne repozytorium to origin master.

Po prostu zrób

git fetch origin branchname
git checkout -f origin/branchname // This will overwrite ONLY new included files
git checkout branchname
git merge origin/branchname

Więc unikasz wszystkich niepożądanych efektów ubocznych, takich jak usuwanie plików lub katalogów, które chcesz zachować, itp.

Zresetuj indeks i głowę do origin/master, ale nie zresetuj drzewa roboczego:

git reset origin/master

Znam o wiele łatwiejszą i mniej bolesną metodę:

$ git branch -m [branch_to_force_pull] tmp
$ git fetch
$ git checkout [branch_to_force_pull]
$ git branch -D tmp

Przeczytałem wszystkie odpowiedzi, ale szukałem jednego polecenia, aby to zrobić. Oto co zrobiłem. Dodano alias git do .gitconfig

[alias]
      fp = "!f(){ git fetch ${1} ${2} && git reset --hard ${1}/${2};};f"

Uruchom polecenie jako

git fp origin master

Odpowiednik

git fetch origin master
git reset --hard origin/master

Wymagania:

1. śledź lokalne zmiany, żeby nikt ich nie zgubił.
2. spraw, aby lokalne repozytorium pasowało do repozytorium zdalnego pochodzenia.

Rozwiązanie:

1. Stash lokalne zmiany.

2. Pobieranie z czystym z Plików i katalogów ignorując .gitignore i hard reset do origin .

   git stash --include-untracked
   git fetch --all
   git clean -fdx
   git reset --hard origin/master