Como buscar todos os ramos Git


1507

Eu clonei um repositório Git, que contém cerca de cinco ramos. No entanto, quando eu git branchvejo apenas um deles:

$ git branch
* master

Sei que posso fazer git branch -apara ver todos os galhos, mas como eu puxaria todos os galhos localmente; assim, quando o faço git branch, mostra o seguinte?

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


2
Esta pergunta mostra como obter todos os ramos depois de usar o --single-branchajuste quando a clonagem: stackoverflow.com/questions/17714159/... ( git fetch --allnunca vai funcionar se você tiver especificado apenas um ramo!)
Matthew Wilcoxson

2
Você nunca verá essa saída porque o asterisco representa a filial que está fazendo checkout no momento. Como você pode fazer check-out de apenas uma ramificação de uma só vez, você pode ter apenas um asterisco à esquerda da sua listagem de ramificações.
Robino

5
Vi muitas respostas, mas nenhuma delas mencionou o que eu acho que é provavelmente a maneira mais fácil de fazer o que você deseja: git clone --bare <repo url> .git (observe que você precisa adicionar "--bare" e ".git" no final para clonar o repositório como um repo "bare"), then git config --bool core.bare false(define o sinalizador "bare" como false), then git reset --hard(move o HEAD para o HEAD atual no repo). Agora, se você git branchver todos os ramos do repositório clonado.
Gabriel Ferraz

4
@GabrielFerraz Então você está abusando da funcionalidade de comentários no Stack Overflow. Os usuários podem votar com antecedência, mas não com votos negativos.
pipe

Respostas:


2051

Você pode buscar todas as ramificações de todos os controles remotos como este:

git fetch --all

É basicamente uma jogada de poder .

fetchatualiza cópias locais de filiais remotas para que seja sempre seguro para suas filiais locais, MAS :

  1. fetchnão atualizará ramificações locais (que rastreiam ramificações remotas); se você quiser atualizar suas ramificações locais, ainda precisará extrair todas as ramificações.

  2. fetchnão criará ramificações locais (que rastreiam ramificações remotas), você deve fazer isso manualmente. Se você deseja listar todas as ramificações remotas: git branch -a

Para atualizar ramificações locais que rastreiam ramificações 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 ramificações remotas, execute este oneliner ANTES git pull --all :

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

Versão TL; 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 o pull busca 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 --alle git remote updatesão equivalentes.



O comentário de Kamil Szot , que as pessoas acharam úteis.

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/branchnamee eu estava recebendo "refname 'origin / branchname' é ambíguo sempre que me referi a ela.


42
Desculpa. Não consigo imaginar que é isso que o OP realmente quer. O comando 'pull' é 'buscar + mesclar' e a parte de mesclagem irá sobrepor todos os ramos um sobre o outro - deixando uma bagunça gigante.
GoZoner

10
que buscar não iria criar uma nova filial remota você ainda precisa verificá-la comgit checkout -b localname remotename/remotebranch
Learath2

125
Eu tive que usar for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done porque seu código criado filiais locais nomeados origem / branchname e eu estava ficando "refname 'origin / branchname' é ambígua sempre que se refere a ele.
Kamil Szot

22
Não sei se estou usando uma versão diferente do GIT, mas tive que alterar o script para git pull --all; for remote in `git branch -r | grep -v \>`; do git branch --track ${remote#origin/} $remote; done. A mudança retira HEAD.
Kim3er # 29/13

16
Para o pessoal do Windows:for /F %remote in ('git branch -r') do ( git branch --track %remote) && git fetch --all && git pull --all
Max

719

Para listar ramificações remotas:
git branch -r

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


88
Era exatamente isso que eu procurava quando encontrei a pergunta acima. Eu suspeito que muitas pessoas que procuram como extrair uma ramificação remota definitivamente não desejam mesclar a ramificação em sua cópia de trabalho atual, mas desejam uma ramificação local idêntica à remota.
Frug

12
Mesmo se o ramo não estiver visível localmente, eu posso fazer git checkout remotebranchnamee funciona. qual a diferença com a sua solução?
François Romain

12
Seu comportamento padrão agora. Não era o caso nas versões mais antigas do git. O uso de git checkout remotebranchnameusado para criar apenas uma nova ramificação não relacionada denominada remotebranchname .
Learath2

12
A resposta aceita faz algo, fundamentalmente diferente e para ser franco eu nem sequer entender por que sua resposta aceite
Learath2

8
O OP solicitou todas as filiais. Esta resposta faz apenas um.
Ted Bigham #

193

Você precisará criar filiais locais que rastreiam filiais remotas.

Supondo que você tenha apenas um controle remoto chamado origin, esse snippet criará ramificações locais para todas as de rastreamento remoto:

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

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

Além disso, git pull --allatualizará suas ramificações de rastreamento local, mas, dependendo das confirmações locais e de como a opção de configuração 'mesclar' estiver definida, isso poderá criar uma confirmação de mesclagem, avanço rápido ou falha.


5
Isso robusta a solução contra nomes de ramificações que contêm metacaracteres de shell (conforme comentário de pinkeen na outra resposta) e evita saída de erro espúrio: git branch -r | grep -v - '->' | enquanto lê remotamente; do git branch --track "$ {remote # origin /}" "$ remote" 2> & 1 | grep -v 'já existe'; feito
Daira Hopwood

6
Tem certeza de que git pull --allatualizará todas as ramificações de rastreamento local? Tanto quanto posso dizer, apenas atualiza o ramo atual de todos os controles remotos.
217 Andy

3
Fez isso. As ramificações locais correspondentes às ramificações remotas não foram criadas. Qual é o comando git que simplesmente diz "puxe todos os ramos remotos criando locais se eles não existirem"?
11787 JosephK

@ JosephphK talvez seu controle remoto não seja chamado origin? Veja esta resposta que funcionará em todos os nomes remotos.
Tom Hale

@ TomHale Era "origem", mas obrigado pela sua resposta - embora louca seja necessária muita coisa para fazer o que deve ser uma ou talvez duas bandeiras. Agora estou tentando sem sentido, para tentar evitar a insanidade de alguns aspectos do git.
JosephK

116

Se você fizer:

git fetch origin

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

git branch -a

você os verá listados como controles remotos / origem / nome da filial. 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

5
Acabei de encontrar esta página no google ... esse era o tipo de resposta que eu estava procurando. Tentei o primeiro comando, mas recebi um erro: [$ git fetch --all origem fatal: fetch --all não aceita argumento de repositório] --- Usar "git fetch --all" parece fazer o truque. Obrigado pela liderança!
Longda

1
Corrigido (eliminado --all)
GoZoner 29/03

12
git fetch -allbusca todos os ramos de todos os controles remotos. git fetch originbusca todos os ramos do controle remoto origin. Quanto mais tarde é o que o OP estava perguntando.
GoZoner

3
--allsignifica "todos os controles remotos", não "todos os ramos de um determinado controle remoto". O último está implícito em qualquer busca de um controle remoto.
Spacediver

2
Essa não é a maneira de puxar todas as ramificações para o repo local, do repo remoto.
Vladimir Despotovic

69
$ git remote update
$ git pull --all

Isso pressupõe que todas as ramificações são rastreadas.

Se não estiverem, você pode disparar isso no Bash:

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

Em seguida, execute o comando


3
Quando tento, ainda obtenho o mesmo resultado acima.
precisa saber é o seguinte

4
Assim como @JacobLowe, obtive o erro, mas funcionou de qualquer maneira; 'fatal: um ramo chamado' origem / mestre 'já existe.'
AnneTheAgile 21/07

Isso é feio como ele irá tentar criar uma filial para ->o que provavelmente vai existir na saída git branch -rcomo `origem / HEAD -> origem / master`
Tom Hale

Além disso, não funciona. Recebo a saída: Branch 'origin/quote-filenames' set up to track local branch 'master'. A saída desejada é: Branch 'quote-filenames' set up to track remote branch 'quote-filenames' from 'origin'. Isso é inverso , definindo a origem para rastrear o controle remoto. Veja esta resposta para uma correção.
Tom Hale

exatamente o que eu precisava. Desde que troquei o Mac, mesmo depois de clonar o repositório, não pude verificar outras ramificações remotas e git fetchnão funcionaria. Portanto, a lição aqui é que você precisa acompanhar as ramificações remotas. Gracias!
Victor Ramos

58

O forloop Bash não estava funcionando para mim, mas isso fez exatamente o que eu queria. Todos os ramos da minha origem espelhavam o mesmo nome localmente.

git checkout --detach
git fetch origin '+refs/heads/*:refs/heads/*'

Veja o comentário de Mike DuPont abaixo. Acho que estava tentando fazer isso em um servidor Jenkins, que o deixa no modo de cabeça desanexada.


6
Isso produz fatal: Refusing to fetch into current branch refs/heads/master of non-bare repositorydepois de um simples clone. Tem que destacar a cabeça primeiro. Eu fiz isso comgit checkout <SHA>
brannerchinese

6
Minha solução usando este é git checkout --detach # detach the heade depoisgit fetch origin \'+refs/heads/*:refs/heads/*
Mike DuPont

1
Este funcionou para mim, exceto que eu também uso o parâmetro --tags. Eu gostaria que houvesse um front end simples e padrão para o git, o número de coisas simples no git que precisam de mais de 10 respostas de estouro de pilha é ridículo!
22416 kristianp

1
@kristianp Você já viu o Ungit ou o GitKraken?
precisa saber é o seguinte

@ dragon788 Eu tenho usado o SourceTree para uma GUI do git, mas eu estava realmente falando sobre uma linha de comando mais simples para tarefas de script.
Kristianp #

51

Use git fetch && git checkout RemoteBranchName.

Funciona muito bem para mim...


6
Esta é a nova melhor resposta para todos. Não sei se talvez isso não fosse possível antes, mas as versões recentes do Git pelo menos perceberão que você está tentando efetuar check-out de uma filial remota e configuram automaticamente a filial de rastreamento local para você (e você não precisa especificar origin/branch; basta dizer apenas branch).
Neil Traft

9
Isso não responde à pergunta original: "Como eu puxaria todos os ramos localmente?" Está puxando-os um por um, o que não é escalável.
ingyhere

Esta foi a única resposta que me permitiu puxar filiais remotas em cada situação que eu encontrei
Emmanuel Buckshi

38

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, existe uma maneira muito mais limpa e rápida, embora seja um pouco complicado. Você precisa de três etapas para fazer isso:

  1. Primeiro passo

    crie uma nova pasta vazia na 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.

  2. 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
    
  3. 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.


1
Promovido para menção de ramos ocultos. me ajudou a entender imensamente o rastreamento de filiais locais.
mburke05

É uma boa resposta, mas a pergunta implica em algo para o uso diário. Não é prático clonar o repositório toda vez.
Z. Khullah

Por que a redefinição cria todas as ramificações localmente?
Z. Khullah

@ Z.Khullah, não é a redefinição que cria todos os ramos, mas o clone --mirror. Infelizmente para nós, isso também cria um repositório simples, que é o que as etapas 2 e 3 mudam.
ScottJ

29

Você pode buscar todos os ramos por:

git fetch --all

ou:

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

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


Para puxar todos os galhos, use:

git pull --all

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

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

pois ele remote.origin.fetchpode suportar apenas um ramo específico durante a busca, especialmente quando você clonou seu repositório --single-branch. Verifique isso: git config remote.origin.fetch.

Depois disso, você poderá fazer checkout de qualquer agência.

Veja também:


Para enviar todas as ramificações para o controle remoto, use:

git push --all

eventualmente --mirrorpara espelhar todos os árbitros.


Se seu objetivo é duplicar um repositório, consulte: Duplicando um artigo de repositório no GitHub.


1
Impressionante ... Tentei de tudo antes da sua solução nesta página. Muito obrigado!
Sujoy 7/03/2017

2
Usei a clonagem superficial ( depth=1) e a configuração também especificou um ramo específico para fetch- o depth=1000parâmetro foi a correção que me ajudou a verificar um ramo remoto específico
Sandra

2
pull --allnão puxa todos os ramos, mas todos os controles remotos
Z. Khullah

Bom truque com a configuração! Gostaria de buscá-los todos, o tempo todo
Z. Khullah

Eu verifiquei a configuração como você escreveu, ainda funciona apenas com o ramo atual. Parece que todas as respostas aqui não funcionam para mim ... #
Alexei Martianov

25

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

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

Uma versão um pouco mais curta:

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

17

Acredito que você clonou o repositório por:

git clone https://github.com/pathOfrepository

Agora vá para essa pasta usando o cd:

cd pathOfrepository

Se você digitar, git statuspoderá ver tudo:

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

Para ver todos os tipos de ramificação ocultos:

 git branch -a

Ele listará todas as ramificações remotas.

Agora, se você quiser fazer o checkout em qualquer filial em particular, digite:

git checkout -b localBranchName origin/RemteBranchName

16

Se você está aqui procurando uma solução para obter todas as filiais e depois migrar tudo para outro servidor Git, montei o processo abaixo. Se você deseja atualizar todos os ramos localmente, pare na primeira linha vazia.

git clone <ORIGINAL_ORIGIN>
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 <NEW_ORIGIN>
git pull
<resolve_any_merge_conflicts>
git push --all
git push --tags
<check_NEW_ORIGIN_to_ensure_it_matches_ORIGINAL_ORIGIN>

3
Muito prestativo; exatamente o que eu precisava. A única coisa que tive que mudar foi na segunda linha, adicionei aspas simples em torno de 'HEAD' e 'master'; provavelmente porque estou usando zsh. Obrigado!
Sockmonk

Isso é basicamente o seguinte: (1) Obtenção dos nomes reais das ramificações remotas [sem cabeçalho, sem mestre]; (2) dizendo ao Git para rastreá-los [nem todas as soluções fazem isso]; (3) Buscando e puxando tudo desses ramos [incluindo tags]; (4) Estabelecendo uma nova origem e caminhando empurrando absolutamente tudo para cima. Novamente, a maioria das outras soluções falha ao mover todas as peças. Isso faz tudo.
ingyhere

1
Eu removi o antipadrão da execução do grep e do awk e condensou os comandos grep no comando awk. Graças triplo !
ingyhere

Leia isto e nunca escreva git fetch git pull stackoverflow.com/a/292359/1114926
Verde

O Git pullrealmente faz o fetchprimeiro, mas é mais fácil saber se o problema é da fetchparte pullou da mergeparte subsequente de pullquando fetché executado independentemente.
ingyhere

12

Depois de clonar o repositório principal, você pode executar

git fetch && git checkout <branchname>

1
simples. e trabalhou para conseguir um ramo de origem remota
sirvon

3
Isso não responde à pergunta original: "Como eu puxaria todos os ramos localmente?" Está puxando-os um por um, o que não é escalável. Considere o caso de 100 ramos.
ingyhere

10

Verifique se todas as ramificações remotas são buscáveis .git/config arquivo.

Neste exemplo, apenas a origin/productionramificação é buscável, mesmo se você tentar fazer git fetch --allnada acontecerá, além de buscar a productionramificação:

[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 fetchetc ...


3
Para inspecionar: git config --get remote.origin.fetche depois defini-lo (destrutivamente):git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'
qneill

ou modificar o arquivo de configuração de texto no diretório .git, trabalhou para mim
FDIM

9

Looping não parecia funcionar para mim e eu queria ignorar a 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

1
Uma variação disso é a resposta correta, mas essa não funciona em todos os casos extremos. Além disso, os nomes das filiais podem ser descolados. Então, fiz o seguinte: git branch -r | grep -v CABEÇA | grep –v master | awk -F'origin / '' {print $ 2 "" $ 1 "origin /" $ 2} '| xargs -L 1 ramo git -f --track; git fetch --all; git pull - tudo; E que fez o truque!
ingyhere

3
Uma melhoria estilística para evitar o grep | awk antipadrão : git branch -r | awk -F 'origin/' '!/HEAD|master/{...
tripleee

7

Apenas estes três comandos obterão todos os ramos:

git clone --mirror repo.git  .git     (gets just .git  - bare repository)

git config --bool core.bare false

git reset --hard

Esta é realmente a raiz do problema do OP. Se clonado corretamente, ele não precisaria fazer a pull --all. Mas se ainda for necessário, a outra resposta abaixo, de @Johnno Nola, assumindo que todos os ramos sejam rastreados, misturados a essa resposta, é o caminho a seguir.
Dr Beco

7

Por que ninguém responde à pergunta dos caras e explica o que está acontecendo?

  1. Verifique se você está acompanhando todas as ramificações remotas (ou as que você deseja rastrear) .
  2. Atualize suas ramificações locais para refletir as ramificações remotas.

Acompanhe todas as ramificações remotas:

Rastreie todas as ramificações existentes no repositório remoto.

Faça manualmente:

Você substituiria <branch>por uma ramificação exibida na saída de git branch -r.

git branch -r
git branch --track <branch>

Faça isso com um script bash

for i in $(git branch -r | grep -vE "HEAD|master"); do git branch --track ${i#*/} $i; done

Atualize as informações sobre as ramificações remotas no seu computador local:

Isso busca atualizações nas ramificações do repositório remoto que você está rastreando no repositório local. Isso não altera suas filiais locais. Seu repositório git local agora está ciente das coisas que aconteceram nas ramificações remotas. Um exemplo seria que uma nova confirmação foi enviada ao mestre remoto, ao fazer uma busca agora o alertará de que seu mestre local está atrasado em 1 confirmação.

git fetch --all

Atualize as informações sobre as ramificações remotas no computador local e atualize as ramificações locais:

Faz uma busca seguida por uma mesclagem para todas as ramificações do controle remoto para a ramificação local. Um exemplo seria que uma nova confirmação foi enviada ao mestre remoto, fazendo uma solicitação atualizará seu repositório local sobre as alterações na ramificação remota e, em seguida, mesclará essas alterações na ramificação local. Isso pode criar uma bagunça devido a conflitos de mesclagem.

git pull --all

4

Escrevi um pequeno script para gerenciar a clonagem de um novo repositório e criar ramificações locais para todas as ramificações remotas.

Você pode encontrar a versão mais recente 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 para o diretório git bin (para mim C:\Program Files (x86)\Git\bin\git-cloneall) e, em seguida, na linha de comando:

git cloneall [standard-clone-options] <url>

Ele clona como de costume, mas cria ramificações de rastreamento local para todas as ramificações remotas.


4

Como buscar todas as ramificações do Git que seguem o controle remoto único.

Isso foi testado e funciona no Red Hat e no Git Bash no Windows 10.


TLDR:

for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;

Explicação:

O liner único faz check-out e busca todos os ramos, exceto HEAD.

Listar as ramificações de rastreamento remoto.

git branch -r

Ignore HEAD.

grep -v ' -> '

Retire o nome da filial do (s) controle (s) remoto (s).

cut -d"/" -f2

Faça o check-out de todas as filiais que acompanham um único controle remoto.

git checkout $branch

Buscar ramificação com check-out.

git fetch

Tecnicamente, a busca não é necessária para novas ramificações locais.

Isto pode ser utilizado para qualquer fetchoupull ramos que são novos e têm mudanças em remotas (s).

Apenas certifique-se de puxar apenas se estiver pronto para mesclar.


Configuração de teste

Confira um repositório com URL SSH.

git clone git@repository.git

Antes

Verifique as agências no local.

$ git branch
* master

Executar comandos

Execute o liner único.

for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;

Depois de

Verifique se as ramificações locais incluem ramificações remotas.

$ git branch
  cicd
  master
* preprod

4

Para usuários do Windows que usam 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

Isso funciona com ramificações com / no nome: 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" } }
Markus

3

Aqui está algo que eu consideraria robusto:

  • Não atualiza o rastreamento remoto para filiais existentes
  • Não tenta atualizar HEAD para acompanharorigin/HEAD
  • Permite controles remotos nomeados que não sejam origin
  • Shell corretamente citado
for b in $(git branch -r --format='%(refname:short)'); do
  [[ "${b#*/}" = HEAD ]] && continue
  git show-ref -q --heads "${b#*/}" || git branch --track "${b#*/}" "$b";
done
git pull --all

Não é necessário, git fetch --allcomo passar -allpara git pullpassar essa opção para o interno fetch.

Crédito para esta resposta .


2

Aqui está uma versão Perl do one-liner fornecida na resposta aceita:

git branch -r | perl -e 'while(<>) {chop; my $remote = $_; my ($local) = ($remote =~ /origin\/(.*)/); print "git branch --track $local $remote\n";}' > some-output-file

Você pode executar o arquivo de saída como um script do Shell, se desejar.

Excluímos nosso repositório de projetos Stash por acidente. Felizmente, alguém havia criado um garfo antes da perda acidental. Eu clonei o garfo no meu local (omitir os detalhes de como eu fiz isso). Depois de colocar o garfo totalmente no meu local, executei uma linha. Modifiquei a URL do controle remoto (origem no meu caso) para apontar para o repositório de destino para o qual estávamos recuperando:

git remote set-url origin <remote-url>

E finalmente empurrou todos os ramos para a origem da seguinte maneira:

git push --all origin

e estávamos de volta aos negócios.


1

Podemos colocar todos os nomes de ramificações ou tags em um arquivo temporário e, em seguida, 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

1

Se você tiver problemas fetch --all, acompanhe sua ramificação remota:

git checkout --track origin/%branchname%

1

Para evitar a mensagem de erro 'fatal: já existe uma ramificação chamada' origin / master '.', É necessário:

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

0

Com base na resposta de Learath2, aqui está o que eu fiz depois de fazer git clone [...]e cdinserir o 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 sei se funcionará para você. Seja cuidadoso.


0
git remote add origin https://yourBitbucketLink

git fetch origin

git checkout -b yourNewLocalBranchName origin/requiredRemoteBranch (use tab :D)

Agora localmente, você yourNewLocalBranchNameé seu requiredRemoteBranch.


0

Para usuários do Visual Studio, no console do Gerenciador de Pacotes:

ramo git | % {git buscar a montante; git mesclar upstream / master}


0

Já tentei de várias maneiras, apenas esta é simples e funciona para mim.

for branch in $(git ls-remote -h git@<your_repository>.git | awk '{print $2}' | sed 's:refs/heads/::')
do
  git checkout "$branch"
  git pull
done

0

Definir alias: (com base na resposta superior)

git config --global alias.track-all-branches '!git fetch --all && for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done && git fetch --all'

Agora, para acompanhar todos os ramos:

git track-all-branches

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.