⚠ Important: dacă aveți modificări locale, acestea se vor pierde. Cu sau fără opțiunea --hard, orice comitere locală care nu a fost împinsă se va pierde.^[*]

Dacă aveți fișiere care nu sunt urmărite de Git (de exemplu, conținut de utilizator încărcat), aceste fișiere nu vor fi afectate.

Mai întâi, executați o preluare pentru a actualiza toate origin/<branch> referințe la cea mai recentă:

git fetch --all

Faceți o copie de rezervă a sucursalei dvs. actuale:

git branch backup-master

Apoi, aveți două opțiuni:

git reset --hard origin/master

SAU Dacă vă aflați într-o altă sucursală:

git reset --hard origin/<branch_name>

Explicaţie:

git fetch descarcă cea mai recentă versiune de la distanță fără a încerca să îmbine sau să rebazeze nimic.

Apoi git reset resetează ramura principală la ceea ce tocmai ați preluat. Opțiunea --hard modifică toate fișierele din arborele de lucru pentru a se potrivi cu fișierele din origin/master

Mențineți actualele comisioane locale

^[*]: Este demn de remarcat faptul că este posibil să se mențină comiterile locale actuale prin crearea unei ramuri din master înainte de a reseta:

git checkout master
git branch new-branch-to-save-current-commits
git fetch --all
git reset --hard origin/master

După aceasta, toate comiterile vechi vor fi păstrate în new-branch-to-save-current-commits.

Modificări neangajate

Cu toate acestea, modificările neangajate (chiar în etape) se vor pierde. Asigurați-vă că ați ascunde și comite tot ce aveți nevoie. Pentru asta puteți rula următoarele:

git stash

Și apoi pentru a reaplica aceste modificări neangajate:

git stash pop

Incearca asta:

git reset --hard HEAD
git pull

Ar trebui să facă ce vrei tu.

AVERTISMENT: git clean șterge toate fișierele/directoarele neurmărite și nu poate fi anulat.

Uneori doar clean -f nu ajută. În cazul în care aveți DIRECTORIE neurmărite, este necesară și opțiunea -d:

# WARNING: this can't be undone!

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

AVERTISMENT: git clean șterge toate fișierele/directoarele neurmărite și nu poate fi anulat.

Luați în considerare mai întâi să utilizați indicatorul -n (--dry-run). Acest lucru vă va arăta ce va fi șters fără a șterge nimic:

git clean -n -f -d

Exemplu de ieșire:

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

La fel ca Ariciul, cred că răspunsurile sunt teribile. Dar, deși răspunsul lui Hedgehog ar putea fi mai bun, nu cred că este atât de elegant pe cât ar putea fi. Modul în care am găsit să fac acest lucru este folosind fetch și merge cu o strategie definită. Ceea ce ar trebui să facă astfel încât modificările dvs. locale să fie păstrate atâta timp cât acestea nu sunt unul dintre fișierele cu care încercați să forțați o suprascriere.

Mai întâi faceți o comitere a modificărilor dvs

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

Apoi preluați modificările și suprascrieți dacă există un conflict

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

-X este un nume de opțiune și theirs este valoarea pentru acea opțiune. Alegi să folosești their modificări (cealaltă opțiune este ours modificări) dacă există un conflict.

In loc sa faci:

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

Aș sfătui să faceți următoarele:

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

Nu este nevoie să preluați toate telecomenzile și ramurile dacă aveți de gând să resetați la ramura de origine/master, nu?

Se pare că cel mai bun mod este să faci mai întâi:

git clean

Pentru a șterge toate fișierele neurmărite și apoi continuați cu git pull obișnuit...

Atenție, dacă faceți acest lucru ștergeți definitiv fișierele dacă aveți orice director/* intrări în fișierul dvs. gitignore.

Unele răspunsuri par a fi teribile. Teribil în sensul a ceea ce sa întâmplat cu @Lauri, urmând sugestia lui David Avsajanishvili.

Mai degrabă (git > v1.7.6):

git stash --include-untracked
git pull

Mai târziu, puteți curăța istoricul stocurilor.

Manual, unul câte unul:

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

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

Brutal, dintr-o dată:

$ git stash clear

Desigur, dacă vrei să te întorci la ceea ce ai ascuns:

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

S-ar putea să găsiți această comandă utilă pentru a arunca modificările locale:

git checkout <your-branch> -f

Și apoi faceți o curățare (elimină fișierele neurmărite din arborele de lucru):

git clean -f

Dacă doriți să eliminați directoarele neurmărite pe lângă fișierele neurmărite:

git clean -fd

În loc să fuzionezi cu git pull, încearcă asta:

git fetch --all

urmată de:

git reset --hard origin/master.

Singurul lucru care a funcționat pentru mine a fost:

git reset --hard HEAD~5

Acest lucru vă va duce înapoi cinci comite și apoi cu

git pull

Am descoperit că, căutând cum să anulez o îmbinare Git.

Problema cu toate aceste soluții este că toate sunt fie prea complexe, fie, o problemă și mai mare, este că elimină toate fișierele neurmărite de pe serverul web, ceea ce nu dorim, deoarece sunt întotdeauna necesare fișiere de configurare care sunt activate. server și nu în depozitul Git.

Iată cea mai curată soluție pe care o folosim:

# 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

• Prima comandă preia cele mai noi date.

• A doua comandă verifică dacă există fișiere care sunt adăugate în depozit și șterge acele fișiere neurmărite din depozitul local care ar provoca conflicte.

• A treia comandă verifică toate fișierele care au fost modificate local.

• În cele din urmă facem o tragere pentru a actualiza la cea mai nouă versiune, dar de data aceasta fără conflicte, deoarece fișierele neurmărite care se află în depozit nu mai există și toate fișierele modificate local sunt deja la fel ca în depozit.

În primul rând, încercați modul standard:

git reset HEAD --hard # To remove all not committed changes!
git clean -fd         # To remove all untracked (non-git) files and folders!

^{Avertisment: comenzile de mai sus pot duce la pierderi de date/fișiere numai dacă nu le-ați comis! Dacă nu sunteți sigur, faceți mai întâi o copie de rezervă a întregului folder de depozit.}

Apoi trageți din nou.

Dacă mai sus nu vă ajută și nu vă pasă de fișierele/directoarele neurmărite (faceți mai întâi copierea de rezervă pentru orice eventualitate), încercați următorii pași simpli:

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

Aceasta va ȘTERGE toate fișierele git (cu excepția .git/ dir, unde aveți toate commit-urile) și le va trage din nou.

De ce git reset HEAD --hard ar putea eșua în unele cazuri?

1. Reguli personalizate în .gitattributes file

   Având regula eol=lf în .gitattributes ar putea determina git să modifice unele modificări ale fișierelor prin conversia terminațiilor de linie CRLF în LF în unele fișiere text.

   Dacă acesta este cazul, trebuie să comiteți aceste modificări CRLF/LF (prin revizuirea lor în git status) sau încercați: git config core.autcrlf false să le ignorați temporar.

2. Incompatibilitatea sistemului de fișiere

   Când utilizați un sistem de fișiere care nu acceptă atribute de permisiune. De exemplu, aveți două depozite, unul pe Linux/Mac (ext3/hfs+) și altul pe sistemul de fișiere bazat pe FAT32/NTFS.

   După cum observați, există două tipuri diferite de sisteme de fișiere, așa că cel care nu acceptă permisiunile Unix, practic, nu poate reseta permisiunile de fișiere pe sistemul care nu acceptă acest tip de permisiuni, deci indiferent cât de --hard încercați, git detectează întotdeauna unele „modificări”.

Am avut aceeasi problema. Nimeni nu mi-a dat această soluție, dar mi-a funcționat.

Am rezolvat-o prin:

1. Ștergeți toate fișierele. Lăsați doar directorul .git.
2. git reset --hard HEAD
3. git pull
4. git push

Acum functioneaza.

Primă:

Vorbind despre pull/fetch/merge în răspunsurile anterioare, aș dori să împărtășesc un truc interesant și productiv,

git pull --rebase

Această comandă de mai sus este cea mai utilă comandă din viața mea Git, care a economisit mult timp.

Înainte de a împinge noul dvs. commit pe server, încercați această comandă și va sincroniza automat cele mai recente modificări ale serverului (cu un fetch + merge) și vă va plasa commit-ul în partea de sus în jurnalul Git. Nu este nevoie să vă faceți griji cu privire la extragerea/imbinarea manuală.

Găsiți detalii în Ce face git pull --rebase?.

Am avut o problemă similară. A trebuit sa fac asta:

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

Am rezumat alte răspunsuri. Puteți executa git pull fără erori:

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

Avertisment: acest script este foarte puternic, așa că ați putea pierde modificările.

Pe baza propriilor mele experiențe similare, soluția oferită de Strahinja Kustudic mai sus este de departe cea mai bună. După cum au subliniat alții, simpla resetare hard va elimina toate fișierele neurmărite care ar putea include o mulțime de lucruri pe care nu doriți să le eliminați, cum ar fi fișierele de configurare. Ceea ce este mai sigur, este să eliminați numai fișierele care urmează să fie adăugate și, de altfel, probabil că ați dori, de asemenea, să verificați orice fișiere modificate local care urmează să fie actualizate.

În minte, am actualizat scriptul lui Kustudic pentru a face exact asta. Am remediat și o greșeală de tipar (lipsește un " în original).

#/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

Cred că există două posibile cauze de conflict, care trebuie rezolvate separat și, din câte îmi pot da seama, niciunul dintre răspunsurile de mai sus nu se referă la ambele:

• Fișierele locale care nu sunt urmărite trebuie șterse, fie manual (mai sigur), fie așa cum se sugerează în alte răspunsuri, de git clean -f -d

• Comiterile locale care nu sunt pe ramura la distanță trebuie, de asemenea, șterse. IMO, cea mai ușoară modalitate de a realiza acest lucru este cu: git reset --hard origin/master (înlocuiți „master” cu orice ramură la care lucrați și rulați mai întâi un git fetch origin)

Se pare că majoritatea răspunsurilor de aici sunt concentrate pe ramura master; cu toate acestea, există momente în care lucrez la aceeași ramură a caracteristicilor în două locuri diferite și vreau ca o rebază într-unul să se reflecte în celălalt, fără să sară mult prin cercuri.

Bazat pe o combinație de răspunsul ARN și răspunsul lui Torek la o întrebare similară, am venit cu asta care funcționează splendid:

git fetch
git reset --hard @{u}

Rulați acest lucru dintr-o sucursală și vă va reseta doar filiala locală la versiunea din amonte.

Acest lucru poate fi bine pus și într-un alias git (git forcepull):

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

Sau, în fișierul dvs. .gitconfig:

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

Bucurați-vă!

Am avut aceeași problemă și din anumite motive, chiar și un git clean -f -d nu ar face-o. Iată de ce: Din anumite motive, dacă fișierul dvs. este ignorat de Git (prin o intrare .gitignore, presupun), încă se deranjează să-l suprascrie cu o pull ulterioară, dar o curățare nu îl va elimina, decât dacă adăugați -x.

O modalitate mai ușoară ar fi:

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

Acest lucru va suprascrie fișierul local cu fișierul de pe git

Știu o metodă mult mai ușoară și mai puțin dureroasă:

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

Asta este!

Tocmai am rezolvat asta prin:

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

unde ultima comandă oferă o listă cu modificările locale. Continuați să modificați ramura „tmp” până când este acceptabilă și apoi fuzionați înapoi în master cu:

git checkout master && git merge tmp

Pentru data viitoare, probabil că puteți gestiona asta într-un mod mai curat, căutând „git stash branch”, deși stash este probabil să vă provoace probleme la primele încercări, așa că faceți mai întâi un experiment pe un proiect necritic...

Am o situație ciudată în care nici git clean sau git reset nu funcționează. Trebuie să elimin fișierul aflat în conflict din git index utilizând următorul script pe fiecare fișier neurmărit:

git rm [file]

Atunci reușesc să trag bine.

Utilizare:

git fetch --all

Apoi, dacă vă aflați în ramura master,

git reset --hard origin/master

altfel

git reset --hard origin/master<branch_name>

Doar fa-o

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

Astfel, evitați toate efectele secundare nedorite, cum ar fi ștergerea fișierelor sau directoarelor pe care doriți să le păstrați etc.

În ciuda întrebării inițiale, răspunsurile de top pot cauza probleme persoanelor care au o problemă similară, dar nu doresc să-și piardă fișierele locale. De exemplu, vezi comentariile lui Al-Punk și crizCraig.

Următoarea versiune comite modificările dvs. locale într-o ramură temporară (tmp), verifică ramura originală (care presupun că este master) și îmbină actualizările. Ai putea face acest lucru cu stash, dar am descoperit că de obicei este mai ușor să folosești pur și simplu abordarea de ramificare / îmbinare.

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

unde presupunem că celălalt depozit este origin master.

Resetați indexul și capul la origin/master, dar nu resetați arborele de lucru:

git reset origin/master

Aceste patru comenzi funcționează pentru mine.

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

Pentru a verifica/trage după executarea acestor comenzi

git pull origin master

Am încercat multe, dar în cele din urmă am avut succes cu aceste comenzi.

Cerințe:

1. Urmăriți modificările locale, astfel încât nimeni de aici să nu le piardă vreodată.
2. Faceți ca depozitul local să se potrivească cu depozitul de origine la distanță.

Soluţie:

1. Ascundeți modificările locale.

2. Preluare cu o curățare de fișiere și directoare ignorând .gitignore și hard reset la origine.

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

Am citit toate răspunsurile, dar am căutat o singură comandă pentru a face acest lucru. Iată ce am făcut. S-a adăugat un alias git la .gitconfig

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

Rulați comanda ca

git fp origin master

echivalentă cu

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

Acest lucru a funcționat pentru mine foarte bine!

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

Aceasta este cea mai bună practică pentru anularea modificărilor:

• git commit Acordați modificările în etape, astfel încât acestea să fie salvate în reflog (vezi mai jos)
• git fetch Preluați cele mai recente modificări în amonte
• git reset --hard origin/master Resetare completă la ramura principală de origine

reflog înregistrează ramurile și alte referințe actualizate în depozitul local. Sau, pur și simplu, reflogul este istoria modificărilor dvs..

Deci este întotdeauna o practică grozavă să te angajezi. Commit-urile sunt atașate la reflog, ceea ce vă asigură că veți avea întotdeauna o modalitate de a prelua codul șters.

Nu folosiți git reset --hard. Acest lucru le va șterge modificările care pot fi complet nedorite. In schimb:

git pull
git reset origin/master
git checkout <file1> <file2> ...

Desigur, puteți folosi git fetch în loc de git pull, deoarece în mod clar nu se va îmbina, dar dacă de obicei trageți, este logic să continuați să trageți aici.

Deci, ceea ce se întâmplă aici este că git pull îți actualizează originea/referința principală; git reset îți actualizează referința la sucursala locală pentru a fi identică cu originea/masterul, fără a actualiza niciun fișier, astfel încât starea ta de check-out rămâne neschimbată; apoi git checkout reduce fișierele la starea indexului de sucursală locală după cum este necesar. În cazurile în care exact același fișier a fost adăugat pe live și pe master upstream, indexul se potrivește deja cu fișierul după resetare, așa că în cazul obișnuit nu trebuie să faceți deloc git checkout.

Dacă ramura din amonte conține și comite-uri pe care doriți să le aplicați automat, puteți urma o variație subtilă a procesului:

git pull
git merge <commit before problem commit>
git reset <problem commit>
git checkout <file1> <file2> ...
git pull

Poti incerca:

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

Am folosit această comandă pentru a scăpa de fișierele locale care mă împiedică să fac un pull/merge. Dar fii atent! Mai întâi rulați git merge … pentru a vedea dacă există doar acele fișiere pe care doriți cu adevărat să le eliminați.

git merge origin/master 2>&1 >/dev/null | grep ^[[:space:]] | sed s/^[[:space:]]//g | xargs -L1 rm

• git merge listează printre altele toate acele fișiere. Ele sunt predate de un spațiu alb.
• 2>&1 >/dev/null redirecționează ieșirea de eroare la cea standard, astfel încât să fie preluată de grep.
• grep ^[[:space:]] filtrează numai liniile cu nume de fișiere.
• sed s/^[[:space:]]//g decupează spațiul alb de la început.
• xargs -L1 rm apelează rm pe fiecare dintre acele fișiere, ștergându-le.

Manipulați cu grijă: indiferent de ieșirile git merge, rm va fi apelat pentru fiecare linie care începe cu un spațiu alb.

Încercam să folosesc ramura Material2 pe Angular2-Webpack-Starter și am avut o distracție. Acesta era singurul mod în care puteam descărca și folosi acea ramură.

git clone --depth 1 https://github.com/angularclass/angular2-webpack-starter.git

cd angular2-webpack-starter/

git checkout -b material2

Deschideți folderul proiectului și ștergeți toate fișierele și folderele care nu sunt ascunse. Lasă toate cele ascunse.

git add .

git commit -m "pokemon go"

git reset --hard

git pull origin material2

(Când apare editorul, apăsați „:wq”, apoi apăsați pe Enter)

Acum ești gata.

Dacă doriți să resetați la ramura de urmărire la distanță într-un mod generic, utilizați:

git fetch
git reset --keep origin/$(git rev-parse --abbrev-ref HEAD)

Dacă doriți să resetați și modificările locale:

git fetch
git reset --hard origin/$(git rev-parse --abbrev-ref HEAD)

Pe Windows, faceți această singură comandă:

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

Puteți ignora acel fișier cu un fișier din folderul de bază al proiectului:

.gitignore

public/images/*

Apoi trageți modificările și apoi eliminați acea linie din fișierul dvs. gitignore.

1: Resetați la o comitere anterioară

git reset --hard HEAD

2: Ștergeți fișierele neurmărite

git clean -f

3: Trageți commit-urile

git pull

Surse:

• https://git-scm.com/docs/git-reset
• https://git-scm.com/docs/git-clean/

În ciuda faptului că această întrebare are deja multe răspunsuri, întrebarea inițială este de a rezolva această întrebare

eroare: fișierul arbore de lucru neurmărit „public/images/icon.gif” ar fi suprascris prin îmbinare

Deoarece fișierele binare nu pot fi îmbinate, un răspuns simplu este

git checkout public/images/icon.gif

Cu asta, fișierul va recupera starea anterioară pe care o avea în această ramură.

De obicei fac git stash dacă nu vreau să-mi pierd modificările sau ceva de genul git checkout . dacă nu-mi pasă de fișierele modificate local. IMO mult mai simplu decât reset --hard, clean... și toate aceste lucruri mai potrivite pentru a părăsi ramura ca la distanță, inclusiv comiteri, fișiere neurmărite, mai degrabă decât rezolvarea unui fișier modificat local.

Odată ce faceți git pull, veți obține o listă de fișiere care nu se potrivesc. Dacă numărul de fișiere nu este foarte mare, atunci puteți verifica acele fișiere, această acțiune le va suprascrie.

git checkout -- ‹nume fișier›

De obicei o fac dacă, pentru verificare rapidă, modific fișierele locale de pe server (niciun motiv recomandat și probabil în spatele acestei probleme :D), verific fișierele modificate după ce găsesc soluția.

Am făcut asta ca să funcționeze:

Pe computerul unde am creat noua ramură:

git push --all

Pe computerul pe care am vrut să arate noua ramură:

git fetch --all

Pasul 1. (opțional)
Din rădăcina depozitului local, salvați o copie de rezervă și golește folderul curent:

mkdir -p ../<branch>-bkp && mv --backup=t * ../<branch>-bkp

Pasul 2. Descărcați toate fișierele și folderele ramurii din depozitul de la distanță:

git checkout <branch> && git add -A . && git reset --hard origin/<branch> && git pull

unde ar trebui să înlocuiți <branch> cu numele ramurii pe care doriți să o suprascrieți.

Comentarii:

• Poate preferați să faceți backup manual și să eliminați fișierele și folderele curente în loc de pasul 1.
  De fapt, vă recomand > făcând acest lucru cu un handler de fișiere în interfața grafică a sistemului dvs. de operare.
• Dacă omiteți pasul 1, aveți grijă: veți pierde toată munca din depozitul local!
• Important: dacă omiteți git pull în pasul 2,
  riști să nu obții cea mai recentă versiune de la depozitul de la distanță!
  Conform celei de-a doua referințe de mai jos, git reset --hard va
  reseta zona de pregătire și directorul de lucru pentru a se potrivi cu cea mai recentă comitere .
  Experiența mea contrazice această afirmație!
• Dacă rulați git reset --hard origin/<branch_to_overwrite> fără să ștergeți mai întâi toate fișierele și folderele din depozitul local, aveți grijă că orice fișiere nedorite care se află încă prin preajmă se pot strecura în depozitul de la distanță la un git push ulterior, chiar dacă aceasta nu a fost intenția dvs.
  git add -A . suplimentar din pasul 2 previne acest lucru dacă alegeți să omiteți pasul 1.

Referințe:
https://gitforwindows.org/
https://www.atlassian.com/git/tutorials/undoing-changes/git-reset
https://www.atlassian.com/git/tutorials/rewriting-history/git-reflog

Deoarece am adesea nevoie de o modalitate rapidă de a reseta ramura curentă pe Windows prin promptul de comandă, iată o modalitate rapidă:

for /f "tokens=1* delims= " %a in ('git branch^|findstr /b "*"') do @git reset --hard origin/%b

Am încercat majoritatea a ceea ce am putut găsi aici, niciunul nu a funcționat în cazul meu.

Ceea ce a funcționat a fost git merge -X theirs

Ați putea încerca git pull --force sau poate să vă ascundeți comitările folosind git stash și apoi rulând git pull.

Cred că poți forța și prin git push -f / git push --force