stash - visual studio git force pull




Come impongo "git pull" per sovrascrivere i file locali? (20)

Importante: se si verificano modifiche locali, queste verranno perse. Con o senza opzione --hard , qualsiasi commit locale che non è stato premuto verrà perso. [*]

Se si dispone di file non tracciati da Git (ad es. Contenuto utente caricato), questi file non saranno interessati.

Penso che questo sia il modo giusto:

git fetch --all

Quindi, hai due opzioni:

git reset --hard origin/master

OPPURE Se ti trovi in ​​qualche altro ramo:

git reset --hard origin/<branch_name>

Spiegazione:

git fetch scarica le ultime dal remoto senza tentare di unire o rebase nulla.

Quindi il git reset reimposta il ramo master su ciò che hai appena recuperato. L'opzione --hard cambia tutti i file nell'albero di lavoro in modo che corrispondano ai file in origin/master

Mantieni i commit locali correnti

[*] : Vale la pena notare che è possibile mantenere i commit locali correnti creando un branch dal master prima di resettare:

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

Dopodiché, tutti i vecchi commit saranno mantenuti in commit da new-branch-to-save-current-commits .

Modifiche non commesse

Le modifiche non applicate, tuttavia (anche messe in scena), andranno perse. Assicurati di mettere da parte e salvare tutto ciò di cui hai bisogno. Per questo è possibile eseguire quanto segue:

git stash

E poi riapplicare queste modifiche senza commit:

git stash pop

Come posso forzare una sovrascrittura di file locali su un git pull ?

Lo scenario sta seguendo:

  • Un membro del team sta modificando i modelli per un sito web su cui stiamo lavorando
  • Aggiungono alcune immagini alla directory delle immagini (ma dimentica di aggiungerle sotto il controllo del codice sorgente)
  • Stanno inviando le immagini per posta, più tardi, a me
  • Sto aggiungendo le immagini sotto il controllo del codice sorgente e inserendole in GitHub insieme ad altre modifiche
  • Non possono estrarre gli aggiornamenti da GitHub perché Git non vuole sovrascrivere i loro file.

Questo è l'errore che sto ottenendo:

error: Untracked working tree file 'public/images/icon.gif' would be overwritten by merge

Come faccio a forzare Git a sovrascriverli? La persona è un designer - di solito risolvo tutti i conflitti a mano, quindi il server ha la versione più recente che devono solo aggiornare sul proprio computer.


Bonus:

Parlando di pull / fetch / merge nelle risposte precedenti, mi piacerebbe condividere un trucco interessante e produttivo,

git pull --rebase

Questo comando sopra è il comando più utile nella mia vita Git che ha risparmiato un sacco di tempo.

Prima di spingere il tuo nuovo commit al server, prova questo comando e sincronizzerà automaticamente le ultime modifiche del server (con un fetch + unisci) e posizionerà il tuo commit nella parte superiore del log Git. Non c'è alcun bisogno di preoccuparsi di pull / fusione manuale.

Trova i dettagli in Cosa fa "git pull --rebase"? .


Come Riccio penso che le risposte siano terribili. Ma anche se la risposta di Hedgehog potrebbe essere migliore, non penso che sia così elegante come potrebbe essere. Il modo in cui ho trovato di farlo è utilizzando "fetch" e "merge" con una strategia definita. Il che dovrebbe fare in modo che le modifiche locali vengano mantenute purché non siano uno dei file con cui si tenta di forzare una sovrascrittura.

Prima fai un commit delle tue modifiche

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

Quindi recuperare le modifiche e sovrascrivere se c'è un conflitto

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

"-X" è un nome di opzione e "loro" è il valore per tale opzione. Stai scegliendo di utilizzare le "loro" modifiche, invece delle "tue" modifiche se c'è un conflitto.


Conosco un metodo molto più semplice e meno doloroso:

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

Questo è tutto!


Ho avuto lo stesso problema e per qualche ragione, anche un git clean -f -d non lo farebbe. Ecco perché: per qualche ragione, se il tuo file viene ignorato da Git (tramite una voce .gitignore, presumo), si preoccupa ancora di sovrascriverlo con un pull successivo, ma un clean non lo rimuoverà, a meno che tu aggiunga -x .


Ho avuto lo stesso problema. Nessuno mi ha dato questa soluzione, ma ha funzionato per me.

L'ho risolto da:

  1. Cancellare tutti i file. Lascia solo la directory .git.
  2. git reset --hard HEAD
  3. git pull
  4. git push

Ora funziona.


Ho letto tutte le risposte ma stavo cercando un singolo comando per farlo. Ecco cosa ho fatto. Aggiunto un alias git a .gitconfig

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

Esegui il tuo comando come

git fp origin master

equivalente a

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

Ho riassunto altre risposte. Puoi eseguire git pull senza errori:

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

Attenzione : questo script è molto potente, quindi potresti perdere le tue modifiche.


Il problema con tutte queste soluzioni è che sono tutte o troppo complesse, o, un problema ancora più grande, è che rimuovono tutti i file non tracciati dal server web, cosa che non vogliamo visto che ci sono sempre file di configurazione necessari che sono attivi il server e non nel repository Git.

Ecco la soluzione più pulita che stiamo usando:

# 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
  • Il primo comando recupera i dati più recenti.

  • Il secondo comando controlla se ci sono file che vengono aggiunti al repository ed elimina quei file non tracciati dal repository locale che causerebbero conflitti.

  • Il terzo comando controlla tutti i file che sono stati modificati localmente.

  • Infine eseguiamo un pull per aggiornare la versione più recente, ma questa volta senza conflitti, poiché i file non tracciati che sono nel repository non esistono più e tutti i file modificati localmente sono già gli stessi del repository.


Invece di fare:

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

Consiglierei di fare quanto segue:

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

Non è necessario recuperare tutti i telecomandi e le derivazioni se si intende ripristinare la diramazione origine / master correttamente?


L'ho appena risolto da solo:

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

dove l'ultimo comando fornisce un elenco delle modifiche locali. Continua a modificare il ramo "tmp" finché non è accettabile e quindi unisci di nuovo a master con:

git checkout master && git merge tmp

Per la prossima volta, probabilmente puoi gestirlo in un modo più pulito cercando "git stash branch", anche se lo stash rischia di causare problemi nei primi tentativi, quindi fai il primo esperimento su un progetto non critico ...


L'unica cosa che ha funzionato per me è stata:

git reset --hard HEAD~5

Questo ti riporterà cinque commit e poi con

git pull

L'ho trovato cercando come annullare una fusione Git .


Potresti trovare utile questo comando per eliminare le modifiche locali:

git checkout <your-branch> -f

E poi fai una pulizia (rimuove i file non tracciati dall'albero di lavoro):

git clean -f

Se si desidera rimuovere le directory non tracciate oltre ai file non tracciati:

git clean -fd

Prima di tutto, prova il modo standard:

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

Se sopra non ti sarà d'aiuto e non ti preoccuperai dei tuoi file / directory non tracciati (fai il backup prima solo nel caso), prova i seguenti semplici passaggi:

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

Questo rimuoverà tutti i file git (es. .Git .git/ dir, dove hai tutti i commit) e lo tiri di nuovo.

Perché git reset HEAD --hard potrebbe fallire in alcuni casi?

  1. Regole personalizzate nel .gitattributes file

    Avere eol=lf regola in .gitattributes potrebbe far sì che git modifichi alcune modifiche ai file convertendo le terminazioni di riga CRLF in LF in alcuni file di testo.

    In questo caso, devi impegnare queste modifiche CRLF / LF (esaminandole in git status ), oppure provare: git config core.autcrlf false in modo temporaneo ignorarle.

  2. Incapacità del file system

    Quando si utilizza il file system che non supporta gli attributi di autorizzazione. Nell'esempio si hanno due repository, uno su Linux / Mac ( ext3 / hfs+ ) e un altro su file system basato su FAT32 / NTFS.

    Come noti, ci sono due diversi tipi di file system, quindi quello che non supporta i permessi Unix fondamentalmente non può resettare i permessi dei file sul sistema che non supporta quel tipo di permessi, quindi non importa quanto --hard tu prova, git rileva sempre alcuni "cambiamenti".


Questi quattro comandi funzionano per me.

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

Per controllare / tirare dopo aver eseguito questi comandi

git pull origin master

Ho provato molto ma alla fine ho avuto successo con questi comandi.


Requisiti:

  1. Tieni traccia dei cambiamenti locali così nessuno li perde mai.
  2. Rendere il repository locale corrispondente al repository di origine remoto.

Soluzione:

  1. Conserva le modifiche locali.
  2. Scarica con una pulizia di file e directory ignorando .gitignore e hard reset all'origine .

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

Sembra che il modo migliore sia fare prima:

git clean

Per eliminare tutti i file non tracciati e quindi continuare con il solito git pull ...


Sembra che la maggior parte delle risposte qui siano focalizzate sul ramo master ; tuttavia, ci sono momenti in cui sto lavorando sullo stesso ramo di funzionalità in due luoghi diversi e voglio che un rebase in uno si rifletta nell'altro senza un sacco di salti mortali.

Basato su una combinazione di risposta di RNA e risposta di torek a una domanda simile , ho trovato questo che funziona splendidamente:

git fetch
git reset --hard @{u}

Esegui questo da un ramo e reimposterà solo il tuo ramo locale alla versione upstream.

Questo può anche essere inserito in un alias git forcepull ( git forcepull ):

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

Oppure, nel tuo file .gitconfig :

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

Godere!


Un modo più semplice sarebbe:

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

Questo sovrascriverà il tuo file locale con il file su git


Attenzione, facendo questo eliminerai definitivamente i tuoi file se hai qualche directory / * nel tuo file gitignore.

Alcune risposte sembrano essere terribili. Terribile nel senso di ciò che è successo a @Lauri seguendo il suggerimento di David Avsajanishvili.

Piuttosto (git> v1.7.6):

git stash --include-untracked
git pull

Più tardi puoi pulire la cronologia di scorta.

Manualmente, uno per uno:

$ git stash list
[email protected]{0}: WIP on <branch>: ...
[email protected]{1}: WIP on <branch>: ...

$ git stash drop [email protected]{0}
$ git stash drop [email protected]{1}

Brutalmente, tutto in una volta:

$ git stash clear

Certo, se vuoi tornare a ciò che hai nascosto:

$ git stash list
...
$ git stash apply [email protected]{5}




git-fetch