Meu colega e eu estamos trabalhando no mesmo repositório. Nós o ramificamos em dois ramos, cada um tecnicamente para projetos diferentes, mas eles têm semelhanças, portanto, às vezes, queremos voltar ao * masterdo branch.

No entanto, eu tenho o branch. Como meu colega consegue esse ramo especificamente?

Um git clonedos repositórios não parece criar as ramificações localmente para ele, embora eu possa vê-las viver sem problemas depois de um empurrão do meu lado.

Além disso, quando eu fiz o ramo originalmente, fiz -b checkout. Isso faz muita diferença?

$ git branch -r
origin/HEAD -> origin/master
origin/daves_branch
origin/discover
origin/master

$ git fetch origin discover
$ git checkout discover

Estes são os comandos que corri. Mas definitivamente não está funcionando.

Quero poder verificar essa ramificação e, em seguida, enviar e confirmar novamente as alterações das ramificações de vários colaboradores ou estações de trabalho .

Você precisa criar uma filial local que rastreie uma filial remota. O comando a seguir criará uma ramificação local chamada daves_branch , rastreando a origem da ramificação remota / daves_branch . Quando você envia suas alterações, a ramificação remota será atualizada.

Para as versões mais recentes do Git:

git checkout --track origin/daves_branch

--tracké uma abreviação de git checkout -b [branch] [remotename]/[branch]onde [remotename] é a origem neste caso e [branch] é duas vezes o mesmo, daves_branch nesse caso.

Para o Git 1.5.6.5, você precisava disso:

git checkout --track -b daves_branch origin/daves_branch

Para o Git 1.7.2.3 e superior, isso é suficiente (pode ter sido iniciado mais cedo, mas esta é a confirmação mais antiga que pude encontrar rapidamente):

git checkout daves_branch

Observe que nas versões recentes do Git, este comando não cria uma ramificação local e coloca você no estado 'desanexado HEAD'. Se você deseja uma filial local, use a --trackopção

Detalhes completos estão aqui: Ramificação 3.5 Git - Ramificações remotas, ramificações de rastreamento

Eu usei fetchseguido por checkout...

git fetch <remote> <rbranch>:<lbranch>
git checkout <lbranch>

... onde <rbranch>está a filial remota ou referência de origem e <lbranch>é a filial local ou referência de destino ainda inexistente que você deseja rastrear e que provavelmente deseja nomear o mesmo nome que filial remota ou referência de origem. Isso é explicado em opções na explicação de .<refspec>

O Git é tão inteligente que conclui automaticamente o primeiro comando se eu tabular após as primeiras letras da ramificação remota. Ou seja, nem preciso nomear o ramo local, o Git copia automaticamente o nome do ramo remoto para mim. Obrigado Git!

Além disso, como mostra a resposta nesta postagem similar do Stack Overflow , se você não nomear a ramificação local fetch, ainda poderá criá-la quando fizer check-out usando o -bsinalizador. Ou seja, git fetch <remote> <branch> seguido por git checkout -b <branch> <remote>/<branch>faz exatamente o mesmo que a minha resposta inicial. E, evidentemente, se o seu repositório tiver apenas um controle remoto, você poderá fazer isso git checkout <branch>depois fetche ele criará uma ramificação local para você. Por exemplo, você acabou de clonar um repositório e deseja verificar ramificações adicionais no controle remoto.

Acredito que parte da documentação do fetchpode ter sido copiada literalmente pull. Em particular, a seção <refspec>em opções é a mesma. No entanto, eu não acredito que fetchisso nunca merge, portanto, se você deixar o lado do cólon de destino vazio, fetch não deverá fazer nada .

NOTA: git fetch <remote> <refspec>é uma abreviação git fetch <remote> <refspec>:que, portanto, não faria nada, mas git fetch <remote> <tag>é a mesma git fetch <remote> <tag>:<tag>que deve copiar o controle remoto <tag>localmente.

Eu acho que isso só é útil se você deseja copiar uma filial remota localmente, mas não necessariamente verificá-la imediatamente. Caso contrário, agora eu usaria a resposta aceita , que é explicada em detalhes na primeira seção da descrição do checkout e mais tarde na seção de opções na explicação de --track, uma vez que é uma linha única. Bem ... uma espécie de one-liner, porque você ainda teria que correr git fetch <remote>primeiro.

FYI: A ordem do <refspecs>(origem: destino) explica o bizarro método anterior ao Git 1.7 para excluir ramificações remotas . Ou seja, não introduza nada no refspec de destino.

Se você estiver tentando "efetuar checkout" de uma nova ramificação remota (que existe apenas no controle remoto, mas não localmente), eis o que você precisará:

git fetch origin
git checkout --track origin/<remote_branch_name>

Isso pressupõe que você deseja buscar da origem . Caso contrário, substitua a origem pelo seu nome remoto .

Para fazer o checkout do myBranch que existe remotamente e não localmente - Isso funcionou para mim:

git fetch --all
git checkout myBranch

Eu recebi esta mensagem:

Branch myBranch set up to track remote branch myBranch from origin
Switched to a new branch 'myBranch'

Use git branch -a(ramificações locais e remotas) ou git branch -r(apenas ramificações remotas) para ver todos os controles remotos e suas ramificações. Você pode fazer um git checkout -t remotes/repo/branchno controle remoto e criar uma filial local.

Há também um comando git-ls-remote para ver todas as referências e tags desse remoto.

O título e a pergunta estão confusos:

• Git buscar ramificação remota
• como meu colega pode puxar esse ramo especificamente.

Se a pergunta for: como posso trabalhar com uma filial remota ou como posso fazer o Git com uma filial remota? , uma solução mais simples é:

Com o Git (> = 1.6.6), você pode usar:

git checkout <branch_name>

Se local <branch_name>não for encontrado, mas existir um ramo de rastreamento em exatamente um controle remoto com um nome correspondente, trate-o como equivalente a:

git checkout -b <branch_name> --track <remote>/<branch_name>

Consulte a documentação do check-out do Git

Para seu amigo:

$ git checkout discover
Branch discover set up to track remote branch discover
Switched to a new branch 'discover'

A maneira mais fácil de fazer isso, pelo menos para mim:

git fetch origin <branchName> # Will fetch the branch locally
git checkout <branchName> # To move to that branch

Usar:

git checkout -b serverfix origin/serverfix

Esta é uma operação bastante comum que o Git fornece a --trackabreviação:

git checkout --track origin/serverfix

De fato, isso é tão comum que existe até um atalho para esse atalho. Se o nome do ramo que você está tentando fazer checkout (a) não existir e (b) corresponder exatamente a um nome em apenas um controle remoto, o Git criará um ramo de rastreamento para você:

git checkout serverfix

Para configurar uma filial local com um nome diferente da filial remota, você pode facilmente usar a primeira versão com um nome diferente de filial local:

git checkout -b sf origin/serverfix

Agora, sua filial local sfserá automaticamente retirada origin/serverfix.

Fonte: Pro Git, 2ª Edição , escrito por Scott Chacon e Ben Straub (corte para facilitar a leitura)

Com este comando simples:

git checkout -b 'your_branch' origin/'remote branch'

Para buscar uma ramificação que existe no controle remoto, a maneira mais simples é:

git fetch origin branchName
git checkout branchName

Você pode ver se ele já existe no controle remoto com:

git branch -r

Isso buscará a ramificação remota no seu local e rastreará automaticamente a ramificação remota.

O que me ajudou foi

1) Para visualizar todas as filiais remotas disponíveis (por exemplo, 'nome da filial remota')

git branch -r

2) Crie uma filial local usando o nome da filial remota

git fetch && git checkout 'remote-branch-name'

Você também pode buscar e fazer check-out da ramificação remota de uma só vez:

git fetch && git checkout the-branch-name

git fetch

git branch -r

git checkout <branch_name>

Eu digitei

git checkout <branch_name>

e pegou

Branch <branch_name> set up to track remote branch <branch_name> from origin.
Switched to a new branch '<branch_name>'

Às vezes, você é solicitado a não mexer com o ramo mestre e trabalhar apenas com o ramo remoto (como me pediram). Então, tudo que você precisa é da ramificação remota.

Portanto, para clonar a ramificação remota sozinha (sem o mestre), faça isso

git clone url --branch remote_branch_name

em que remote_branch_name é o nome da ramificação remota

Por exemplo,

git clone git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git --branch v3.15

Isso garantirá que você clone a ramificação remota na ramificação local com o nome da ramificação remota.

Agora, se você confirmar seu código e enviar por push, o código será enviado apenas para esse ramo.

[Resposta rápida]

Existem muitas alternativas, e meus favoritos são:

- Alternativa 1:

git fetch --all
git checkout YourBranch

Usando essa alternativa, use uma ramificação que existe remotamente, mas não no seu local.

- Alternativa 2:

git checkout -b 'YourBranch' origin/'YourRemote'

Provavelmente, esta é a maneira mais simples.

Digamos que seu controle remoto seja git@xyz.git e você queira a ramificação random_branch. O processo deve ser o seguinte:

1. Primeiro verifique a lista de seus controles remotos

   git remote -v

2. Se você não possui o controle remoto git@xyz.git na saída do comando acima, adicione-o

   git remote add xyz git@xyz.git

3. Agora você pode buscar o conteúdo desse controle remoto

   git fetch xyz

4. Agora faça o checkout do ramo desse controle remoto

   git checkout -b my_copy_random_branch xyz/random_branch

5. Verifique a lista de agências por

   git branch -a

O ramo local my_copy_random_branch rastreará o ramo random_branch do seu controle remoto.

git fetch --all & git checkout <branch name>

git fetch && git checkout <your friend's branch name> deve fazer o truque

Desejo fornecer um comando de uma linha para buscar todas as ramificações remotas no local e alternar para a ramificação local recém-criada desejada:

git fetch && git checkout discover

Depois de executar o comando acima, você receberá a mensagem abaixo:

Switched to a new branch 'discover'
Branch discover set up to track remote branch discover from origin.

A primeira linha indica que mudou para uma nova ramificação - por que novo? Já está lá no controle remoto!

Mas, na verdade, você também deve criá-lo localmente. A ramificação é obtida do índice remoto e criada localmente para você.

Aqui discoverestá um novo ramo que foi criado a partir do ramo remoto do seu repositório discover.

Mas a segunda linha fornece mais informações do que a primeira que nos diz que:

Nossa filial é configurada para rastrear ramificações remotas com o mesmo nome.

Embora git fetch busque todas as filiais no local. Mas se você correr git branchatrás dele, verá apenas masterramificações no local. Por que ?

Porque para cada ramo que você tem no controle remoto, você também deve criá-lo localmente, para segui-lo como git checkout <branchname>fizemos no exemplo acima.

Após executar o git checkoutcomando, você pode executar git branche agora pode ver o ramo:

1. mestre e 2. descobrir em sua lista local.

Se você deseja buscar todas as ramificações remotas, digite apenas:

git fetch --all

Simplesmente tente:

git pull origin your_branch_name

Se você tiver um repositório que foi clonado --depth 1, muitos dos comandos listados não funcionarão. Por exemplo, veja aqui

% git clone --depth 1 https://github.com/repo/code
Cloning into 'code'...
cd code
remote: Counting objects: 1778, done.
remote: Compressing objects: 100% (1105/1105), done.
remote: Total 1778 (delta 87), reused 1390 (delta 58), pack-reused 0
Receiving objects: 100% (1778/1778), 5.54 MiB | 4.33 MiB/s, done.
Resolving deltas: 100% (87/87), done.
Checking connectivity... done.
Checking out files: 100% (1215/1215), done.
% cd code
% git checkout other_branch
error: pathspec 'other_branch' did not match any file(s) known to git.
% git fetch origin other_branch
remote: Counting objects: 47289, done.
remote: Compressing objects: 100% (15906/15906), done.
remote: Total 47289 (delta 30151), reused 46699 (delta 29570), pack-reused 0
Receiving objects: 100% (47289/47289), 31.03 MiB | 5.70 MiB/s, done.
Resolving deltas: 100% (30151/30151), completed with 362 local objects.
From https://github.com/repo/code
 * branch            other_branch-> FETCH_HEAD
% git checkout other_branch
error: pathspec 'other_branch' did not match any file(s) known to git.
%

Nesse caso, eu reclona o repositório, mas talvez haja outras técnicas, por exemplo, git shallow clone (clone --thpth) perde ramificações remotas

Se você já conhece seu ramo remoto dessa forma ...

git remote
=> One
=> Two

e você sabe o nome da filial que deseja fazer o checkout, por exemplo, br1.2.3.4 , e faça

git fetch One
=> returns all meta data of remote, that is, the branch name in question.

Tudo o que resta é fazer o checkout da filial

git checkout br.1.2.3.4

Em seguida, faça novas ramificações com ele.

Os passos são os seguintes;

1. git fetch originou git fetch --all, isso buscará todas as ramificações remotas no seu local e, em seguida, será a segunda opção com a qual você poderá proceder.

2. git checkout --track origin/<The_remote_branch you want to switch over>

Em seguida, trabalhe neste ramo e você poderá verificar se está ou não nesse ramo, digitando

git branch

Ele exibe a filial em que você está atualmente.

git branch <name> --track origin/<name>

Verifique seu .git/configarquivo, principalmente o rastreamento presente na busca desse controle remoto.

[remote "randomRemote"]
    url = git@github.com:someUser/someRepo.git
    fetch = +refs/heads/*:refs/remotes/randomRemote/*

Se estiver heads/*apontando para randomRemote/*, quando você executargit fetch randomRemote , buscará todas as ramificações.

Então você pode apenas fazer checkout desse ramo.

De outra forma,

1. Você precisa adicionar ramificações remotas ao rastreamento usando isso. Verifique o seu .git/configdepois de executar isso. Você vai entender.

   git remote set-branches --add randomRemote randomBranch
   

2. Corra git fetch randomRemote. Isso buscará a ramificação remota.

3. Agora você pode correr git checkout randomBranch.

Você usa 'git pull' para manter seus galhos separados. Usarei os nomes reais do repositório e da ramificação para ajudar, pois é difícil decifrar 'lbranch' e 'rbranch'.

Vamos usar:

git init
git pull git@myteam.unfuddle.com:myteam/tlc daves_branch:refs/remotes/origin/daves_branch

Um comando simples, git checkout remote_branch_nameajudará você a criar uma filial local que possua todas as alterações na filial remota.

git checkout -b branch_name
git pull remote_name branch_name