Sono nuovo di GitHub . Oggi ho riscontrato qualche problema durante il tentativo di inviare il mio codice a GitHub.

Pushing to git@github.com:519ebayproject/519ebayproject.git
To git@github.com:519ebayproject/519ebayproject.git
 ! [rejected]        master -> master (non-fast-forward)
error: failed to push some refs to 'git@github.com:519ebayproject/519ebayproject.git'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. Merge the remote changes (e.g. 'git pull')
hint: before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

Non ho ancora inserito nulla nel repository, quindi perché devo estrarre qualcosa?

Ciò può causare la perdita di commit del repository remoto; usalo con cura.

Se non si desidera unire il ramo remoto nel proprio ramo locale (vedere le differenze con git diff ) e si desidera eseguire un push forzato, utilizzare il comando push con -f

git push -f origin <branch>

dov'è originil nome del tuo repository remoto .

Di solito, il comando rifiuta di aggiornare un riferimento remoto che non è un antenato del riferimento locale utilizzato per sovrascriverlo. Questo flag disabilita il controllo. Ciò può causare la perdita di commit del repository remoto; usalo con cura.

Come ti dice il messaggio,

Unisci le modifiche remote (ad esempio 'git pull')

Utilizzare git pullper estrarre le ultime modifiche dal repository remoto al repository locale. In questo caso, l'estrazione delle modifiche richiederà un'unione perché sono state apportate modifiche al repository locale.

Fornirò un esempio e una foto per spiegare. Supponiamo che il tuo ultimo richiamo dall'origine / filiale sia stato in Commit B. Hai completato e commesso alcuni lavori (Commit C). Allo stesso tempo, qualcun altro ha completato il proprio lavoro e lo ha spinto verso l'origine / il ramo (Commit D). Dovrà esserci un'unione tra questi due rami.

local branch:                         --- Commit C 
                                    /
                                   /
                                  /
origin/branch: Commit A ------ Commit B ---- Commit D

Poiché sei tu quello che vuole spingere, Git ti costringe a eseguire l'unione. Per fare ciò, devi prima estrarre le modifiche da origine / ramo.

local branch:                         --- Commit C -- Commit E
                                    /               /           
                                   /               /             
                                  /               /               
origin/branch: Commit A ------ Commit B ---- Commit D 

Dopo aver completato l'unione, ti sarà ora permesso di avanzare rapidamente in origine / ramo verso Commit E spingendo le tue modifiche.

Git richiede che tu gestisca le fusioni, perché un'unione può portare a conflitti.

Hai aggiornato il codice prima di inviare?

Utilizzare git pull origin masterprima di spingere qualsiasi cosa.

Presumo che tu stia usando origincome nome per il tuo telecomando.

È necessario eseguire il pull prima del push, per aggiornare il repository locale prima di eseguire il push di qualcosa (nel caso in cui qualcun altro abbia già aggiornato il codice github.com). Questo aiuta a risolvere i conflitti localmente.

Questo di solito accade quando si git committenta di git pushapportare modifiche in precedenza git pullingin quel ramo in xcui qualcun altro ha già apportato modifiche.

Il flusso normale sarebbe come di seguito,

PASSAGGIO 1 : git stashle modifiche locali senza commit su quel ramo.

PASSAGGIO 2 : git pull origin branch_name -va pull and mergemodifiche localmente impegnate su quel ramo ( dare un messaggio a questa unione e correggere eventuali conflitti ) .

PASSAGGIO 3 : git stash pople stashmodifiche ed ( Quindi è possibile effettuare commit su file spuntati se si desidera o inviare prima modifiche già impegnate (PASSAGGIO 4) e successivamente eseguire un nuovo commit sui file. )

PASSAGGIO 4 : git push origin branch_name -vle modifiche unite.

Sostituire branch_namecon master(per masterdiramazione).

Prima e semplice soluzione (non consigliata)

• Prova questo comando git push -f origin master.
• Questo comando sovrascriverà forzatamente il repository remoto (GitHub)

Soluzione consigliata

• Esegui questi comandi:

git pull --allow-unrelated-histories  //this might give you error but nothing to worry, next cmd will fix it
git add *
git commit -m "commit message"
git push

Se questo non funziona, segui 🔰

• Elimina la .gitdirectory dalla cartella.

• Quindi eseguire questi comandi:

  git init
  git add .
  git commit -m "First Commit"
  git remote add origin [url]
  git push -u origin master
  

O

git push -f origin master 

Utilizzare solo git push -f origin masterse -unon funziona per te.

Questo risolverà quasi ogni tipo di errore che si verifica durante il push dei tuoi file.

A volte abbiamo dimenticato di tirare e fatto un sacco di lavori nell'ambiente locale.

Se qualcuno vuole spingere senza tirare,

git push --force

sta lavorando. Questo non è raccomandato quando lavori con altre persone, ma quando il tuo lavoro è una cosa semplice o un progetto di giocattolo personale, sarà una soluzione rapida.

Alcuni di voi potrebbero avere questo errore perché Git non sa quale ramo si sta tentando di spingere.

Se il tuo messaggio di errore include anche

error: failed to push some refs to 'git@github.com:jkubicek/my_proj.git'
hint: Updates were rejected because a pushed branch tip is behind its remote
hint: counterpart. If you did not intend to push that branch, you may want to
hint: specify branches to push or set the 'push.default' configuration
hint: variable to 'current' or 'upstream' to push only the current branch.

quindi potresti voler seguire i consigli pratici di Jim Kubicek, Configura Git su Solo push ramo corrente , per impostare il ramo predefinito su corrente.

git config --global push.default current

git pull origin branch_name --rebase

Questo ha funzionato per me: il comando git pull origin branch_name --rebaseestrae inizialmente le modifiche da remoto branch_name, quindi il rebaseramo corrente nella parte superiore di esso.

Oltre alle risposte sopra, per me ha funzionato:

Scenario -

1. Ho spinto my_branch all'origine con successo.
2. Ho apportato alcune altre modifiche.
3. Quando ho provato a spingere di nuovo, (dopo aver fatto aggiungere, commettere ovviamente), ho ricevuto l'errore sopra menzionato.

Soluzione -

 1. git checkout **my_branch**
 2. git add, commit your changes.
 3. git pull origin **my_branch** (not origin, master, or develop)
 4. git push origin **my_branch**

Ho avuto lo stesso problema, quello che ho fatto è stato per la prima volta spinto con la forza usando questo

git push --force

L'ho fatto dopo aver eseguito il commit dei file e si è verificato un errore. È stato eseguito il commit di tutti i file e li ha spinti. Poi la prossima volta che stavo spingendo verso il github. Ho fatto quello che mi chiedeva e andava bene allora. Spero che questo funzioni anche per te :)

Ne ho parlato nel mio tutorial, Come usare GitHub: un tutorial per principianti .

Quando crei un nuovo repository su GitHub, GitHub potrebbe chiederti di creare un file readme. Se crei un file readme direttamente su GitHub, dovrai prima fare una richiesta 'pull' prima che la richiesta 'push' abbia esito positivo. Questi comandi 'estrarranno' il repository remoto, lo uniranno con i tuoi file attuali, e quindi 'riporteranno' tutti i file su GitHub:

git pull https://github.com/thomas07vt/MyFirstRepo.git master

git push https://github.com/thomas07vt/MyFirstRepo.git master

Stavo ricevendo il messaggio di errore sopra menzionato quando ho provato a inviare il mio ramo corrente foobar:

git checkout foobar
git push origin foo

Si è scoperto che avevo due filiali locali che seguivano lo stesso ramo remoto:

foo -> origin/foo (some old branch)
foobar -> origin/foo (my current working branch)

Ha funzionato per me spingere il mio ramo attuale usando:

git push origin foobar:foo

... e per pulire git branch -d

git push -f origine nome del ramo

Utilizzare il comando precedente solo se si è certi di non aver bisogno del codice di diramazione remoto, altrimenti eseguire prima l'unione e quindi premere il codice

Se non vuoi entrare nel tuo progetto attuale (e potenzialmente affrontare conflitti di unione non ti interessa risolvere) e non vuoi creare un altro ramo (questo sarà noioso per gestire un altro ramo), e don non voglio fare alcun forcecomando git rischioso e permanente (che anche dopo aver letto quello che fanno sono spesso sorpreso dalle implicazioni del farlo).

Soluzione : è possibile semplicemente trascinare il contenuto della cartella in un'altra cartella, trascinare il progetto nella cartella ora vuota, trascinare il contenuto estratto nel cestino, quindi trascinare il progetto corretto nella cartella. Dovresti essere in grado di spingere correttamente e ottenere i risultati desiderati. Mi ci vogliono letteralmente meno di 10 secondi per farlo.

Alle persone che mi direbbero che ciò non è corretto senza citarne le conseguenze, o le persone che mi dicono di usare un comando che mi provoca fastidi futuri, dico: "Questo metodo mi impiega letteralmente meno di 10 secondi". Se trovo un comando git che impiega meno di 10 secondi per essere implementato e ha lo stesso effetto, lo adotterò. Fino ad allora, sto usando questo metodo.

Un aspetto negativo di questo metodo è che la cronologia del commit apparirà lineare quando ti sei effettivamente unito in un ramo senza che l'unione sia documentata. Questo potrebbe non essere il metodo migliore quando si lavora con i gruppi. Lavora sui rami in quei casi!

Ho avuto lo stesso problema, ma nel mio caso avevo digitato il ramo sbagliato sul telecomando. Quindi, sembra che sia un'altra fonte di questo problema ... ricontrolla che stai spingendo al ramo corretto.

Ho riscontrato lo stesso problema e ho scoperto che ero su un ramo (locale) diverso da quello che pensavo di essere E che il ramo locale corretto era dietro in commit da remoto.

La mia soluzione: controlla il ramo corretto, scegli il commit dall'altro ramo locale, git pull e git push

Ho avuto un problema simile e si è scoperto che il mio flusso di lavoro per mantenere aggiornato il mio ramo era in errore. Stavo facendo quanto segue:

Nel mio "padrone" locale

git fetch upstream
git merge upstream/master --ff-only

poi di nuovo nella mia filiale locale

git rebase master

Funzionava bene con un flusso git precedente ma non con github. Il git rebaseproblema qui era quello di causare problemi con la sincronizzazione (e ammetterò che è qualcosa che ho dovuto accettare senza comprendere appieno) e purtroppo mi ha messo in una posizione in cui è git push -fdiventata probabilmente l'opzione più semplice. Non bene.

Il mio nuovo flusso è di aggiornare il ramo direttamente usando git mergecome segue:

Nella mia filiale locale

git fetch upstream
git merge upstream/master

Nessun avanzamento veloce, poiché avrò apportato modifiche ovviamente nella filiale locale.

Come probabilmente puoi dire, non sono un esperto di git ma sono informato in modo affidabile che questo flusso di lavoro probabilmente eviterà i problemi specifici che ho avuto.

Nel mio caso, avevo verificato "mybranch" e l'avevo fatto git pull, quindi non riuscivo a capire perché la spinta non funzionasse. Alla fine, mi sono reso conto che stavo spingendo il ramo sbagliato. Stavo scrivendo git push origin masterinvece di git push origin mybranch.

Quindi, se hai già fatto git pulle ricevi ancora questo messaggio, assicurati di spingere il ramo corretto.

Il nome della tua filiale è uguale al nome della filiale remota?

In caso contrario, è necessario effettuare il checkout di un nuovo ramo con lo stesso nome del ramo remoto e provare a spingerlo di nuovo.

Supponiamo che il ramo remoto che vuoi spingere sia [ test ] e che il tuo ramo locale sia chiamato [ test ].

Se non sei nel ramo di prova , prima passa ad esso.

git checkout test

Quindi aprire un nuovo ramo e denominarlo test .

git checkout -b testing

Ora è il momento di spingerlo:

git push [remote repo] testing

Ho risolto questo problema nel mio repository GIT. Non è necessario rebaseo forceimpegnarsi in questo caso. Utilizzare i passaggi seguenti per risolvere questo problema -

local_barnch> git branch --set-upstream to=origin/<local_branch_name> 

local_barnch>git pull origin <local_branch_name>

local_barnch> git branch --set-upstream to=origin/master

local_barnch>git push origin <local_branch_name>

spero che possa aiutare.

Un'altra soluzione è far avanzare la testa del telecomando effettuando un altro commit, se possibile. Dopo aver tirato questa testa avanzata nella sottostruttura locale, sarai in grado di spingerla di nuovo.

Stavo ricevendo un errore simile mentre spingevo le ultime modifiche in un repository Git nudo che utilizzo per gitweb . Nel mio caso non ho apportato modifiche al repository nudo, quindi ho semplicemente eliminato il mio repository nudo e clonato di nuovo:

git clone --bare <source repo path> <target bare repo path>

Se sei sicuro che nessuno ha apportato modifiche al tuo repository git e che stai lavorando all'ultima versione, git pullnon ha senso come soluzione nel tuo cuore ...

Quindi questo è probabilmente quello che è successo, hai usato git commit --amend

Ti consente di combinare le modifiche graduali con il commit precedente anziché eseguirne il commit come un'istantanea completamente nuova. Può anche essere usato per modificare semplicemente il precedente messaggio di commit senza cambiarne l'istantanea.

Tutorial ATLASSIAN: riscrivere la storia

Tuttavia, non è consigliabile eseguire git commit --amend se hai già inviato il commit a GitHub , questo perché "la modifica non modifica solo il commit più recente, ma lo sostituisce del tutto. A Git, sembrerà un nuovo commit" il che significa che per gli altri sviluppatori su GitHub, la cronologia sembra A-> B-> C ma a te sembra A-> B-> D, se GitHub te lo consente push, tutti gli altri dovranno correggere manualmente la cronologia

Questo è il motivo per cui ricevi il messaggio di errore ! [rejected] master -> master (non-fast-forward), se sai che nessuno ha eseguito l'ultima modifica, puoi farlo git push --force, questo cambierà la cronologia git nel tuo repository pubblico . Altrimenti ... puoi esibirti git pull, ma credo che questo avrà lo stesso risultato che non hai passato git commit --amend, creerà un nuovo commit (cioè: cronologia git dopo git pull: A-> B-> C-> D )

per maggiori dettagli: come modificare il tuo ultimo commit

Un'altra opzione: rinominare localmente il tuo ramo in qualcosa di nuovo.

Sarai quindi in grado di inviarlo al repository remoto, ad esempio se questo è il tuo modo di conservare una copia (backup) e assicurarti che nulla vada perso.

Puoi recuperare il ramo remoto per avere una copia locale ed esaminare le differenze tra (i) ciò che il telecomando aveva (con il vecchio nome del ramo) e (ii) quello che hai (con il nuovo nome del ramo) e decidere cosa fare . Dato che non eri a conoscenza delle differenze del telecomando in primo luogo (da qui il problema), semplicemente fondere o forzare i cambiamenti da qualche parte è troppo brutale.

Guarda le differenze, scegli su quale ramo vuoi lavorare, scegli le modifiche che desideri dall'altro ramo o annulla le modifiche che non desideri sul ramo che hai, ecc.

Quindi dovresti essere in grado di decidere se forzare la tua versione pulita sul telecomando o aggiungere nuove modifiche o altro.

Il problema con il comando push è che il tuo repository locale e remoto non corrisponde. Se si inizializza il file Leggimi per impostazione predefinita quando si crea un nuovo repository dall'hub git, il ramo master viene creato automaticamente. Tuttavia, quando si tenta di spingere che non ha alcun ramo. non puoi spingere ... Quindi, la migliore pratica è creare un repository senza l'inizializzazione readme predefinita.

Questo problema è di solito causato dalla creazione di un file readme.md, che viene conteggiato come commit, non sincronizzato localmente sul sistema e mancante dietro la testa, quindi mostra una richiesta git pull. Puoi provare a evitare il file Leggimi e quindi provare a eseguire il commit. Ha funzionato nel mio caso.

Un'altra causa di questo problema (apparentemente non così comune) ...

Il mio server era dietro ~ 12 ore quando ho fatto un push

Ho configurato NTP sul server SYNC il mio orologio.

Ho eseguito una nuova push git che ha portato all'errore discusso in questo post.

Se per caso viene git pullstampato Already up-to-date, potresti voler controllare il push.defaultparametro git globale (In ~/.gitconfig). Impostalo su simplese fosse dentro matching. La risposta di seguito spiega perché:

Git - Qual è la differenza tra push.default "matching" e "simple"

Inoltre, vale la pena verificare se la filiale locale non è aggiornata utilizzando git remote show origine fare un pull se necessario

usa git pull https://github.com/username/repository È perché Github e i repository remoti non sono sincronizzati. Se pullil repository e quindi Pushtutto sarà sincronizzato e l'errore scomparirà.

`

git pull stampe già up-to-date

soluzione:

potresti essere creato un repository / progetto in remoto (server) e aggiungere qualche file lì, quindi creare nuovamente una cartella nel tuo git locale e inizializzato git init- questo è l' errore , non dovresti creare git initin locale, invece clonare il progetto nel tuo locale utilizzandogit clone

quindi tirare