Como clonar todas as ramificações remotas no Git?


4129

Eu tenho um mastere um developmentramo, ambos enviados para o GitHub . Eu tenho cloned, pulled, e fetched, mas permanecem incapazes de obter outra coisa senão a mastervolta ramo.

Tenho certeza de que estou perdendo algo óbvio, mas li o manual e não estou tendo nenhuma alegria.


133
A resposta aceita aqui ( git branch -a) mostra as ramificações no controle remoto, mas se você tentar verificar alguma delas, estará em um estado 'desanexado HEAD'. A próxima resposta abaixo (a segunda mais votada) responde a uma pergunta diferente (a saber: como puxar todos os ramos e, novamente, isso só funciona para aqueles que você está rastreando localmente). Vários comentários apontam que você pode analisar os git branch -aresultados com um script de shell que rastreia localmente todas as ramificações remotas. Resumo: Não existe uma maneira nativa do git para fazer o que você deseja, e pode não ser uma idéia tão boa assim.
Dia Davis Waterbury

5
Talvez apenas copie a pasta inteira da maneira antiga? scp some_user@example.com:/home/some_user/project_folder ~Não tenho certeza se essa solução funciona para o github ...
snapfractalpop 26/09/12

19
Em vez de dizer "clonei, puxei e busquei", é muito melhor nos mostrar os comandos exatos que você executou.
Bob Gilmore

57
Sempre me surpreende por que "clone" não está no sentido de uma cópia exata. Se for um clone exato, todas as ramificações não devem fazer parte do repositório local? Quero dizer, não é esse o ponto de ser distribuído? Então, quando algo do repositório acabar, você ainda terá uma cópia completa de tudo. Ou é o chamado "remoto" que já faz parte do repositório local?
huggie

21
Vendo todas as votações, respostas, comentários sobre respostas e o número de visualizações incompreensível, acho que é hora de o git adicionar um comando para fazer isso. E certo, você é @ huggie, exatamente meus pensamentos.
Sнаđошƒаӽ

Respostas:


4557

Primeiro, clone um repositório Git remoto e um CD nele:

$ git clone git://example.com/myproject
$ cd myproject

Em seguida, observe as ramificações locais no seu repositório:

$ git branch
* master

Mas existem outros ramos escondidos no seu repositório! Você pode vê-los usando o-a bandeira:

$ git branch -a
* master
  remotes/origin/HEAD
  remotes/origin/master
  remotes/origin/v1.0-stable
  remotes/origin/experimental

Se você quiser apenas dar uma olhada rápida em um ramo upstream, pode verificar diretamente:

$ git checkout origin/experimental

Mas se você quiser trabalhar nesse ramo, precisará criar um ramo de rastreamento local, que é feito automaticamente por:

$ git checkout experimental

e você verá

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

Essa última linha lança algumas pessoas: "Novo ramo" - hein? O que realmente significa é que a ramificação é retirada do índice e criada localmente para você. o linha anterior é realmente mais informativa, pois indica que a ramificação está sendo configurada para rastrear a ramificação remota, o que geralmente significa a ramificação origin / branch_name

Agora, se você olhar para suas filiais locais, é isso que você verá:

$ git branch
* experimental
  master

Você pode rastrear mais de um repositório remoto usando git remote .

$ git remote add win32 git://example.com/users/joe/myproject-win32-port
$ git branch -a
* master
  remotes/origin/HEAD
  remotes/origin/master
  remotes/origin/v1.0-stable
  remotes/origin/experimental
  remotes/win32/master
  remotes/win32/new-widgets

Neste ponto, as coisas estão ficando muito loucas, então corra gitkpara ver o que está acontecendo:

$ gitk --all &

119
Como alguém pode criar automaticamente todos os ramos remotos, por exemplo, experimental por origem / experimental?
Cristian Ciupitu 4/06/2009

54
Cristian: Eu sempre criava um ramo 'foo' para cada ramo 'origin / foo', mas isso levou a dois problemas: (1) acabei com muitos ramos de rastreamento realmente obsoletos que eram muitos commits por trás do ramo remoto correspondente e (2) nas versões mais antigas do git, a execução de 'git push' tentaria enviar todas as minhas ramificações locais para um controle remoto, mesmo quando essas ramificações estavam obsoletas. Portanto, agora eu só mantenho ramificações locais para itens que estou desenvolvendo ativamente e acesso as ramificações origin / * diretamente se precisar de informações sobre elas. (Dito isto, você poderia usar um shell script para analisar '-a git branch'.)
emk

49
"git fetch <nome-original> <nome-filial>" reduz a ramificação localmente para você.

137
Boa resposta, mas meio que perde a pergunta. Eu estava procurando por uma fila para verificar todas as filiais remotas.
precisa

32
A pergunta era sobre a clonagem de todas as ramificações remotas, não a verificação delas. E, como observei acima, você realmente não deseja criar mais ramificações de rastreamento local do que o necessário, porque, quando ficam realmente obsoletas, podem causar dores de cabeça.
28/10/10

822

Se você tiver muitas ramificações remotas que deseja buscar de uma só vez, faça:

$ git pull --all

Agora você pode fazer o checkout de qualquer ramificação conforme necessário, sem acessar o repositório remoto.


12
Se eu clico no git, tenho a ramificação principal localmente e 10 ramificações "remotas". Portanto, esta resposta de Gabe foi muito útil e responde à pergunta.
basZero

38
isso só buscar filiais remotas que foram localmente não acrescentou qualquer filial remota
jujule

33
O primeiro comando é redundante. Simplesmente git pull --allfará o mesmo - ele não será buscado duas vezes. E a infosec812 está certa de que isso não responde à pergunta de qualquer maneira. Eu me pergunto como isso conseguiu tantos votos positivos.
Sven Marnach 06/04/12

6
Depois que fiz git remote updatee tentei git branch, só vi filiais locais. Mas, se o fizer git branch -a, agora posso ver as ramificações remotas e posso fazer a git pull <branchname>para obter a ramificação que desejo. - Cheguei a essa pergunta em uma pesquisa no Google e esta resposta resolve meu problema.
WNRosenberg 31/01

38
Isso não ajuda em nada, não puxa nenhuma ramificação remota além da existente.
Avinash R

446

Esse script do Bash me ajudou:

#!/bin/bash
for branch in $(git branch --all | grep '^\s*remotes' | egrep --invert-match '(:?HEAD|master)$'); do
    git branch --track "${branch##*/}" "$branch"
done

Ele criará ramificações de rastreamento para todas as ramificações remotas, exceto o mestre (que você provavelmente obteve do comando clone original). Eu acho que você ainda pode precisar fazer uma

git fetch --all
git pull --all

para ter certeza.

Um exemplo : git branch -a | grep -v HEAD | perl -ne 'chomp($_); s|^\*?\s*||; if (m|(.+)/(.+)| && not $d{$2}) {print qq(git branch --track $2 $1/$2\n)} else {$d{$_}=1}' | csh -xfs
Como sempre: teste sua configuração antes de copiar o universo rm -rf como o conhecemos

Créditos para one-liner vão para o usuário cfi


19
Isso está quase perto de ser uma solução perfeita. A única coisa que melhoraria seria se essa funcionalidade fosse incorporada como uma opção no git.
precisa

51
"Um liner": git branch -a | grep -v HEAD | perl -ne 'chomp($_); s|^\*?\s*||; if (m|(.+)/(.+)| && not $d{$2}) {print qq(git branch --track $2 $1/$2\n)} else {$d{$_}=1}' | csh -xfs Como de costume: teste na sua configuração antes de copiarrm -rf universe as we know it
TPI

4
Este comando cria os ramos de recursos remotos como ramos normais (não ramos de recursos) - como consertar isso?
Alex2php

4
se você tiver problemas com "/" nos nomes das filiais, há uma solução abaixo usando um alias do git. ver resposta por "ninguém" em "respondeu 15 de maio de 13 às 11:02"
wemu 12/01

8
Eu estou aparando apenas remotes/origin/para preservar namespaces:for BRANCH in $(git branch -a | grep remotes | grep -v HEAD | grep -v master); do git branch --track "${BRANCH#remotes/origin/}" "${BRANCH}"; done
kgadek

348

O uso da --mirroropção parece copiar as remoteramificações de rastreamento corretamente. No entanto, ele configura o repositório como um repositório simples, portanto, você deve transformá-lo novamente em um repositório normal posteriormente.

git clone --mirror path/to/original path/to/dest/.git
cd path/to/dest
git config --bool core.bare false
git checkout anybranch

Referência: FAQ do Git: Como clonar um repositório com todos os ramos rastreados remotamente?


7
Você sabe que isso realmente parece ser uma resposta muito boa, embora não tenha votos. Existem armadilhas para fazer dessa maneira? Eu tive que fazer checkout explicitamente de uma ramificação depois de executar esses comandos.
loop

27
Isso combinado com o git push --mirror é exatamente o que eu precisava para criar uma duplicata exata de um repositório remoto do git ao passar do github.com para uma instalação corporativa do github. Obrigado!
Jacob Fike

3
@Dave: adicione um git checkoutcomando final como último para finalizar a compra do cabeçalho da ramificação atual no repositório clonado. Esta é uma ótima resposta, de longe a melhor. Seja corajoso, eventualmente, vamos levá-lo ao topo :-) #
1126

3
@ Dave: Hm. Estou pensando duas vezes: --mirror faz mais do que apenas configurar todos os ramos como sendo rastreados. Ele copia todos os árbitros da origem e o subsequente git remote updatefará isso novamente. Comportamento de mudanças de tração. Volto a acreditar que a cópia completa requer um script de uma linha.
Cfi

5
git clone --mirroré muito bom para fazer backup de seus repositórios git ^ _ ^
TrinitronX

220

Você pode facilmente mudar para um ramo sem usar a sintaxe "git checkout -b somebranch origin / somebranch". Você pode apenas fazer:

git checkout somebranch

O Git fará automaticamente a coisa certa:

$ git checkout somebranch
Branch somebranch set up to track remote branch somebranch from origin.
Switched to a new branch 'somebranch'

O Git verificará se uma ramificação com o mesmo nome existe em exatamente um controle remoto e, se existir, a rastreará da mesma maneira como se você tivesse especificado explicitamente que é uma ramificação remota. Na página de manual do git-checkout do Git 1.8.2.1:

Se <branch> não for encontrado, mas existir um ramo de rastreamento em exatamente um controle remoto (chame-o <remote>) com um nome correspondente, trate como equivalente a

$ git checkout -b <branch> --track <remote>/<branch>

1
Portanto, se o nome da ramificação você checkoutfor idêntico ao nome da ramificação remota, tudo após o "/", o git criará uma ramificação com o mesmo nome, tudo após o "/", "tracking" desse controle remoto ? E por rastreamento, queremos dizer: git push, git pull, etc. será feito naquele remoto? Se isso estiver correto, expanda sua resposta com mais informações, porque eu concordo com @Daniel, essa resposta merece mais rep.
Gerard Roche

5
@BullfrogBlues, a resposta para todas as suas perguntas parece ser sim (estou usando o git v1.7.7.4). Concordo que esse comportamento deve ser mais conhecido. (Não está no manual para esta versão do git.) Na verdade, eu não gosto desse comportamento, prefiro receber um erro e preciso dizer git checkout --track origin/somebranchexplicitamente.
precisa saber é o seguinte

3
@dubiousjim: Na verdade, isso está no manual. git-checkout (1) diz: "Se <branch> não for encontrado, mas existir um ramo de rastreamento em exatamente um controle remoto (chame-o <remote>) com um nome correspondente, trate como equivalente a 'git checkout -b <branch > --track <remote> / <branch> '"(Git V.1.8.1.1).
sleske

O que precisamos é de $ git pull * <remote> / * - onde "*" é um curinga, portanto, ele puxa todas as ramificações, incluindo as que ainda não estão no sistema local. Como fazer isso? Devemos realmente fazer checkout / pull de cada ramo apenas para obter o código extraído para o nosso sistema local?
21917 JosephK

98

A respeito de,

$ git checkout -b origem experimental / experimental

usando

$ git checkout -t origin/experimental

ou o mais detalhado, mas mais fácil de lembrar

$ git checkout --track origin/experimental

pode ser melhor em termos de rastreamento de um repositório remoto.


Então você quer dizer que a segunda forma é apenas mais fácil de lembrar e não há outra diferença?
Aderchox 18/07/19

79

A busca que você está fazendo deve obter todas as ramificações remotas, mas não criará ramificações locais para elas. Se você usa o gitk, verá as ramificações remotas descritas como "remotes / origin / dev" ou algo semelhante.

Para criar uma filial local com base em uma filial remota, faça algo como:

git checkout -b dev refs / remotes / origin / dev

O que deve retornar algo como:

Desenvolvedor de filial configurado para rastrear refs / remotes / origin / dev.
Mudou para um novo ramo "dev"

Agora, quando você estiver no ramo de desenvolvimento, "git pull" atualizará seu desenvolvedor local para o mesmo ponto que o ramo de desenvolvimento remoto. Observe que ele buscará todos os galhos, mas puxe apenas o que você está no topo da árvore.


14
Você não precisa de referências / controles remotos aqui. git checkout -b dev origin / dev funcionará bem.
EMK

3
Isso sempre funciona: git checkout -b newlocaldev --track origin/dev. Se você quiser que a ramificação local tenha o mesmo nome que a remota, e a remota não tiver um nome complicado, você pode omitir o -b newlocaldev. Com a branch.autosetupmergeconfiguração padrão , e supondo que você não tenha uma ramificação local nomeada dev, esses dois comandos podem fazer a mesma coisa: git checkout -b dev origin/deve simplesmente git checkout dev. Por fim, git checkout origin/devnão cria uma nova ramificação, apenas o coloca no estado HEAD desanexado.
precisa saber é o seguinte

O que acontece quando o controle remoto não existe mais, mas o Git é burro demais para reconhecer que foi excluído? Isso pressupõe que você atualizou e git branch -acontinua a listá-lo como uma filial remota.
JWW

E fazemos isso para dezenas de filiais?
21917 JosephK

59

Quando você faz o "git clone git: // location", todas as ramificações e tags são buscadas.

Para trabalhar em cima de uma ramificação remota específica, supondo que seja a origem remota:

git checkout -b branch origin/branchname

2
Agradeço sua observação "todas as ramificações e tags foram buscadas". Eu ia comentar que sua resposta estava errada, mas verifiquei e descobri que você está perfeitamente certo. Então, de certa forma, você forneceu a resposta mais curta - se você clonou, já a possui. Agradável. Pode-se tentar acrescentar: tente $ git branch -aaprender quais ramificações remotas já estão disponíveis.
Jan Vlcinsky

Dê uma olhada na resposta que eu postei também. Isso pode ser útil se você souber que deseja trabalhar localmente em muitas das ramificações remotas e não precisar verificá-las uma a uma.
precisa

Você pode me explicar qual é a diferença entre git checkout -b master origin/mastere git checkout --track origin/masterpor favor?
Aderchox 18/07/19

1
@aderchox Hoje em dia, acho que não.
Elmarco 02/08/19

58

Use aliases. Embora não haja nenhuma linha nativa do Git, você pode definir seu próprio como

git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'

e depois use-o como

git clone-branches

Obrigado. Na verdade, isso clona todas as ramificações remotas, ao contrário de várias das outras respostas
FearlessHyena

50

Por que você vê apenas "mestre"

git clonebaixa todas as ramificações remotas, mas ainda as considera "remotas", mesmo que os arquivos estejam localizados no seu novo repositório. Há uma exceção a isso: o processo de clonagem cria uma ramificação local chamada "mestre" a partir da ramificação remota chamada "mestre". Por padrão, git branchmostra apenas ramificações locais, e é por isso que você vê apenas "mestre".

git branch -amostra todas as ramificações, incluindo ramificações remotas .


Como obter filiais locais

Se você realmente deseja trabalhar em uma ramificação, provavelmente desejará uma versão "local" dela. Para simplesmente criar ramificações locais a partir de ramificações remotas (sem retirá-las e, assim, alterar o conteúdo do seu diretório de trabalho) , você pode fazer o seguinte:

git branch branchone origin/branchone
git branch branchtwo origin/branchtwo
git branch branchthree origin/branchthree

Neste exemplo, branchoneé o nome de uma ramificação local na qual você está criando, com base origin/branchone; se você deseja criar ramificações locais com nomes diferentes, pode fazer o seguinte:

git branch localbranchname origin/branchone

Depois de criar uma ramificação local, você poderá vê-la com git branch(lembre-se, você não precisa -aver ramificações locais).


Se origin/branchoneexistir, você também pode usar apenas git checkout branchonepara criar uma filial local com o mesmo nome e configurá-la para rastrear remotamente.
Evan

47

Isso não é muito complicado, as etapas muito simples e diretas são as seguintes;

git fetch origin Isso trará todas as ramificações remotas para o seu local.

git branch -a Isso mostrará todas as ramificações remotas.

git checkout --track origin/<branch you want to checkout>

Verifique se você está na ramificação desejada pelo seguinte comando;

git branch

A saída será assim;

*your current branch 
some branch2
some branch3 

Observe o sinal * que indica a ramificação atual.


1
Obrigado suraj. A razão porque não foi votado muito. E o ans não é aceito pelo questionador.
Sam

A "origem de busca do git" não trouxe nenhuma das ramificações remotas para o meu local - ou elas estão ocultas em algum lugar? Ler todas as respostas acima me deu dor de cabeça. Estamos procurando por "git buscar todos os ramos para o local". Deve haver uma maneira de além dos scripts bash para fazer isso.
JosephK

1
Logo após você executar "git fetch origin", ele mostrará a saída como esta em seu terminal - "* [novo ramo] branch_name -> origin / branch_name", mas quando você executa o "git branch", ele mostra apenas o local branches, então, para ver todos os branches, você pode "git branch -a" e, para alternar para o branch remoto, é necessário executar "git checkout --track origin / <branch que você deseja fazer checkout>". Espero que isto ajude. :-)
Sam

4
Suraj, porque a pergunta era: como "clonar todas as ramificações remotas" - não como atualizar manualmente uma de cada vez. Parece que não há resposta para a pergunta real - apenas maneiras de digitar muito se você tiver muitos ramos.
19417 JosephK

47

Antes tarde do que nunca, mas aqui está a melhor maneira de fazer isso:

mkdir repo
cd repo
git clone --bare path/to/repo.git .git
git config --unset core.bare
git reset --hard

Neste ponto, você tem uma cópia completa do repositório remoto com todas as suas ramificações (verifique com git branch). Você pode usar em --mirrorvez de --barese o seu repo remoto tiver controles remotos próprios.


Ocorreu um erro durante as edições aqui. Agora, essa resposta não faz sentido. O " --bare" mencionado na última frase não existe na lista de comandos fornecida.
Cerran

tirando da resposta de Dave abaixo. Usar 'git config --bool core.bare false' em vez de 'git config unset core.bare' parece fazer o trabalho.
Vorlon confuso

Eu tenho o error: key does not contain a section: unset. A resposta do Dave funciona melhor.
olibre

Na git config --unset core.bareverdade, é ... Para mim, essa parece a solução mais limpa de todas as apresentadas nas respostas aqui. Uma pena que tem tão poucas upvotes ...
Dirk Hillbrecht

1
Obrigado @ChrisSim Concordo git config --bool core.bare false. É por isso que recomendo a resposta de Dave . O que você acha da resposta de Dave ? Cheers
olibre

39

Apenas faça o seguinte:

$ git clone git://example.com/myproject
$ cd myproject
$ git checkout branchxyz
Branch branchxyz set up to track remote branch branchxyz from origin.
Switched to a new branch 'branchxyz'
$ git pull
Already up-to-date.
$ git branch
* branchxyz
  master
$ git branch -a
* branchxyz
  master
  remotes/origin/HEAD -> origin/master
  remotes/origin/branchxyz
  remotes/origin/branch123

Veja, 'git clone git: //example.com/myprojectt' busca tudo, mesmo os ramos, você só precisa fazer check-out deles, e seu ramo local será criado.


25

Você só precisa usar o "git clone" para obter todas as ramificações.

git clone <your_http_url>

Mesmo que você veja apenas branch master, você pode usar "git branch -a" para ver todos os branches.

git branch -a

E você pode mudar para qualquer ramo que você já possui.

git checkout <your_branch_name>

Não se preocupe, pois depois de "git clone", você não precisa se conectar ao repositório remoto, "git branch -a" e "git checkout" podem ser executados com êxito quando você fechar o wifi. Portanto, está provado que, quando você faz o "git clone", ele já copiou todos os ramos do repositório remoto. Depois disso, você não precisa do repositório remoto, seu local já possui todos os códigos das agências.


Resposta muito clara aqui. Muita gente confusa sobre esse tópico.
XMAN 20/1018

Gostaria de destacar sua afirmação "pode ​​ser executada com êxito quando você fecha o wifi". O "git clone" realmente resulta em um repositório contendo todas as ramificações.
bvgheluwe

Uma ótima resposta clara e direta.
Amr

24

A git clonedeve copiar todo o repositório. Tente cloná-lo e, em seguida, execute git branch -a. Ele deve listar todos os ramos. Se você deseja mudar para a ramificação "foo" em vez de "master", use git checkout foo.


1
Você pode executar comandos git com ou sem o hífen. Tanto o "git-branch" quanto o "git branch" funcionarão.
22678 Peter Boughton

21
Talvez essa resposta tenha sido dada há muito tempo quando o git funcionou de maneira diferente, mas acho que é enganoso hoje. git clonefaz o download de todas as ramificações remotas, mas faz apenas uma ramificação local do mestre. Como git branchapenas mostra ramificações locais, você também precisa git branch -aver ramificações remotas.
Cerran

Obrigado. Esse é um tipo de comportamento padrão estranho do IMO. Vou atribuir isso a mais testemunhas enigmáticas. Se ele baixou os branches, por que os ocultaria ao chamar o git branch?
Adam Hughes

1
@ Cerran, obrigado; Atualizei minha resposta de acordo.
MattoxBeckman

"faz o download de todas as ramificações remotas, mas faz apenas uma ramificação local do mestre". Preciso de ajuda para entender isso. Parece que o git clone NÃO clona nenhuma ramificação, exceto master, pois quando você "git branch -a" mostra que a ramificação "develop" está apenas em "remotes / origin / develop". Isso deve estar dizendo que você não tem esse ramo em nenhum lugar localmente, ele existe apenas atualmente na origem, certo?
John Little

19

Use minha ferramenta git_remote_branch (você precisa do Ruby instalado na sua máquina). Ele foi desenvolvido especificamente para facilitar as manipulações remotas de ramificações.

Cada vez que realiza uma operação em seu nome, ela é impressa em vermelho no console. Com o tempo, eles finalmente aderem ao seu cérebro :-)

Se você não quiser que o grb execute comandos em seu nome, use o recurso 'explicação'. Os comandos serão impressos no seu console em vez de executados por você.

Por fim, todos os comandos têm aliases, para facilitar a memorização.

Observe que este é um software alfa ;-)

Aqui está a ajuda quando você executa o grb help:

git_remote_branch versão 0.2.6

  Uso:

  grb criar nome_da_ ramificação [origin_server] 

  grb publica branch_name [origin_server] 

  grb renomear branch_name [origin_server] 

  grb excluir nome_da_ filial [origin_server] 

  faixa grb nome_da_ filial [origin_server] 



  Notas:
  - Se origin_server não for especificado, o nome 'origin' será assumido 
    (padrão do git)
  - A funcionalidade de renomeação renomeia a ramificação atual

  O meta-comando de explicação: você também pode anexar qualquer comando com o comando 
palavra-chave 'explicar'. Em vez de executar o comando, git_remote_branch
simplesmente emitirá a lista de comandos que você precisa executar para realizar 
esse objetivo.

  Exemplo: 
    grb explicar criar
    grb explicar criar my_branch github

  Todos os comandos também possuem aliases:
  criar: criar, novo
  delete: excluir, destruir, matar, remover, rm
  publicar: publicar, remotizar
  renomear: renomear, rn, mv, mover
  rastrear: rastrear, seguir, pegar, buscar

6
Palavra aos sábios: Parece que este projeto foi abandonado na época em que esta resposta foi publicada. Não consigo encontrar nenhuma atualização depois de 2008. Caveat emptor e tudo isso. Se eu estiver errado, espero que alguém edite e forneça um ponteiro atual, porque eu adoraria ter uma ferramenta como essa à mão.
Bradheintz

@bradheintz verifique esta resposta, ele cria um alias do git: stackoverflow.com/a/16563327/151841
user151841

19

todas as respostas que vi aqui são válidas, mas há uma maneira muito mais limpa de clonar um repositório e puxar todos os ramos de uma só vez.

Quando você clona um repositório, todas as informações dos ramos são realmente baixadas, mas os ramos ficam ocultos. Com o comando

$ git branch -a

você pode mostrar todas as ramificações do repositório e com o comando

$ git checkout -b branchname origin/branchname

você pode "baixá-los" manualmente, um de cada vez.


No entanto, quando você deseja clonar um repositório com muitos ramos, todas as formas ilustradas acima são longas e tediosas em relação a uma maneira muito mais limpa e rápida que mostrarei, embora seja um pouco complicado. Você precisa de três etapas para fazer isso:

  1. Primeiro passo

crie uma nova pasta vazia em sua máquina e clone uma cópia espelhada da pasta .git do repositório:

$ cd ~/Desktop && mkdir my_repo_folder && cd my_repo_folder
$ git clone --mirror https://github.com/planetoftheweb/responsivebootstrap.git .git

o repositório local dentro da pasta my_repo_folder ainda está vazio, existe apenas uma pasta .git oculta agora que você pode ver com um comando "ls -alt" no terminal.

  1. Segundo passo

alterne este repositório de um repositório vazio (vazio) para um repositório regular alternando o valor booleano "bare" das configurações do git para false:

$ git config --bool core.bare false
  1. Terceiro passo

Pegue tudo o que está dentro da pasta atual e crie todas as ramificações na máquina local, tornando isso um repositório normal.

$ git reset --hard

Então agora você pode apenas digitar o comando "git branch" e pode ver que todos os ramos foram baixados.

Essa é a maneira rápida em que você pode clonar um repositório git com todos os ramos de uma só vez, mas não é algo que você deseja fazer para cada projeto dessa maneira.


Não gosto do uso da palavra "baixar" em ... "faça o download" manualmente, um de cada vez . De fato, todas as informações já foram baixadas após a clonagem do repositório. A única coisa que você precisa fazer é criar ramificações de rastreamento local (o que também é possível quando está offline, o que prova que todas as informações estão no repositório).
bvgheluwe

@bvgheluwe é por isso que está entre aspas.
FedericoCapaldo

15

A clonagem de um repositório local não funcionará com o git clone & git fetch: muitos ramos / tags permanecerão não buscados.

Para obter um clone com todas as ramificações e tags.

git clone --mirror git://example.com/myproject myproject-local-bare-repo.git

Para obter um clone com todas as ramificações e tags, mas também com uma cópia de trabalho:

git clone --mirror git://example.com/myproject myproject/.git
cd myproject
git config --unset core.bare
git config receive.denyCurrentBranch updateInstead
git checkout master

13

OK, quando você clona seu repositório, você tem todos os ramos lá ...

Se você apenas faz git branch, eles estão meio que escondidos ...

Portanto, se você quiser ver o nome de todos os ramos, basta adicionar uma --allbandeira como esta:

git branch --all ou git branch -a

Se você apenas fizer o checkout da filial, terá tudo o que precisa.

Mas e se o ramo criado por outra pessoa após você clonar?

Nesse caso, basta fazer:

git fetch

e verifique todos os ramos novamente ...

Se você deseja buscar e fazer checkout ao mesmo tempo, pode:

git fetch && git checkout your_branch_name

Também criou a imagem abaixo para você simplificar o que eu disse:

git branch --all para obter todos os branches


3
Há uma diferença entre "você tem" e "você vê". O git branch -all NÃO listará mais as ramificações remotas quando você remover o repositório remoto.
Gustave

12

Olhando para uma das respostas à pergunta, notei que é possível reduzi-la:

for branch in  `git branch -r | grep -v 'HEAD\|master'`; do  
 git branch --track ${branch##*/} $branch;
done

Mas cuidado, se um dos ramos remotos for nomeado como, por exemplo, admin_master, não será baixado!

Graças ao bigfish pela ideia original


Você pode melhorar a regex, ou talvez usar o Awk em vez de grep, para melhorar o filtro e evitar falsos positivos.
Tripleee

todos os ramos são 'origin \ my_branch_name', que não é definitivamente o que eu quero.
Sнаđошƒаӽ

Eu nunca vi o construto $ {branch ## * /} antes - parece realmente útil - alguma idéia de onde posso descobrir mais sobre isso? não consigo encontrar sob bash em qualquer lugar. Valeu.
SaminOz


10

Para copiar e colar na linha de comando:

git checkout master ; remote=origin ; for brname in `git branch -r | grep $remote | grep -v master | grep -v HEAD | awk '{gsub(/^[^\/]+\//,"",$1); print $1}'`; do git branch -D $brname ; git checkout -b $brname $remote/$brname ; done ; git checkout master

Para mais legibilidade:

git checkout master ;
remote=origin ;
for brname in `
    git branch -r | grep $remote | grep -v master | grep -v HEAD 
    | awk '{gsub(/^[^\/]+\//,"",$1); print $1}'
`; do
    git branch -D $brname ;
    git checkout -b $brname $remote/$brname ;
done ;
git checkout master


Isso vai:

  1. confira o master (para que possamos excluir o ramo em que estamos)
  2. selecione controle remoto para finalizar a compra (altere para qualquer controle remoto que você tenha)
  3. percorrer todas as ramificações do controle remoto, exceto master e HEAD
    1. excluir ramificação local (para que possamos verificar ramificações atualizadas à força)
    2. confira ramificação do controle remoto
  4. confira mestre (por uma questão de)

Com base na resposta do VonC .


10

Eu escrevi essas pequenas funções do Powershell para poder verificar todos os meus ramos git, que estão remotos na origem.

Function git-GetAllRemoteBranches {
     iex "git branch -r"                       <# get all remote branches #> `
     | % { $_ -Match "origin\/(?'name'\S+)" }  <# select only names of the branches #> `
     | % { Out-Null; $matches['name'] }        <# write does names #>
}


Function git-CheckoutAllBranches {
    git-GetAllRemoteBranches `
        | % { iex "git checkout $_" }          <# execute ' git checkout <branch>' #>
}

Mais funções git podem ser encontradas no repositório de configurações do git


9

Aqui está uma resposta que usa awk. Esse método deve ser suficiente se usado em um novo repositório.

git branch -r | awk -F/ '{ system("git checkout " $NF) }'

As ramificações existentes serão simplesmente retiradas ou declaradas como já nela, mas filtros podem ser adicionados para evitar conflitos.

Também pode ser modificado para chamar um git checkout -b <branch> -t <remote>/<branch>comando explícito .

Esta resposta segue Nikos C. 's idéia .


Como alternativa, podemos especificar a ramificação remota. Isto é baseado em murphytalk 's resposta .

git branch -r | awk '{ system("git checkout -t " $NF) }'

Ele lança mensagens de erro fatais em conflitos, mas eu as vejo inofensivas.


Ambos os comandos podem ser alternativos.

Usando a resposta de ninguém como referência, podemos ter os seguintes comandos para criar os aliases:

git config --global alias.clone-branches '! git branch -r | awk -F/ "{ system(\"git checkout \" \$NF) }"'
git config --global alias.clone-branches '! git branch -r | awk "{ system(\"git checkout -t \" \$NF) }"'

Pessoalmente eu usaria track-allou track-all-branches.


Só queria te agradecer. Isso funcionou perfeitamente e não sofre de vários problemas relacionados à clonagem de um
repositório vazio

8

Eu precisava fazer exatamente o mesmo. Aqui está o meu script Ruby .

#!/usr/bin/env ruby

local = []
remote = {}

# Prepare
%x[git reset --hard HEAD]
%x[git checkout master] # Makes sure that * is on master.
%x[git branch -a].each_line do |line|
  line.strip!
  if /origin\//.match(line)
     remote[line.gsub(/origin\//, '')] = line
   else
     local << line
   end
end
# Update 
remote.each_pair do |loc, rem|
  next if local.include?(loc)
  %x[git checkout --track -b #{loc} #{rem}]
end
%x[git fetch]

Veja a resposta que eu postei mais abaixo, para evitar a execução desse script.
precisa

8

Nenhuma dessas respostas foi suficiente, exceto o usuário que ninguém está no caminho certo.

Eu estava tendo problemas para mover um repositório de um servidor / sistema para outro. Quando eu clonei o repositório, ele criou apenas uma ramificação local para mestre. Por isso, quando fui pressionado para o novo controle remoto, apenas a ramificação principal foi enviada.

Então eu achei esses dois métodos MUITO úteis. Espero que eles ajudem alguém.

Método 1:

git clone --mirror OLD_REPO_URL
cd new-cloned-project
mkdir .git
mv * .git
git config --local --bool core.bare false
git reset --hard HEAD
git remote add newrepo NEW_REPO_URL
git push --all newrepo
git push --tags newrepo

Método 2:

git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'
git clone OLD_REPO_URL
cd new-cloned-project
git clone-branches
git remote add newrepo NEW_REPO_URL
git push --all newrepo
git push --tags newrepo

8

git clone --mirror no repositório original funciona bem para isso.

git clone --mirror /path/to/original.git
git remote set-url origin /path/to/new-repo.git
git push -u origin

7

O Git geralmente (quando não especificado) busca todas as ramificações e / ou tags (refs, consulte:) git ls-refsde um ou mais outros repositórios junto com os objetos necessários para completar seus históricos. Em outras palavras, ele busca os objetos que são alcançáveis ​​pelos objetos que já foram baixados. Veja: O que git fetchrealmente faz?

Às vezes, você pode ter ramificações / tags que não estão diretamente conectadas à atual, então git pull --all/ git fetch --allnão ajudará nesse caso, mas você pode listá-las da seguinte forma:

git ls-remote -h -t origin

e buscá-los manualmente, conhecendo os nomes das referências.

Então, para buscar todos eles , tente:

git fetch origin --depth=10000 $(git ls-remote -h -t origin)

O --depth=10000parâmetro pode ajudar se você tiver um repositório raso.

Em seguida, verifique todas as suas ramificações novamente:

git branch -avv

Se o procedimento acima não ajudar, você precisará adicionar ramificações ausentes manualmente à lista rastreada (pois elas se perderam de alguma forma):

$ git remote -v show origin
...
  Remote branches:
    master      tracked

por git remote set-brancheslike:

git remote set-branches --add origin missing_branch

para que apareça abaixo da remotes/originbusca:

$ git remote -v show origin
...
  Remote branches:
    missing_branch new (next fetch will store in remotes/origin)
$ git fetch
From github.com:Foo/Bar
 * [new branch]      missing_branch -> origin/missing_branch

Solução de problemas

Se você ainda não conseguir nada além da ramificação principal, verifique o seguinte:

  • Verifique seus controles remotos ( git remote -v), por exemplo
    • Validar que git config branch.master.remoteé origin.
    • Verifique se originaponta para o URL correto via: git remote show origin(veja esta postagem ).

7

No início de 2017, a resposta neste comentário funciona:

git fetch <origin-name> <branch-name>derruba o ramo para você. Embora isso não puxe todas as ramificações de uma só vez, você pode executar essa ramificação por singularidade.


Isso requer que você busque cada ramificação uma por vez. Não é muito bom se você tiver muitos galhos.
precisa

6

Aqui está outro comando curto de uma linha que cria ramificações locais para todas as ramificações remotas:

(git branch -r | sed -n '/->/!s#^  origin/##p' && echo master) | xargs -L1 git checkout

Também funciona corretamente se o rastreamento de ramificações locais já estiver criado. Você pode chamá-lo após o primeirogit clone ou a qualquer momento depois.

Se você não precisar fazer o mastercheck-out da ramificação após a clonagem, use

git branch -r | sed -n '/->/!s#^  origin/##p'| xargs -L1 git checkout
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.