Como buscar todos os ramos do git?

Eu clonei um repository git, que contém cerca de 5 ramificações. No entanto, quando eu git branch eu vejo apenas um deles:

 $ git branch * master 

Eu sei que eu posso fazer git branch -a para ver todos os branches, mas como eu iria puxar todos os branches localmente assim quando eu faço git branch , ele mostra:

 $ git branch * master * staging * etc... 

Eu escrevi a minha resposta há algum tempo e último downvote me motivou a atualizá-lo com a minha experiência posterior 🙂

Editar: a versão anterior dessa resposta criou ramificações com prefixo ‘origin’, todas apontando para a ramificação principal, em vez de ramificações reais e tendo problemas com expansões variables. Isso foi corrigido conforme comentários.

Você pode buscar um ramo de todos os controles remotos como este:

 git fetch --all 

fetch atualizações de cópias locais de filiais remotas, de modo que isso seja sempre seguro para suas filiais locais, MAS :

  1. fetch não atualiza as ramificações locais (que rastreiam ramificações remotas); Se você quiser atualizar suas filiais locais, ainda precisará extrair todas as filiais.

  2. fetch não criará ramificações locais (que rastreiam ramificações remotas), você precisa fazer isso manualmente. Se quiser listar todas as agências remotas: git branch -a

Para atualizar filiais locais que rastreiam filiais remotas:

 git pull --all 

No entanto, isso ainda pode ser insuficiente. Ele funcionará apenas para suas filiais locais que rastreiam filiais remotas. Para rastrear todas as filiais remotas, execute este oneliner ANTES de git pull --all :

 git branch -r | grep -v '\->' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done 

TL; versão DR

 git branch -r | grep -v '\->' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done git fetch --all git pull --all 

(parece que puxar todos os ramos de todos os controles remotos, mas eu sempre busco primeiro apenas para ter certeza)

Execute o primeiro comando apenas se houver ramificações remotas no servidor que não sejam rastreadas por suas ramificações locais.

PS AFAIK git fetch --all e git remote update são equivalentes.



O comentário de Kamil Szot, que 74 (pelo menos) pessoas acharam útil.

Eu tive que usar:

 for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done 

porque seu código criou ramificações locais nomeadas origin/branchname e eu estava recebendo “refname ‘origin / branchname’ é ambíguo sempre que me referi a ele.

Para listar filiais remotas:
git branch -r

Você pode vê-los como filiais locais com:
git checkout -b LocalName origin/remotebranchname

Você precisará criar filiais locais para rastrear filiais remotas.

Supondo que você tenha apenas uma origin remota chamada, esse snippet criará ramificações locais para todas as ocorrências de rastreamento remoto:

 for b in `git branch -r | grep -v -- '->'`; do git branch --track ${b##origin/} $b; done 

Depois disso, git fetch --all atualizará todas as cópias locais das ramificações remotas.

Além disso, o git pull --all atualizará suas ramificações de rastreamento local, mas, dependendo das suas confirmações locais e de como a opção de configuração “mesclar” está configurada, pode criar uma consolidação de mesclagem, avanço rápido ou falha.

Se você fizer:

 git fetch origin 

então eles estarão todos lá localmente. Se você, então, executar:

 git branch -a 

você os verá listados como remotas / origin / branch-name. Uma vez que eles estão lá localmente, você pode fazer o que quiser com eles. Por exemplo:

 git diff origin/branch-name 

ou

 git merge origin/branch-name 

ou

 git checkout -b some-branch origin/branch-name 
 $ git remote update $ git pull --all 

Isso pressupõe que todas as filiais sejam rastreadas

se eles não são você pode triggersr isso em bash

 for remote in `git branch -r `; do git branch --track $remote; done 

Em seguida, execute o comando.

E quanto ao git fetch && git checkout RemoteBranchName ? Funciona muito bem para mim…

O bash for loop não estava funcionando para mim, mas isso fez exatamente o que eu queria. Todos os ramos da minha origem são espelhados como o mesmo nome localmente.

 git fetch origin '+refs/heads/*:refs/heads/*' 

Quando você clona um repository, 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 repository, e com o comando

 $ git checkout -b branchname origin/branchname 

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


No entanto, há uma maneira muito mais limpa e rápida, 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 repository:

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

    o repository 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.

  2. Segundo passo

    Troque este repository de um repository vazio (vazio) para um repository regular, trocando o valor booleano “bare” das configurações do git para false:

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

    Pegue tudo o que estiver dentro da pasta atual e crie todas as ramificações na máquina local, tornando-a um repository 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 repository git com todos os branches de uma vez, mas não é algo que você queira fazer para cada projeto dessa maneira.

Eu costumo usar nada além de comandos como este:

 git fetch origin git checkout --track origin/remote-branch 

Uma versão pouco mais curta:

 git fetch origin git checkout -t origin/remote-branch 

Você pode buscar todos os ramos por:

 git fetch --all 

ou:

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

O parâmetro --depth=10000 pode ajudar se você tiver um repository --depth=10000 .


Para puxar todos os ramos, use:

 git pull --all 

Se acima não funcionar, então preceda o comando acima com:

 git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*' 

como o remote.origin.fetch poderia suportar apenas um ramo específico ao buscar, especialmente quando você clonou seu repository com --single-branch . Verifique isso por: git config remote.origin.fetch .

Depois disso, você poderá fazer o checkout de qualquer filial.

Veja também:

  • Como buscar todos os ramos remotos?
  • Como clonar todos os ramos remotos no Git?

Para empurrar todos os ramos para o controle remoto, use:

 git push --all 

eventualmente --mirror para espelhar todos os refs.


Se seu objective é duplicar um repository, consulte: Duplicando um artigo de repository no GitHub.

Se você está aqui procurando uma solução para obter todas as ramificações e depois migrar tudo para outro servidor Git, eu uno o processo abaixo. Se você quiser apenas atualizar todas as filiais localmente, pare na primeira linha vazia.

 git clone  git branch -r | awk -F'origin/' '!/HEAD|master/{print $2 " " $1"origin/"$2}' | xargs -L 1 git branch -f --track git fetch --all --prune --tags git pull --all git remote set-url origin  git pull  git push --all git push --tags  

Eu acredito que você tenha clonado o repository

 git clone https://github.com/pathOfrepository 

agora vá para essa pasta usando o cd

 cd pathOfrepository 

se você digitar git status

você pode ver tudo

  On branch master Your branch is up-to-date with 'origin/master'. nothing to commit, working directory clean 

para ver todo o tipo de ramificação oculta

  git branch -a 

listará todos os ramos remotos

Agora, se você quiser fazer o checkout em qualquer ramo em particular, basta digitar

 git checkout -b localBranchName origin/RemteBranchName 

Depois de clonar o repository principal, você pode executar

 git fetch && git checkout  

Certifique-se de que todas as ramificações remotas estejam disponíveis no arquivo .git/config .

Neste exemplo, somente a ramificação de origin/production ser obtida, mesmo se você tentar fazer git fetch --all acontecerá, mas buscando a ramificação de production :

 [origin] fetch = +refs/heads/production:refs/remotes/origin/production 

Esta linha deve ser substituída por:

 [origin] fetch = +refs/heads/*:refs/remotes/origin/* 

Então execute git fetch etc …

Looping não parecia funcionar para mim e eu queria ignorar origem / mestre. Aqui está o que funcionou para mim.

 git branch -r | grep -v HEAD | awk -F'/' '{print $2 " " $1"/"$2}' | xargs -L 1 git branch -f --track 

Depois disso:

 git fetch --all git pull --all 

Apenas esses 3 comandos receberão todos os ramos

 git clone --mirror repo.git .git (gets just .git - bare repository) git config --bool core.bare false git reset --hard 

Escrevi um pequeno script para gerenciar a clonagem de um novo repository e criar ramificações locais para todos os ramos remotos.

Você pode encontrar a última versão aqui :

 #!/bin/bash # Clones as usual but creates local tracking branches for all remote branches. # To use, copy this file into the same directory your git binaries are (git, git-flow, git-subtree, etc) clone_output=$((git clone "$@" ) 2>&1) retval=$? echo $clone_output if [[ $retval != 0 ]] ; then exit 1 fi pushd $(echo $clone_output | head -1 | sed 's/Cloning into .\(.*\).\.\.\./\1/') > /dev/null 2>&1 this_branch=$(git branch | sed 's/^..//') for i in $(git branch -r | grep -v HEAD); do branch=$(echo $i | perl -pe 's/^.*?\///') # this doesn't have to be done for each branch, but that's how I did it. remote=$(echo $i | sed 's/\/.*//') if [[ "$this_branch" != "$branch" ]]; then git branch -t $branch $remote/$branch fi done popd > /dev/null 2>&1 

Para usá-lo, basta copiá-lo em seu diretório git bin (para mim, C:\Program Files (x86)\Git\bin\git-cloneall ), então, na linha de comando:

 git cloneall [standard-clone-options]  

Ele clona como de costume, mas cria ramificações de rastreamento locais para todos os ramos remotos.

Para usuários do Windows usando o PowerShell:

 git branch -r | ForEach-Object { # Skip default branch, this script assumes # you already checked-out that branch when cloned the repo if (-not ($_ -match " -> ")) { $localBranch = ($_ -replace "^.*/", "") $remoteBranch = $_.Trim() git branch --track "$localBranch" "$remoteBranch" } } git fetch --all git pull --all 

Podemos colocar todos os nomes de ramos ou marcas em um arquivo temporário, e fazer o git pull para cada nome / tag:

 git branch -r | grep origin | grep -v HEAD| awk -F/ '{print $NF}' > /tmp/all.txt git tag -l >> /tmp/all.txt for tag_or_branch in `cat /tmp/all.txt`; do git checkout $tag_or_branch; git pull origin $tag_or_branch; done 

Baseado na resposta de Learath2, aqui está o que eu fiz depois de fazer git clone [...] e cd -ing no diretório criado:

git branch -r | grep -v master | awk {print\$1} | sed 's/^origin\/\(.*\)$/\1 &/' | xargs -n2 git checkout -b

Trabalhou para mim, mas não posso saber que funcionará para você. Seja cuidadoso.

 git remote add origin https://yourBitbucketLink git fetch origin git checkout -b yourNewLocalBranchName origin/requiredRemoteBranch (use tab :D) 

Agora, localmente, seu yourNewLocalBranchName é o seu requiredRemoteBranch .