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

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.

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.

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

git checkout HEAD^ file/to/overwrite
git pull

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

git reset --hard
git pull

Ecco una soluzione che elimina i cambiamenti graduali:

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

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

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

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

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.

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.

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

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.

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.

git reset --hard && git clean -df

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

Puoi usarlo per sovrascrivere il file

git checkout file_to_overwrite

Il modo migliore per risolvere questo problema è:

git checkout -- <path/file_name>

Successivamente è possibile sovrascrivere il file:

git pull origin master

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

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.

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.

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):

Quando provo a estrarre le modifiche remote ricevo un errore:

Queste modifiche non si intersecano con le modifiche locali:

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

Ora le mie modifiche locali sono leggermente inferiori:

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

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.

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.

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!

La soluzione più semplice è:

git reset --hard && git pull

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.

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
}

Se questo errore è dovuto a terminazioni di riga,

git add
git checkout mybranch

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

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

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

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.