Come faccio a ignorare un errore su 'git pull' sulle mie modifiche locali verrebbe sovrascritto dall'unione?


569

Come faccio a ignorare il seguente messaggio di errore su Git pull?

Le modifiche locali ai seguenti file verrebbero sovrascritte dall'unione

E se volessi sovrascriverli?

Ho provato cose del genere git pull -f, ma nulla funziona.

Per essere chiari, voglio solo sovrascrivere cambiamenti specifici, non tutto.



7
@BrianKnoblauch sono totalmente d'accordo! Inoltre, non è molto "unione" se è "sovrascrittura", vero? Mi manca SVN ogni giorno ...
user1944491

2
git config core.fileMode falsesalva i miei tempi
Nolwennig,


E se non volessi sovrascriverli?
Philip Rego,

Risposte:


439

Se vuoi rimuovere tutte le modifiche locali, inclusi i file non tracciati da git, dalla tua copia di lavoro, semplicemente nascondili:

git stash push --include-untracked

Se non ti servono più, ora puoi eliminare quella scorta:

git stash drop

Se non desideri nascondere le modifiche che hai già messo in scena, ad esempio con git add, aggiungi l'opzione --keep-index. Si noti tuttavia che ciò impedirà comunque l'unione se tali modifiche organizzate si scontrano con quelle dell'upstream.


Se si desidera sovrascrivere solo parti specifiche delle modifiche locali, ci sono due possibilità:

  1. Commetti tutto ciò che non vuoi sovrascrivere e usa il metodo sopra per il resto.

  2. Utilizzare git checkout path/to/file/to/revertper le modifiche che si desidera sovrascrivere. Assicurarsi che il file non sia messo in scena tramite git reset HEAD path/to/file/to/revert.


La possibilità n. 2 non funziona. Dopo aver eseguito il comando non succede nulla. Al pull ottengo ancora lo stesso errore.
Mae,

1
@ user1132363: funziona per me. Provalo prima con un singolo file. Inoltre, devi assicurarti che il file che vuoi sovrascrivere non sia messo in scena.
Daniel Hilgarth,

3
Il trucco era usare git checkout HEAD^ path/to/file/to/revert. L'uso di HEAD ^ ha fatto la differenza.
Mae,

2
@ user1132363: che verifica la versione precedente e non quella attualmente archiviata. Non credo che questo sia l'approccio corretto.
Daniel Hilgarth,

1
Ho dovuto lasciare fuori " save --keep-index".
Peter Mortensen,

318

Bene con l'aiuto delle altre due risposte ho trovato una soluzione diretta:

git checkout HEAD^ file/to/overwrite
git pull

7
Questo ha funzionato per me. Potresti espandere questa risposta, ad es. che cosa sta realmente facendo?
AC Patrice,

3
Sta abbandonando le modifiche locali, ripristinando il riferimento HEAD che è probabilmente l'ultimo commit nel ramo master
k3a

32
perché HEAD ^ invece di HEAD?
Yura,

19
HEAD ^ è l'abbreviazione di HEAD ^ 1, che significa essenzialmente il commit prima di HEAD. Puoi anche eseguire HEAD ^ 2 per il commit prima di quello. Per ulteriori informazioni vedere git-scm.com/book/en/v2/... e stackoverflow.com/questions/1955985/... .
davidneedham,

4
per favore, spiega cosa fa questo nella risposta
endolito del

242

Questo funziona per me per sovrascrivere tutte le modifiche locali e non richiede un'identità:

git reset --hard
git pull

4
SO ha bisogno di lavorare sul proprio algoritmo di classifica, ingombrante per trovare una risposta funzionante e molto apprezzata finora.
Benedict K.

3
@BenedictK. Credo che il sistema di classificazione rifletta adeguatamente "ciò che la maggior parte delle persone trova più utile". Sono classificati in base ai voti. Più persone preferiscono le altre soluzioni. Questa è una buona soluzione, ma più persone trovano più utili le altre risposte .
Kittsil,

Funziona bene per me
Ender,

super easy =) thx ^^
lestat_kim

carri armati, funziona bene per me
Igor il

76

Ecco una soluzione che elimina i cambiamenti graduali:

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

11
Stranamente, se la differenza percepita deriva dal fatto che il file ha avuto le sue nuove righe cambiate quando è stato estratto, questo non risolverà il problema.
DanielSank,

1
Risolto il mio problema
Loïc N.

questa è la risposta migliore, imo, perché non interrompe alcun elemento in scena, ma risolve il problema del file impedendo il pull
theRiley

65

Puoi eseguire il commit delle modifiche prima di eseguire l'unione oppure metterle da parte:

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

10
Il punto è che non dovresti farlo. Basta prendere il materiale HEAD corrente e ..... unirlo! È davvero semplice, Git, tutti gli altri VCS lo fanno ... ma no. Linus doveva renderlo fastidioso da usare.
Jon

@Jon Questa soluzione è per Ubuntu, non ho trovato niente di meglio di questo.
Suneel Kumar,

Purtroppo l' --autostashopzione è disponibile solo con l' --rebaseopzione (
Eugen Konkov,

questo introdurrà così tanti problemi che non ne vale la pena. Richiede almeno 5 minuti per caricare anche. Presenta anche errori "Unlink of file". downvote
Philip Rego,

51

Se si desidera annullare le modifiche locali su un file, è possibile effettuare le seguenti operazioni:

git checkout -- <file>

Quindi potresti sovrascrivere il file [s] con l'ultima versione semplicemente facendo:

git pull

@pabloasc Questo distrugge le tue modifiche locali in quel file.
Suneel Kumar,

6
Sì, lo fa: "E se volessi sovrascriverli?"
David,

1
La domanda originale non è in grado di farlo, questa risposta può dare a qualcuno un incubo che può copiare alla cieca incollare il comando.
Suneel Kumar,

Se hai già messo in scena un commit, devi prima ripristinare il commit tramite git reset HEAD~e quindi eseguiregit checkout
dopexxx

git checkout -- <file>fallisce conerror: pathspec '<file>' did not match any file(s) known to git.
A__

18

Se il tuo repository contiene alcuni file che vengono rimossi da master:

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

12

A volte, nessuno di questi funziona. Stranamente, a causa della cosa LF, penso, ciò che funzionerà è eliminare i file, quindi tirare. Non che io raccomandi questa soluzione, ma se il file non esiste, git non ti informerà inutilmente che le tue modifiche (che potrebbero anche non essere modifiche) verranno sovrascritte e ti consentiranno di continuare.

Utilizzare a proprio rischio.


Quando sei bloccato a causa della fine della linea, questo metodo ti salva la vita
Dan Pisarski,

Questo non funziona per me. I file non esistono localmente e sto ancora ricevendo l'errore.
PRMan

11

git stash save --keep-index non ha funzionato per me.

sotto il comando ha funzionato come previsto.

git reset --hard
git pull

Sostituisce tutte le modifiche locali se non ne hai bisogno.


10

Così tante risposte qui che odio aggiungerne ancora un'altra, ma tutte le precedenti sono più clunkier di quanto debbano essere. Devo farlo tutto il tempo poiché Git sembra confondersi e dice che ho modificato i file che non sono cambiati (non possono tornare perché non sono cambiati, ma non posso tirare perché presumibilmente sono cambiati) Più semplice e il più veloce che ho trovato finora è:

git stash
git stash drop
git pull

ha funzionato come un fascino
Blaze

Sorprendente! soluzione semplice e funzionante.
naïveRSA

geniale, grazie mille
Hamza

8

Nel recente Git, è possibile aggiungere il comando -r/ --rebaseon pullper riordinare il ramo corrente sopra il ramo a monte dopo il recupero. L'avvertimento dovrebbe scomparire, ma c'è il rischio che tu abbia dei conflitti che dovrai risolvere.


In alternativa è possibile effettuare il checkout di diversi rami con forza, quindi tornare di masternuovo a, ad esempio:

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

Quindi tiralo di nuovo come al solito:

git pull origin master

L'uso di questo metodo può farti risparmiare tempo dallo stashing ( git stash) e potenziali problemi di autorizzazione, reimpostazione dei file ( git reset HEAD --hard), rimozione dei file ( git clean -fd), ecc. Anche quanto sopra è più facile da ricordare.


8

Questo problema è dovuto al fatto che sono state apportate modifiche localmente al / i file / i e lo stesso file / i esiste con modifiche nel repository Git, quindi prima di pull / push è necessario disporre di modifiche locali stash:

Per sovrascrivere le modifiche locali di un singolo file:

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

Per sovrascrivere tutte le modifiche locali (modifiche in tutti i file):

git stash
git pull
git stash pop

Inoltre, questo problema potrebbe essere dovuto al fatto che sei su un ramo che non è unito al ramo principale.


5

git reset --hard && git clean -df

Attenzione : questo ripristinerà e cancellerà tutti i file non tracciati.


27
Non si usa l'ascia per rimuovere la mosca dalla fronte dell'amico.
OnoratoMule

3
NON utilizzare questo senza la consapevolezza che alcuni file verranno eliminati.
andromeda,


4

Il modo migliore per risolvere questo problema è:

git checkout -- <path/file_name>

Successivamente è possibile sovrascrivere il file:

git pull origin master

Ho avuto il problema menzionato perché avevo aggiornato l'indice per presumere che i file fossero invariati. Non mi lasciava ancora fare il tiro. Ho usato git checkout -- path/*solo una volta e mi ha permesso di eseguire il pull dopo.
Stephen O'Flynn,

4

Questo ha funzionato per me scartare le modifiche sul server remoto attivo e estrarre dal controllo del codice sorgente GitHub:

git reset --hard
git pull origin master

4

Ecco la mia strategia per risolvere il problema.

Dichiarazione problema

Dobbiamo apportare modifiche in più di 10 file. Ci abbiamo provato PULL (git pull origin master), ma Git ha gridato:

errore: le modifiche locali ai seguenti file verrebbero sovrascritte dall'unione: Si prega di confermare le modifiche o di nasconderle prima di poterle unire.

Abbiamo provato a eseguire commite quindipull , ma non hanno funzionato neanche.

Soluzione

Eravamo sporchi realtà fase , perché i file erano nella "Area di gestione temporanea" alias "Area indice" e alcuni erano nella "Area principale" alias "directory Git locale". E volevamo estrarre le modifiche dal server.

Controlla questo link per informazioni sulle diverse fasi di Git in modo chiaro: GIT Stages

Abbiamo seguito i seguenti passaggi

  • git stash (Questo ha reso la nostra directory di lavoro pulita. Le tue modifiche sono archiviate nello stack da Git).
  • git pull origin master (Estrai le modifiche dal server)
  • git stash apply (Applicate tutte le modifiche dallo stack)
  • git commit -m 'message' (Commesso i cambiamenti)
  • git push origin master (Ha inviato le modifiche al server)
  • git stash drop (Rilascia la pila)

Capiamo quando e perché è necessario riporlo

Se sei nello stato sporco , significa che stai apportando modifiche ai tuoi file e quindi sei costretto, per qualsiasi motivo, a tirare o passare a un altro ramo per un lavoro molto urgente, quindi a questo punto non puoi tirare o passare fino a quando non si impegna la modifica. Il stashcomando è qui come una mano.

Dal libro ProGIT , 2nd Edition:

Spesso, quando hai lavorato su una parte del tuo progetto, le cose sono in uno stato disordinato e vuoi cambiare un po 'i rami per lavorare su qualcos'altro. Il problema è che non vuoi impegnarti a metà del lavoro solo per tornare più tardi a questo punto. La risposta a questo problema è il comando git stash. Lo stashing prende lo stato sporco della directory di lavoro, ovvero i file tracciati modificati e le modifiche graduali, e lo salva su una serie di modifiche non completate che è possibile riapplicare in qualsiasi momento.


3

Se si desidera sovrascrivere modifiche specifiche, è necessario un modo per dirle quali si desidera dimenticare.

Potresti provare a nascondere selettivamente le modifiche che desideri abbandonare utilizzando git stash --patche quindi a rilasciare quella scorta con git stash drop. È quindi possibile estrarre le modifiche remote e unirle normalmente.


3

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

Non so perché non abbia ancora ricevuto risposta, ma la soluzione, come puoi vedere, è semplice. Tutte le risposte qui suggeriscono lo stesso: per eliminare / salvare le modifiche locali e applicare a monte, quindi (se sisave ) applicare le modifiche locali in alto.

Cosa git pull --rebase --autostashfa passo dopo passo:

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

Il mio caso (probabilmente anche il tuo):

Ho delle modifiche locali (modifiche nella directory di lavoro):

inserisci qui la descrizione dell'immagine

Quando provo a estrarre le modifiche remote ricevo un errore:

inserisci qui la descrizione dell'immagine

Queste modifiche non si intersecano con le modifiche locali:

inserisci qui la descrizione dell'immagine

Quindi, quando ho pull --rebase --autostashmodifiche locali salvate e applicate senza alcun problema automaticamente

inserisci qui la descrizione dell'immagine

Ora le mie modifiche locali sono leggermente inferiori: inserisci qui la descrizione dell'immagine


2

Ho avuto un caso speciale di questo: avevo un file con --assume-invariato su di esso. È stato difficile da individuare, poiché il git statuscomando non mostrava alcun cambiamento


Ho questo stesso problema. Hai trovato il modo di aggirarlo? Suppongo di poter rimuovere e quindi aggiungere di nuovo presupposto invariato ... quello che ho fatto è stato semplicemente fare il checkout di quei file manualmente per ottenere versioni invariate ... mi chiedevo solo se c'è un modo per fare il checkout / rebase / merge solo sovrascrivere loro.
David,

1
No, ho dovuto abbandonare l'intera faccenda "ipotesi invariata".

2

Se si desidera mantenere le modifiche di produzione sul server, è sufficiente unire in un nuovo elemento di configurazione. Il metodo di elaborazione è il seguente:

git stash
git pull
git stash pop

Forse non esegui tutte le operazioni. Puoi sapere cosa puoi fare dopo.


È quindi possibile utilizzare Git diff - w + nome del file per confermare l'unione automatica del codice
YanQing

1

Stavo ignorando un file nel mio repository e quando l'ho fatto git pull upstream masterho ricevuto il seguente errore:

errore: le tue modifiche locali ai seguenti file verrebbero sovrascritte da merge: myfile.js Per favore, commetti le modifiche o nascondile prima di poterle unire. Interruzione

Per risolverlo ho fatto quanto segue

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

Poi l'ho fatto git statuse ho ricevuto questo messaggio

Su un master di filiale Il tuo branch è dietro 'origin / master' di 4 commit e può essere fatto avanzare rapidamente. (usa "git pull" per aggiornare la tua filiale locale)

Modifiche non messe in scena per il commit: (usa "git add ..." per aggiornare ciò che verrà eseguito il commit) (usa "git checkout - ..." per scartare le modifiche nella directory di lavoro)

modificato: myfile.js

nessuna modifica aggiunta al commit (usa "git add" e / o "git commit -a")

Poi l'ho git checkout myfile.jsseguito git pull upstream master. Questa volta l'operazione git pull è stata eseguita correttamente.


1

Ho riscontrato questo quando tirando dal maestro.

Il modo in cui l'ho gestito, usando Visual Studio;

  1. Innanzitutto, ho eseguito Annulla commit sulla mia soluzione.
  2. Poi ho fatto il processo pull di Git.

Spero che sia di aiuto!


1

La soluzione più semplice è:

git reset --hard && git pull

1

Sono nuovo in git e non sono sicuro che la mia soluzione sia una buona idea.

Ho testato TUTTE le risposte e nessuna di queste ha funzionato per me!

Ma ho trovato un'altra soluzione:

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

Spero che sia di aiuto.


1

L'errore "Le modifiche locali ai seguenti file verrebbero sovrascritte dall'unione" viene perché sono presenti alcune modifiche nel repository locale che NON sono state ancora eseguite, quindi prima di eseguire il pull dal repository remoto è sufficiente eseguire il commit delle modifiche nel repository locale.

Supponiamo che il tuo repository remoto abbia un ramo xyz e desideri che quel ramo xyz repo remoto sia unito in (copiato nel) ramo xyz repo locale,

{
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
}

0

Se questo errore è dovuto a terminazioni di riga,

git add
git checkout mybranch

funzionerà. Non sono davvero sicuro del perché funzioni.


0

Per Pycharm, puoi fare Git -> Ripristina e quindi tirare.


0

Questo messaggio può anche accadere se git-lfs viene utilizzato e un puntatore a un file è stato sovrascritto da un file reale.

allora usi:

git stash
git lfs migrate import
git pull

pieno output dal mio caso

λ git stash
Saved working directory and index state WIP on master: 5d4ad47 Merge branch 'feature/...' into 'master'
Encountered 1 file(s) that should have been pointers, but weren't:
        public/apple-touch-icon.png

λ git pull
Updating 5a4ad44..b25f79d
error: Your local changes to the following files would be overwritten by merge:
        public/apple-touch-icon.png
Please commit your changes or stash them before you merge.
Aborting

λ git lfs migrate import
migrate: Fetching remote refs: ..., done
migrate: Sorting commits: ..., done
migrate: Rewriting commits: 100% (0/0), done
migrate: Updating refs: ..., done
migrate: checkout: ..., done


λ git pull
Updating 5d4ad47..a25c79a
Fast-forward
 public/apple-touch-icon.png | Bin 2092 -> 130 bytes
 public/favicon.ico          | Bin 6518 -> 1150 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)

vedi https://github.com/git-lfs/git-lfs/issues/2839


0

Ho provato e ha funzionato con successo, prima di estrarre, fare il commit di tutti i file che non hai eseguito, quindi non riceverai i messaggi da AS.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.