Git puxa uma certa ramificação do GitHub

Eu tenho um projeto com vários ramos. Eu os enviei para o GitHub , e agora que outra pessoa está trabalhando no projeto, preciso extrair suas ramificações do GitHub. Funciona bem no mestre. Mas diga que alguém criou um ramo xyz. Como posso puxar ramificação xyzdo GitHub e mesclá-la em ramificação xyzno meu localhost?

Na verdade, tenho a minha resposta aqui: Empurre e puxe ramos no Git

Mas recebo um erro "! [Rejeitado]" e algo sobre "avanço rápido".

Alguma sugestão?

Mas recebo um erro "! [Rejeitado]" e algo sobre "avanço rápido"

Isso ocorre porque o Git não pode mesclar as alterações dos ramos no seu mestre atual. Digamos que você fez check-out da ramificação mastere deseja mesclar na ramificação remota other-branch. Quando você faz isso:

$ git pull origin other-branch

Git está basicamente fazendo isso:

$ git fetch origin other-branch && git merge other-branch

Ou seja, a pullé apenas a fetchseguido de a merge. No entanto, quando pull-ing, o Git só será mesclado other-branch se puder executar uma mesclagem de avanço rápido . Uma mesclagem de avanço rápido é uma mesclagem na qual o cabeçalho do ramo em que você está tentando mesclar é um descendente direto do cabeçalho do ramo que você deseja mesclar. Por exemplo, se você tiver essa árvore do histórico, a mesclagem other-branchresultará em uma mesclagem de avanço rápido:

O-O-O-O-O-O
^         ^
master    other-branch

No entanto, isso não seria uma mesclagem de avanço rápido:

    v master
O-O-O
\
 \-O-O-O-O
         ^ other-branch

Para resolver seu problema, primeiro busque a ramificação remota:

$ git fetch origin other-branch

Em seguida, mescle-o em sua ramificação atual (presumo que seja master) e corrija quaisquer conflitos de mesclagem:

$ git merge origin/other-branch
# Fix merge conflicts, if they occur
# Add merge conflict fixes
$ git commit    # And commit the merge!

Basta rastrear suas ramificações remotas explicitamente e um simples git pullfará exatamente o que você deseja:

git branch -f remote_branch_name origin/remote_branch_name
git checkout remote_branch_name

Esta última é uma operação local.

Ou ainda mais adequado à documentação do GitHub sobre bifurcação :

git branch -f new_local_branch_name upstream/remote_branch_name

Você pode puxar uma ramificação para uma ramificação com os seguintes comandos.

git pull {repo} {remotebranchname}:{localbranchname}

git pull origin xyz:xyz

Quando você está no ramo principal, também pode fazer o checkout de um ramo como:

git checkout -b xyz

Isso cria uma nova ramificação, "xyz", do mestre e faz o check-out diretamente.

Então você faz:

git pull origin xyz

Isso puxa a nova ramificação para sua xyzramificação local .

A melhor maneira é:

git checkout -b <new_branch> <remote repo name>/<new_branch>

git fetch irá pegar a lista mais recente de ramos.

Agora você pode git checkout MyNewBranch

Feito :)

Para mais informações, consulte docs: git fetch

Não sei se entendi completamente o problema, mas puxar um ramo existente é feito assim (pelo menos funciona para mim :)

git pull origin BRANCH

Isso pressupõe que sua filial local seja criada fora da origem / FILIAL.

Isso me ajudou a obter ramificação remota antes de mesclá-la com outra:

git fetch repo xyz:xyz
git checkout xyz

Simplificando, se você deseja obter do GitHub o ramo the_branch_I_want:

git fetch origin
git branch -f the_branch_I_want origin/the_branch_I_want
git checkout the_branch_I_want

git pull <gitreponame> <branchname>

Normalmente, se você tiver apenas repo atribuído ao seu código, o gitreponame seria a origem.

Se você estiver trabalhando em dois repositórios, como um local e outro remoto, como você pode verificar a lista de repositórios no git remote -v . isso mostra quantos repositórios estão atribuídos ao seu código atual.

BranchName deve existir no gitreponame correspondente.

você pode usar os dois comandos a seguir para adicionar ou remover repositórios de repositório

git remote add <gitreponame> <repourl>
git remote remove <gitreponame>

você também pode fazer

git pull -r origin master

corrigir conflitos de mesclagem, se houver

git rebase --continue

-r é para rebase. Isso fará com que você ramifique a estrutura de

        v  master       
o-o-o-o-o
     \o-o-o
          ^ other branch

para

        v  master       
o-o-o-o-o-o-o-o
              ^ other branch

Isso levará a uma história mais limpa. Nota: Caso você já tenha enviado sua outra ramificação para a origem (ou qualquer outro controle remoto), pode ser necessário forçar a sua ramificação após o rebase.

git push -f origin other-branch

eu fiz

git branch -f new_local_branch_name origin/remote_branch_name

Ao invés de

git branch -f new_local_branch_name upstream/remote_branch_name

Como sugerido por @innaM. Quando usei a versão upstream, ele dizia 'fatal: Não é um nome de objeto válido:' upstream / remote_branch_name ''. Eu não fiz git fetch origincomo um comentário sugerido, mas simplesmente substituí-lo upstreampor origin. Eu acho que eles são equivalentes.

para puxar o ramo do GitHub, você pode usar

git checkout --track origin/the-branch-name

Verifique se o nome da ramificação é exatamente o mesmo.