Eu sou novo no GitHub . Hoje encontrei um problema quando estava tentando enviar meu código para o 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.

Ainda não enviei nada no repositório, então por que preciso extrair alguma coisa?

Isso pode fazer com que o repositório remoto perca confirmações; use-o com cuidado.

Se você não deseja mesclar a ramificação remota em sua ramificação local (consulte as diferenças com o git diff ) e quiser fazer um push forçado, use o comando push com -f

git push -f origin <branch>

onde originé o nome do seu repositório remoto .

Normalmente, o comando se recusa a atualizar uma ref remota que não é um ancestral da ref local usada para substituí-la. Este sinalizador desativa a verificação. Isso pode fazer com que o repositório remoto perca confirmações; use-o com cuidado.

Como a mensagem diz,

Mesclar as alterações remotas (por exemplo, 'git pull')

Use git pullpara extrair as alterações mais recentes do repositório remoto para o repositório local. Nesse caso, puxar alterações exigirá uma mesclagem porque você fez alterações no seu repositório local.

Vou fornecer um exemplo e uma imagem para explicar. Vamos supor que a sua última atração da origem / ramificação tenha sido no Commit B. Você concluiu e comprometeu algum trabalho (Commit C). Ao mesmo tempo, outra pessoa concluiu seu trabalho e o empurrou para a origem / filial (Confirmação D). Será necessário haver uma mesclagem entre esses dois ramos.

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

Porque você é o único que deseja pressionar, o Git obriga a executar a mesclagem. Para fazer isso, você deve primeiro extrair as alterações da origem / ramificação.

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

Após concluir a mesclagem, você poderá avançar rapidamente a origem / ramificação para o Commit E pressionando suas alterações.

O Git exige que você lide com as mesclagens, porque uma mesclagem pode levar a conflitos.

Você atualizou seu código antes de enviar?

Use git pull origin masterantes de empurrar qualquer coisa.

Presumo que você esteja usando origincomo um nome para o seu controle remoto.

Você precisa puxar antes de enviar, para atualizar seu repositório local antes de enviar algo (apenas no caso de alguém já ter atualizado o código github.com). Isso ajuda a resolver conflitos localmente.

Isso normalmente acontece quando você git committenta fazer git pushalterações anteriormente git pullingnaquele ramo em xque outra pessoa já fez alterações.

O fluxo normal seria como abaixo,

PASSO 1 : git stashsuas alterações locais não confirmadas nesse ramo.

PASSO 2 : git pull origin branch_name -vpara pull and mergeas alterações confirmadas localmente nesse ramo ( transmita alguma mensagem a essa mesclagem e corrija conflitos, se houver ) .

ETAPA 3 : git stash popas stashalterações editadas ( você pode fazer confirmações nos arquivos pop-up se desejar ou enviar as alterações já confirmadas (STEP4) primeiro e fazer novas confirmações nos arquivos posteriormente. )

PASSO 4 : git push origin branch_name -vas alterações mescladas.

Substitua branch_namepor master(para masterramificação).

Primeira e simples solução (não recomendado)

• Tente este comando git push -f origin master.
• Este comando substituirá forçosamente o repositório remoto (GitHub)

Solução recomendada

• Execute estes comandos:

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 isso não funcionar, siga 🔰

• Exclua o .gitdiretório da pasta.

• Em seguida, execute estes comandos:

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

OU

git push -f origin master 

Use apenas git push -f origin masterse -unão funcionar para você.

Isso resolverá quase todos os tipos de erros que ocorrem ao enviar seus arquivos.

Às vezes esquecemos o puxão e fizemos muitos trabalhos no ambiente local.

Se alguém quiser empurrar sem puxar,

git push --force

está funcionando. Isso não é recomendado quando se trabalha com outras pessoas, mas quando o seu trabalho é uma coisa simples ou um projeto pessoal de brinquedos, será uma solução rápida.

Alguns de vocês podem estar recebendo esse erro porque o Git não sabe em qual ramificação você está tentando enviar.

Se a sua mensagem de erro também incluir

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.

convém seguir as dicas úteis de Jim Kubicek, Configurar o Git para enviar apenas a ramificação atual , para definir a ramificação padrão como atual.

git config --global push.default current

git pull origin branch_name --rebase

Isso funcionou para mim - o comando git pull origin branch_name --rebasepuxará as alterações do branch_name remoto primeiro, depois rebaseo branch atual na parte superior.

Além das respostas acima, o seguinte funcionou para mim: -

Cenário -

1. Eu empurrei my_branch de origem com sucesso.
2. Fiz mais algumas mudanças.
3. Quando tentei pressionar novamente (depois de adicionar, confirmar, é claro), recebi o erro mencionado acima.

Solução -

 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**

Eu tive o mesmo problema, o que fiz foi primeiro empurrá-lo à força usando este

git push --force

Fiz isso depois de confirmar os arquivos e estava recebendo um erro como você conseguiu.Ele confirmou todos os arquivos e os empurrou. Então, da próxima vez que eu estava empurrando para o github. Eu fiz o que ele me pediu e estava tudo bem então. Espero que isto funcione para você também :)

Eu mencionei isso no meu tutorial, Como usar o GitHub: um tutorial para iniciantes .

Quando você cria um novo repositório no GitHub, o GitHub pode solicitar que você crie um arquivo leia-me. Se você criar um arquivo leia-me diretamente no GitHub, precisará primeiro fazer uma solicitação 'pull' antes que a solicitação 'push' seja bem-sucedida. Esses comandos 'puxam' o repositório remoto, os mesclam com os arquivos atuais e depois 'enviam' todos os arquivos de volta ao GitHub:

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

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

Eu estava recebendo a mensagem de erro acima mencionada quando tentei enviar por push minha ramificação atual foobar:

git checkout foobar
git push origin foo

Acontece que eu tinha duas filiais locais rastreando a mesma filial remota:

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

Funcionou para mim enviar minha ramificação atual usando:

git push origin foobar:foo

... e limpar com git branch -d

origem do git push -f nome da filial

Use o comando acima apenas se tiver certeza de que não precisa de código de ramificação remota, caso contrário, mescle primeiro e empurre o código

Se você não deseja entrar no seu projeto atual (e, potencialmente, enfrentar conflitos de mesclagem que não deseja resolver) e não deseja criar outro ramo (isso será tedioso para gerenciar outro ramo), e você não não quero executar forcecomandos git arriscados e permanentes (que, mesmo depois de ler o que fazem, geralmente fico surpreso com as implicações de fazê-lo).

Solução : você pode simplesmente arrastar o conteúdo da pasta para outra pasta, puxar o projeto para a pasta agora vazia, arrastar o conteúdo puxado para a lixeira e arrastar o projeto correto de volta para a pasta. Você deve poder pressionar corretamente e obter os resultados desejados. Literalmente, levo menos de 10 segundos para fazer isso.

Para as pessoas que me diriam que isso não é apropriado sem citar nenhuma conseqüência, ou as pessoas que me dizem para usar um comando que me cause aborrecimentos futuros, digo: "Esse método literalmente leva menos de 10 segundos". Se eu encontrar um comando git que leva menos de 10 segundos para implementar e tem exatamente o mesmo efeito, adotarei isso. Até então, estou usando esse método.

Uma desvantagem desse método é que seu histórico de consolidação aparecerá linear quando você realmente mesclar em uma ramificação sem que a mesclagem seja documentada. Esse pode não ser o melhor método ao trabalhar com grupos. Trabalhe em galhos nesses casos!

Só tive o mesmo problema, mas no meu caso eu digitei o ramo errado no controle remoto. Portanto, parece que é outra fonte desse problema ... verifique novamente que você está enviando para o ramo correto.

Tive o mesmo problema e, por acaso, eu estava em um ramo (local) diferente do que eu pensava e o ramo local correto estava atrasado em confirmações remotas.

Minha solução: faça o checkout da ramificação correta, escolha a confirmação da outra ramificação local, git pull e git push

Eu tive um problema semelhante e constatou que meu fluxo de trabalho para manter minha filial atualizada estava com falha. Eu estava fazendo o seguinte:

No meu 'mestre' local

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

então de volta na minha filial local

git rebase master

Isso funcionou bem para um fluxo git anterior, mas não com o github. O git rebaseproblema aqui estava causando problemas com a sincronização (e admito que é algo que tive que aceitar sem entender completamente) e, infelizmente, me colocou em uma posição em que git push -fprovavelmente se tornou a opção mais fácil. Não é bom.

Meu novo fluxo é atualizar a ramificação diretamente usando git mergeo seguinte:

Na minha filial local

git fetch upstream
git merge upstream/master

Não há avanço rápido, pois terei feito mudanças de rumo na filial local.

Como você provavelmente pode perceber, não sou especialista em git, mas sou informado com segurança de que esse fluxo de trabalho provavelmente evitará os problemas específicos que tive.

No meu caso, eu havia feito o "mybranch" e o feito git pull, então não consegui descobrir por que o impulso não estava funcionando. Eventualmente, eu percebi que estava empurrando o ramo errado. Eu estava digitando em git push origin mastervez de git push origin mybranch.

Portanto, se você já fez git pulle ainda recebe essa mensagem, verifique se está enviando a ramificação correta.

O nome da sua filial é igual ao nome da filial remota?

Se não, você deve fazer check-out de uma nova ramificação com o mesmo nome da ramificação remota e tentar enviá-la novamente.

Suponha que a ramificação remota que você deseja enviar seja [ testing ] e sua ramificação local seja nomeada como [ test ].

Se você não estiver no ramo de teste , primeiro mude para ele.

git checkout test

Em seguida, abra uma nova ramificação e denomine-a de teste .

git checkout -b testing

Agora, é hora de pressionar:

git push [remote repo] testing

Eu resolvi esse problema no meu repositório GIT. Não há necessidade rebaseou forceconfirmação neste caso. Use as etapas abaixo para resolver isso -

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>

espero que ajude.

Outra solução é avançar o chefe do controle remoto, fazendo outro commit, se possível. Depois de puxar essa cabeça avançada para a subárvore local, você poderá empurrá-la novamente.

Eu estava recebendo um erro semelhante ao enviar as alterações mais recentes para um repositório Git vazio que eu uso para o gitweb . No meu caso, não fiz nenhuma alteração no repositório vazio, então simplesmente excluí meu repositório vazio e clonei novamente:

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

Se você tem certeza de que ninguém fez alterações no seu repositório git e está trabalhando na versão mais recente, git pullnão faz sentido como uma solução em seu coração ...

Então foi provavelmente o que aconteceu, você usou git commit --amend

Permite combinar as alterações faseadas com a confirmação anterior, em vez de confirmar como uma captura instantânea totalmente nova. Também pode ser usado para simplesmente editar a mensagem de confirmação anterior sem alterar seu instantâneo.

Tutorial ATLASSIAN: reescrevendo o histórico

No entanto, não é recomendável executar git commit --amend se você já enviou o commit ao GitHub , porque "alterar não apenas altera o commit mais recente - ele o substitui inteiramente. Para o Git, ele parecerá um commit totalmente novo" o que significa para outro desenvolvedor no seu GitHub, o histórico se parece com A-> B-> C, mas para você se parece com A-> B-> D, se o GitHub permitir push, todos os outros terão que corrigir manualmente o histórico

Essa é a razão pela qual você recebe a mensagem de erro ! [rejected] master -> master (non-fast-forward). Se você sabe que ninguém efetuou a alteração mais recente, você pode fazê- git push --forcelo. Isso alterará o histórico do git em seu repositório público . Caso contrário ... você pode executar git pull, mas acredito que isso terá o mesmo resultado que você não passou git commit --amend, ele criará um novo commit (por exemplo: histórico do git após o git pull: A-> B-> C-> D )

para obter mais detalhes: Como alterar seu último commit

Outra opção: renomeie localmente sua filial para algo novo.

Você poderá enviá-lo ao repositório remoto, por exemplo, se essa é a sua maneira de manter uma cópia (backup) e garantir que nada se perca.

Você pode buscar a filial remota para obter uma cópia local e examinar as diferenças entre (i) o que o controle remoto possuía (com o nome antigo da filial) e (ii) o que você possui (com o novo nome da filial) e decidir o que fazer . Como você não estava ciente das diferenças do controle remoto (daí o problema), simplesmente mesclar ou forçar alterações em algum lugar é muito brutal.

Observe as diferenças, escolha em qual filial você deseja trabalhar, escolha as alterações desejadas na outra filial ou reverta as alterações que você não deseja na filial que você possui etc.

Então você deve estar em posição de decidir se deseja forçar sua versão limpa no controle remoto ou adicionar novas alterações, ou o que for.

O problema com o comando push é que seu repositório local e remoto não corresponde. Se você inicializar o leia-me por padrão ao criar um novo repositório a partir do git hub, a ramificação principal será criada automaticamente. No entanto, quando você tenta enviar isso não tem nenhum ramo. você não pode enviar por push ... Portanto, a melhor prática é criar repositório sem inicialização padrão do leia-me.

Esse problema geralmente é causado pela criação de um arquivo readme.md, que é contado como uma confirmação, não é sincronizado localmente no sistema e está faltando atrás da cabeça, portanto, mostra uma solicitação git pull. Você pode tentar evitar o arquivo leia-me e tentar confirmar. Funcionou no meu caso.

Outra causa deste problema (aparentemente não tão comum) ...

Meu servidor estava atrasado ~ 12 horas quando fiz um push

Eu configurei o NTP no servidor SYNC my clock.

Eu executei um novo git push que levou ao erro discutido neste post.

Se por acaso for git pullimpresso Already up-to-date, convém verificar o push.defaultparâmetro git global (In ~/.gitconfig). Configurá-lo para simplese estivesse em matching. A resposta abaixo explica por que:

Git - Qual é a diferença entre push.default "matching" e "simple"

Além disso, vale a pena verificar se sua filial local está desatualizada git remote show origine fazer um puxão, se necessário

use git pull https://github.com/username/repository É porque o Github e os repositórios remotos não estão sincronizados. Se você pullrepo e Pushtudo estará sincronizado e o erro desaparecerá.

`

git pull já imprime up-to-date

solução:

você pode criar um repositório / projeto no controle remoto (servidor) e adicionar algum arquivo lá. Em seguida, novamente criou uma pasta no seu local e inicializou o git git init- este é o erro , você não deve criar git initno local, mas clonar o projeto no seu local usandogit clone

então puxe