Come sostituire la filiale locale con la filiale remota interamente in Git?

Ho due rami:

1. filiale locale (quella con cui lavoro)
2. filiale remota (pubblica, solo commit ben testati vanno lì)

Di recente ho seriamente incasinato la mia filiale locale.

Come sostituirei completamente la filiale locale con quella remota, in modo da poter continuare il mio lavoro da dove si trova ora la filiale remota?

Ho già cercato SO e il check-out sul ramo remoto localmente non ha alcun effetto.

1. Assicurati di aver verificato il ramo che stai sostituendo (dal commento di Zoltán ).

2. Supponendo che il master sia il ramo locale che stai sostituendo e che "origin / master" sia il ramo remoto su cui vuoi reimpostare:

   git reset --hard origin/master
   

Questo aggiorna il tuo ramo HEAD locale in modo che sia la stessa revisione di origin / master e --hardsincronizzerà questa modifica anche nell'indice e nell'area di lavoro.

È facile come tre passaggi:

1. Elimina la tua filiale locale: git branch -d local_branch
2. Scarica l'ultimo ramo remoto: git fetch origin remote_branch
3. Ricostruire il ramo locale basato su quello remoto: git checkout -b local_branch origin/remote_branch

git branch -D <branch-name>
git fetch <remote> <branch-name>
git checkout -b <branch-name> --track <remote>/<branch-name>

Sostituisci tutto con il ramo remoto; ma solo dallo stesso commit è attiva la tua filiale locale:

git reset --hard origin/some-branch

OPPURE , ottieni le ultime novità dalla filiale remota e sostituisci tutto:

git fetch origin some-branch
git reset --hard FETCH_HEAD

A parte, se necessario, puoi cancellare file e directory non tracciati che non hai ancora eseguito il commit:

git clean -fd

Il modo più sicuro e completo per sostituire l'attuale filiale locale con il telecomando:

git stash
git merge --abort
git rebase --abort
git branch -M yourBranch replaced_yourBranch
git fetch origin yourBranch:yourBranch
git checkout yourBranch

La stashriga salva le modifiche che non hai eseguito il commit. La branchlinea sposta il tuo ramo su un nome diverso, liberando il nome originale. La fetchriga recupera l'ultima copia del telecomando. La checkoutlinea ricrea il ramo originale come ramo di tracciamento.

O come una funzione bash:

replaceWithRemote() {
    yourBranch=${1:-`git rev-parse --abbrev-ref HEAD`}
    git stash
    git merge --abort
    git rebase --abort
    git branch -M ${yourBranch} replaced_${yourBranch}_`git rev-parse --short HEAD`
    git fetch origin ${yourBranch}:${yourBranch}
    git checkout ${yourBranch}
}

che rinomina il ramo corrente in qualcosa come sostituito_master_98d258f.

Sono un po 'sorpreso che nessuno lo abbia ancora menzionato; Lo uso quasi ogni giorno:

git reset --hard @{u}

Fondamentalmente, @{u}è solo una scorciatoia per il ramo a monte che il tuo ramo attuale sta seguendo. Ad esempio, questo equivale in genere a origin/[my-current-branch-name]. È bello perché è indipendente dal ramo.

Assicurarsi git fetchinnanzitutto di ottenere l'ultima copia del ramo remoto.

Può essere fatto in diversi modi, continuando a modificare questa risposta per diffondere una migliore prospettiva di conoscenza.

1) Ripristina difficile

Se stai lavorando dal ramo di sviluppo remoto, puoi ripristinare HEAD all'ultimo commit sul ramo remoto come di seguito:

git reset --hard origin/develop

2) Elimina il ramo corrente ed esegui nuovamente il checkout dal repository remoto

Considerando che stai lavorando allo sviluppo del ramo nel repository locale, che si sincronizza con il ramo remoto / sviluppo, puoi fare come di seguito:

git branch -D develop
git checkout -b develop origin/develop

3) Annulla unione

Se sei nel mezzo di una cattiva unione (erroneamente eseguita con un ramo sbagliato) e volevi evitare l'unione per tornare al ramo più recente come di seguito:

git merge --abort

4) Annulla rebase

Se si è in mezzo a un rebase errato, è possibile interrompere la richiesta di rebase come di seguito:

git rebase --abort

Puoi fare come ha detto @Hugo di @Laurent, oppure puoi usare git rebaseper eliminare i commit che vuoi eliminare, se sai quali. Tendo a usare git rebase -i head~N(dove N è un numero, permettendoti di manipolare gli ultimi N commit) per questo tipo di operazioni.

La risposta selezionata è assolutamente corretta , tuttavia non mi ha lasciato con gli ultimi commit / push ...

Quindi per me:

git reset --hard dev/jobmanager-tools
git pull  ( did not work as git was not sure what branch i wanted)

Dal momento che so che voglio impostare temporaneamente il mio ramo upstream per alcune settimane su un ramo specifico (lo stesso di quello in cui sono passato / verificato in precedenza e ho effettuato un hard reset)

Quindi dopo il reset

git branch --set-upstream-to=origin/dev/jobmanager-tools
git pull
git status    ( says--> on branch  dev/jobmanager-tools 

Se vuoi aggiornare un ramo che non è attualmente estratto puoi fare:

git fetch -f origin rbranch:lbranch

Come indicato nella spiegazione scelta, git reset è buono. Ma oggigiorno utilizziamo spesso sottomoduli: repository all'interno di repository. Ad esempio, se usi ZF3 e jQuery nel tuo progetto, molto probabilmente vorrai che vengano clonati dai loro repository originali. In tal caso, git reset non è sufficiente. Dobbiamo aggiornare i sottomoduli con quella versione esatta definita nel nostro repository:

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

git submodule foreach git submodule update

git status

è lo stesso che verrai ricorsivamente (cd) nella directory di lavoro di ciascun sottomodulo e verrà eseguito:

git submodule update

Ed è molto diverso da

git checkout master
git pull

perché i sottomoduli puntano non al ramo ma al commit.

In quei casi, quando si esegue il checkout manuale di un ramo per 1 o più sottomoduli, è possibile eseguire

git submodule foreach git pull

git reset --hard
git clean -fd

Questo ha funzionato per me - clean ha mostrato anche tutti i file che ha eliminato. Se ti dice che perderai le modifiche, devi riporlo.

Il modo brutto ma più semplice: elimina la cartella locale e clona nuovamente il repository remoto.