repositorio - listar branches git




Como clonar todos os ramos remotos no Git? (20)

Use comandos que você possa lembrar

Estou usando o Bitbucket, um Repository Hosting Service da Atlassian. Então eu tento seguir seus documentos. E isso funciona perfeitamente para mim. Com os seguintes comandos fáceis e curtos, você pode verificar sua ramificação remota.

No primeiro clone seu repositório, então mude para a pasta de destino. E por último, mas não menos importante, busca e saída:

git clone <repo> <destination_folder>
cd <destination_folder>
git fetch && git checkout <branch>

É isso aí. Aqui um pequeno exemplo do mundo real:

git clone https://[email protected]/team/repository.git project_folder
cd project_folder
git fetch && git checkout develop

Você encontrará informações detalhadas sobre os comandos nos documentos: Comando Clone , Comando Fetch , Comando Checkout

Eu tenho um master e um ramo de development , ambos enviados para o GitHub . Eu clone , pull ed e fetch ed, mas continuo sem conseguir recuperar nada além do branch master .

Tenho certeza de que estou sentindo falta de algo óbvio, mas li o manual e não estou nem um pouco satisfeito.


Por que você só vê "mestre"

git clone download de todos os ramos remotos remotos, mas ainda os considera "remotos", mesmo que os arquivos estejam localizados em seu novo repositório. Há uma exceção a isso, que é que o processo de clonagem cria uma ramificação local chamada "master" da ramificação remota chamada "master". Por padrão, a git branch mostra apenas ramificações locais, e é por isso que você só vê "mestre".

git branch -a mostra todas as filiais, incluindo filiais remotas .

Como obter filiais locais

Se você realmente quiser trabalhar em um ramo, provavelmente precisará de uma versão "local" dele. Para simplesmente criar ramificações locais a partir de ramificações remotas (sem verificá-las e, assim, alterar o conteúdo do seu diretório de trabalho) , você pode fazer isso assim:

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

Neste exemplo, branchone é o nome de um branch local que você está criando com base em origin/branchone ; Se você quiser criar ramificações locais com nomes diferentes, você pode fazer isso:

git branch localbranchname origin/branchone

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


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.


Apenas faça isso:

$ 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

Você vê, 'git clone git: //example.com/myprojectt' busca tudo, até mesmo as ramificações, você só precisa fazer o checkout delas, então sua ramificação local será criada.


Isso não é muito complicado, passos muito simples e diretos são os seguintes;

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

git branch -a Isso mostrará todos os ramos remotos.

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

Verifique se você está no ramo desejado pelo seguinte comando;

git branch

A saída vai gostar disso;

*your current branch 
some branch2
some branch3 

Observe o sinal * que indica o ramo atual.


Melhor 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 --mirror invés de --bare se seu repo remoto tiver seus próprios remotos.


Olhando para uma das respostas à pergunta, percebi que é possível encurtá-la:

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

Mas cuidado, se uma das filiais remotas for nomeada como, por exemplo, admin_master, ela não será baixada!

Graças ao bigfish pela ideia original


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 readability:

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 mestre (para que possamos excluir o ramo em que estamos)
  2. selecione remoto para checkout (mude para qualquer controle remoto que você tenha)
  3. loop através de todos os ramos do controle remoto, exceto mestre e HEAD
    1. excluir ramificação local (para que possamos verificar as ramificações atualizadas de força)
    2. confira ramo do controle remoto
  4. confira master (por causa disso)

Baseado em answer de VonC .


Quando você faz "git clone git: // location", todos os branches e tags são buscados.

Para trabalhar em cima de um ramo remoto específico, assumindo que é o remoto de origem:

git checkout -b branch origin/branchname

Se você tem muitos ramos remotos que deseja buscar de uma só vez, faça:

$ git pull --all

Agora você pode fazer o checkout de qualquer filial, sem precisar acessar o repositório remoto.


Use aliases. Embora não haja nenhum one-liners nativo do Git, você pode definir o 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 usá-lo como

git clone-branches

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

Cada vez que faz uma operação em seu nome, imprime em vermelho no console. Com o tempo, eles finalmente ficam no seu cérebro :-)

Se você não quer que a grb execute comandos em seu nome, apenas use o recurso 'explain'. Os comandos serão impressos no seu console ao invés de serem executados para você.

Finalmente, todos os comandos possuem aliases, para facilitar a memorização.

Note que este é um git_remote_branch ;-)

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

git_remote_branch version 0.2.6

  Usage:

  grb create branch_name [origin_server] 

  grb publish branch_name [origin_server] 

  grb rename branch_name [origin_server] 

  grb delete branch_name [origin_server] 

  grb track branch_name [origin_server] 



  Notes:
  - If origin_server is not specified, the name 'origin' is assumed 
    (git's default)
  - The rename functionality renames the current branch

  The explain meta-command: you can also prepend any command with the 
keyword 'explain'. Instead of executing the command, git_remote_branch 
will simply output the list of commands you need to run to accomplish 
that goal.

  Example: 
    grb explain create
    grb explain create my_branch github

  All commands also have aliases:
  create: create, new
  delete: delete, destroy, kill, remove, rm
  publish: publish, remotize
  rename: rename, rn, mv, move
  track: track, follow, grab, fetch

Você só precisa usar o "git clone" para obter todos os branches.

git clone <your_http_url>

Mesmo que você veja apenas o 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á tem.

git checkout <your_branch_name>

Não se preocupe que depois de "git clone", você não precisa se conectar com o repo remoto, "git branch -a" e "git checkout" pode ser executado com sucesso quando você fechar o seu wifi. Portanto, é provado que quando você faz "git clone", ele já copiou todos os branches do repositório remoto. Depois disso, você não precisa do repo remoto, o seu local já tem todos os códigos das agências.


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 branches de uma só vez.

Quando você clona um repositório, todas as informações das ramificações são realmente baixadas, mas as ramificações ficam ocultas. Com o comando

$ git branch -a

você pode mostrar todos os ramos 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 branches, todas as formas ilustradas acima são demoradas e tediosas em relação a uma maneira muito mais clara e rápida que eu vou mostrar, embora seja um pouco complicado. Você precisa de três etapas para realizar 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, há apenas uma pasta .git oculta que você pode ver com o comando "ls -alt" do terminal.

  1. Segundo passo

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

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

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

$ git reset --hard

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

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


A clonagem de um repositório local não funcionará com o git clone & git fetch: muitas ramificações / tags permanecerão sem rastreio.

Para obter um clone com todos os ramos 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

Aqui está outro comando curto one-liner que cria ramificações locais para todos os branches remotos:

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

Ele também funciona corretamente se o rastreamento de ramificações locais já tiver sido criado. Você pode ligar depois da primeira git cloneou qualquer outra hora depois.

Se você não precisar que a masterfilial seja retirada após a clonagem, use

git branch -r | sed -n '/->/!s#^  origin/##p'| xargs -L1 git checkout

A partir do início de 2017, a resposta neste comentário funciona:

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


Eu escrevi estas pequenas funções do Powershell para poder verificar todas as minhas ramificações git, que estão na origem remota.

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 meu git


Git geralmente (quando não especificado) busca todos os ramos e / ou tags (refs, veja:) git ls-refsde um ou mais outros repositórios, juntamente com os objetos necessários para completar suas histórias. Em outras palavras, ele busca os objetos que podem ser acessados ​​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 ao atual, então git pull --all/ git fetch --allnão vai ajudar nesse caso, mas você pode listá-las por:

git ls-remote -h -t origin

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

Então, para buscá-los todos , tente:

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

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

Em seguida, verifique todos os seus ramos novamente:

git branch -avv

Se acima não vai ajudar, você precisa adicionar ramos faltando manualmente para a lista rastreada (como eles se perderam de alguma forma):

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

por git remote set-branchesassim:

git remote set-branches --add origin missing_branch

então pode aparecer remotes/origindepois da busca:

$ 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 obter algo além da ramificação mestre, verifique os seguintes itens:

  • Verifique os seus controles remotos ( git remote -v), por exemplo
    • Valide isso git config branch.master.remoteé origin.
    • Verifique se originaponta para o URL correto via: git remote show origin(veja este post ).

Vou adicionar meus 2 centavos aqui porque cheguei aqui tentando descobrir como extrair um branch remoto que eu deletei localmente. A origem não era minha, e eu não queria passar pelo incômodo de re-clonar tudo

Isso funcionou para mim:

supondo que você precisa recriar o ramo localmente:

git checkout -b recreated-branch-name
git branch -a (to list remote branches)
git rebase remotes/remote-origin/recreated-branch-name

Então, se eu forjei do gituser / master para o sjp e, em seguida, passei para o sjp / mynewbranch, ficaria assim:

$ git checkout -b mynewbranch
$ git branch -a
  master
  remotes/sjp/master
  remotes/sjp/mynewbranch
$ git fetch (habit to always do before)
$ git rebase remotes/sjp/mynewbranch




remote-branch