Come faccio a risolvere git dicendo "Commetti le modifiche o nascondile prima di poterle unire"?

Ho effettuato alcuni aggiornamenti sul mio computer locale, li ho trasferiti in un repository remoto e ora sto provando a eseguire il pull delle modifiche sul server e ricevo il messaggio;

errore: le modifiche locali ai seguenti file verrebbero sovrascritte dall'unione:

wp-content / W3TC-config / master.php

Per favore, commetti le modifiche o nascondile prima di poterle unire.

Quindi ho corso

git checkout -- wp-content/w3tc-config/master.php

e riprovato e ricevo lo stesso messaggio. Suppongo che abbia w3tccambiato qualcosa nel file di configurazione sul server. Non mi importa se la copia locale o remota va sul server (suppongo che quella remota sia la migliore), voglio solo essere in grado di unire il resto delle mie modifiche (aggiornamenti del plugin).

Qualche idea?

Non puoi unirti a modifiche locali. Git ti protegge dalla perdita di modifiche potenzialmente importanti.

Hai tre opzioni:

• Conferma la modifica utilizzando

  git commit -m "My message"
  

• Stash.

  Lo stashing funge da stack, in cui è possibile inviare le modifiche e le pop in ordine inverso.

  Per riporre, digitare

  git stash
  

  Fai l'unione e poi tira la scorta:

  git stash pop
  

• Annulla le modifiche locali

  usando git reset --hard
  ogit checkout -t -f remote/branch

  Oppure: Annulla le modifiche locali per un file specifico

  utilizzando git checkout filename

git stash
git pull <remote name> <remote branch name> (or) switch branch
git stash apply --index

Il primo comando memorizza temporaneamente le modifiche nello stash e le rimuove dalla directory di lavoro.

Il secondo comando cambia i rami.

Il terzo comando ripristina le modifiche che sono state memorizzate nella scorta (l' --indexopzione è utile per assicurarsi che i file gestiti siano ancora messi in scena).

Puoi provare uno dei seguenti metodi:

rebase

Per modifiche semplici, prova a eseguire nuovamente la reimpostazione su di esso mentre esegui le modifiche, ad es

git pull origin master -r

Quindi applicherà il tuo ramo corrente sopra il ramo a monte dopo il recupero.

Questo è equivalente a: checkout master, fetche rebase origin/mastercomandi git.

Questa è una modalità operativa potenzialmente pericolosa. Riscrive la cronologia, il che non fa ben sperare quando hai già pubblicato quella cronologia. Non utilizzare questa opzione se non hai letto git-rebase(1)attentamente.

check-out

Se non ti interessano le modifiche locali, puoi passare temporaneamente a un'altra filiale (con la forza) e ripristinarla, ad es

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

Ripristina

Se non ti interessano le modifiche locali, prova a ripristinarlo su HEAD (stato originale), ad es

git reset HEAD --hard

Se sopra non aiuta, potrebbero essere delle regole nel tuo file di normalizzazione git ( .gitattributes), quindi è meglio impegnare ciò che dice. Oppure il tuo file system non supporta le autorizzazioni, quindi devi disabilitarlo filemodenella tua configurazione di git.

Correlati: Come imposto "git pull" per sovrascrivere i file locali?

Prova questo

git stash save ""

e prova a tirare di nuovo

Quindi la situazione in cui mi sono imbattuto era la seguente:

errore: le modifiche locali ai seguenti file verrebbero sovrascritte da merge: wp-content / w3tc-config / master.php Per favore, commetti le modifiche o nascondile prima di poterle unire.

tranne, proprio prima, era remoto: quindi in realtà questo:

remote: errore: le modifiche locali ai seguenti file verrebbero sovrascritte da merge: some / file.ext Per favore, commetti le modifiche o nascondile prima di poterle unire.

Quello che stava succedendo era (penso, non positivo al 100%) che l'hook hook di ricezione git stava iniziando a funzionare e rovinarsi a causa dei cambiamenti di movimento nel repository del server remoto, che in teoria non avrebbe dovuto essere toccato.

Quindi quello che ho finito per rintracciare l'hook post-ricezione e trovarlo, era dover andare al repository remoto sul server e c'era il cambiamento (che non era sul mio repository locale, che, in effetti, ha detto che corrispondeva, nessuna modifica, niente da impegnare, aggiornato, ecc.) Quindi, mentre sul locale, non c'erano cambiamenti, sul server, allora ho fatto un git checkout -- some/file.exte poi i repository locali e remoti effettivamente abbinati e potevo continuare a lavorare e distribuire. Non sono del tutto sicuro di come si sia verificata questa situazione, anche se un paio di dozzine di sviluppatori più le modifiche dell'IT potrebbero averne a che fare.

ATTENZIONE: questo eliminerà i file non tracciati, quindi non è un'ottima risposta a questa domanda.

Nel mio caso, non volevo conservare i file, quindi questo ha funzionato per me:

Git 2.11 e successivi:

git clean  -d  -fx .

Git precedente:

git clean  -d  -fx ""

Riferimento: http://www.kernel.org/pub/software/scm/git/docs/git-clean.html

• -x significa che vengono rimossi anche i file ignorati e i file sconosciuti a Git.

• -d significa rimuovere le directory non tracciate oltre ai file non tracciati.

• -f è necessario per forzare l'esecuzione.

Per tenere traccia dei file appena creati durante la risoluzione di questo problema:

Se sono stati appena creati file , è possibile creare una patch di modifiche locali, estrarre le fusioni remote e applicare la patch locale dopo che l'unione remota è stata completata come definito passo dopo passo:

1. Metti in scena le tue modifiche locali. (non impegnarti). La gestione temporanea è necessaria per creare patch di nuovi file creati (in quanto non ancora tracciati)

git add .

2. Crea una patch per tenere traccia

git diff --cached > mypatch.patch

3. Annulla le modifiche locali ed elimina i nuovi file locali

git reset --hard

4. Tirare le modifiche

git pull

5. Applica la tua patch

git apply mypatch.patch

Git unirà le modifiche e creerà file .rej per le modifiche che non vengono unite.

Come suggerito da Anu, se hai problemi con l'applicazione della patch, prova:

git apply --reject --whitespace=fix mypatch.patch Questa risposta git: patch non applica le discussioni in dettaglio su questo problema

Goditi il ​​tuo lavoro continuo sulla tua funzione e, una volta terminato, esegui il commit delle modifiche locali.

Chiedere il commit prima di tirare

• git stash
• git pull origin << branchname >>

Se necessario :

• git stash si applica

Per me ha git reset --hardfunzionato solo .

Commettere non era un'opzione, poiché non c'era nulla da impegnare.

Lo stashing non era un'opzione perché non c'era nulla da riporre.

Sembra che avrebbe potuto provenire da file esclusi .git/info/excludee aver modificato git update-index --assume-unchanged <file>alcuni file.

Nel mio caso, ho eseguito il backup e quindi eliminato il file di cui Git si stava lamentando, impegnato, quindi sono stato finalmente in grado di controllare un altro ramo.

Ho quindi sostituito il file, copiato nuovamente nel contenuto e continuato come se non fosse successo nulla.

Ciò è probabilmente causato da problemi CRLF.

Vedi: Perché dovrei usare core.autocrlf = true in Git?

Usa questo per estrarre e forzare l'aggiornamento:

git pull origin master
git checkout origin/master -f

Ho provato la prima risposta: git stashcon il punteggio più alto ma il messaggio di errore è ancora apparso, e poi ho trovato questo articolo per eseguire il commit delle modifiche invece di nascondere " Commuct Reluctant"

e il messaggio di errore è finalmente scomparso:

1: git add .

2: git commit -m "this is an additional commit"

3: git checkout the-other-file-name

poi ha funzionato. spero che questa risposta aiuti. :)

Se stai usando le estensioni di Git dovresti essere in grado di trovare le tue modifiche locali Working directorycome mostrato di seguito:

Se non vedi alcuna modifica, probabilmente è perché sei su un sottomodulo sbagliato. Quindi controlla tutti gli elementi con un'icona sottomarina come mostrato di seguito:

Quando hai trovato alcune modifiche non impegnate:

Seleziona la linea con Working directory, vai alla scheda Diff , fai clic con il pulsante destro del mouse sulle righe con un'icona a forma di matita (o +o -), scegli Ripristina per eseguire prima il commit o il commit o lo stash o qualunque cosa tu voglia fare con esso.

Per me questo ha funzionato:

git reset --hard

e poi

git pull origin <*current branch>

dopo di che

git checkout <*branch>

Probabilmente

git --rebase --autostash

aiuterebbe