Come clonare tutte le filiali remote in Git?

Se hai molte filiali remote che vuoi recuperare contemporaneamente, fai:

$ git pull --all

Ora è possibile eseguire il checkout di qualsiasi filiale in base alle necessità, senza colpire il repository remoto.

Questo Bash script mi ​​ha aiutato:

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

Creerà i rami di rilevamento per tutti i rami remoti, ad eccezione del master (che probabilmente si ottiene dal comando clone originale). Penso che potresti ancora aver bisogno di fare un 

git fetch --all
git pull --all

per essere sicuro.

One 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 Come al solito: prova nel tuo setup prima di copiare rm -rf universe come lo conosciamo 

Crediti per one-liner vai all'utente cfi

L'uso dell'opzione --mirror sembra copiare correttamente i rami di tracciamento remote . Tuttavia, imposta il repository come un repository nudo, quindi devi riaccenderlo in un repository normale in seguito.

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

^{Riferimento: FAQ Git: Come posso clonare un repository con tutte le filiali tracciate in remoto?}

È possibile passare facilmente a un ramo senza utilizzare la sintassi di "git checkout -b somebranch Origin/somebranch". Puoi solo fare:

git checkout somebranch

Git farà automaticamente la cosa giusta:

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

Git verificherà se un ramo con lo stesso nome esiste esattamente in un remoto, e se lo fa, lo tiene traccia nello stesso modo in cui si è esplicitamente specificato che si tratta di un ramo remoto. Dalla pagina man di Git-checkout di Git 1.8.2.1:

Se <branch> non viene trovato ma esiste un ramo di monitoraggio in esattamente un telecomando (chiamatelo <remote>) con un nome corrispondente, trattate come equivalente a

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

Per quanto riguarda,

$ git checkout -b Origine sperimentale/sperimentale

utilizzando

$ git checkout -t Origin/experimental

o il più verboso ma più facile da ricordare

$ git checkout --track Origin/experimental

potrebbe essere migliore, in termini di monitoraggio di un repository remoto. 

Il recupero che stai facendo dovrebbe ottenere tutti i rami remoti, ma non creerà per loro rami locali. Se usi gitk, dovresti vedere i rami remoti descritti come "remotes/Origin/dev" o qualcosa di simile.

Per creare un ramo locale basato su un ramo remoto, fai qualcosa come:

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

Quale dovrebbe restituire qualcosa come:

Branch dev set up per tracciare rem rem/remotes remoti/Origin/dev .
 Passato a un nuovo ramo "dev"

Ora, quando sei sul ramo dev, "git pull" aggiornerà il tuo dev locale allo stesso punto del ramo dev remoto. Nota che recupererà tutti i rami, ma tirerà solo quello che sei in cima all'albero.

Quando esegui "git clone git: // location", vengono recuperati tutti i rami e i tag.

Per lavorare su uno specifico ramo remoto, supponendo che si tratti del telecomando Origin:

git checkout -b branch Origin/branchname

Usa alias. Sebbene non ci siano one-liner Git nativi, puoi definire il tuo come

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

e quindi usarlo come

git clone-branches

Questo non è troppo complicato, molto semplice e semplici passi sono i seguenti;

git fetch Origin Questo porterà tutti i rami remoti al tuo locale.

git branch -a Questo mostrerà tutti i rami remoti.

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

Verificare se ci si trova nel ramo desiderato con il seguente comando;

git branch

L'output piacerà a questo;

*your current branch 
some branch2
some branch3 

Si noti il ​​segno * che indica il ramo corrente.

Perché vedi solo "maestro"

git clone scarica tutti i rami remoti remoti, ma li considera "remoti", anche se i file si trovano nel nuovo repository. C'è un'eccezione a questa, che è che il processo di clonazione crea un ramo locale chiamato "master" dal ramo remoto chiamato "master". Per impostazione predefinita, git branch mostra solo i rami locali, motivo per cui viene visualizzato solo "master".

git branch -a mostra tutti i rami, inclusi i rami remoti .

Come ottenere filiali locali

Se in realtà vuoi lavorare su un ramo, probabilmente vorrai una versione "locale" di esso. Per creare semplicemente rami locali da filiali remote (senza controllarli e quindi modificare il contenuto della directory di lavoro) , puoi fare così:

git branch branchone Origin/branchone
git branch branchtwo Origin/branchtwo
git branch branchthree Origin/branchthree

In questo esempio, branchone è il nome di un ramo locale che stai creando in base a Origin/branchone; se invece vuoi creare filiali locali con nomi diversi, puoi farlo:

git branch localbranchname Origin/branchone

Una volta creato un ramo locale, puoi vederlo con git branch (ricorda che non è necessario -a per vedere i rami locali).

Meglio tardi che mai, ma ecco il modo migliore per farlo:

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

A questo punto hai una copia completa del repository remoto con tutte le sue filiali (verifica con git branch). È possibile utilizzare --mirror anziché --bare se il repository remoto dispone di propri telecomandi.

Basta fare questo:

$ 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

Vedete, 'git clone git: //example.com/myprojectt' recupera tutto, anche i rami, basta controllarli, quindi verrà creato il ramo locale.

Devi solo usare "git clone" per ottenere tutti i rami.

git clone <your_http_url>

Anche se vedi solo il ramo principale, puoi usare "git branch -a" per vedere tutti i rami.

git branch -a

E puoi passare a qualsiasi ramo che hai già.

git checkout <your_branch_name>

Non preoccuparti del fatto che dopo aver "clonato" non è necessario connettersi con il repository remoto, "git branch -a" e "git checkout" possono essere eseguiti correttamente quando si chiude il wifi. Quindi è dimostrato che quando fai "git clone", ha già copiato tutti i rami dal repository remoto. Dopodiché, non hai bisogno del repository remoto, il tuo locale ha già tutti i codici delle filiali. 

Un git clone dovrebbe copiare l'intero repository. Prova a clonarlo, quindi esegui git branch -a. Dovrebbe elencare tutti i rami. Se poi vuoi passare al ramo "foo" invece di "master", usa git checkout foo.

Usa il mio strumento git_remote_branch (hai bisogno di Ruby installato sul tuo computer). È stato progettato appositamente per rendere le manipolazioni di branch remote estremamente facili.

Ogni volta che esegue un'operazione a tuo nome, la stampa in rosso sulla console. Nel corso del tempo, si attaccano finalmente al tuo cervello :-)

Se non vuoi eseguire comandi a tuo nome, usa la funzione 'spiega'. I comandi verranno stampati sulla tua console invece che eseguiti per te.

Infine, tutti i comandi hanno alias, per facilitare la memorizzazione.

Si noti che questo è software alfa ;-)

Ecco l'aiuto quando esegui grb help:

 git_remote_branch versione 0.2.6 

 Uso: 

 grb crea branch_name [Origin_server] 

 grb pubblica branch_name [Origin_server] 

 grb rename branch_name [Origin_server] 

 grb delete branch_name [Origin_server] 

 grb track branch_name [Origin_server] 



 Gli appunti:
 - Se Origin_server non è specificato, il nome 'Origine' è assunto 
 (predefinito di Git) 
 - La funzionalità rename rinomina il ramo corrente 

 Spiega il meta-comando: puoi anche anteporre qualsiasi comando con la parola chiave 
 'Spiega'. Invece di eseguire il comando, git_remote_branch 
 Restituirà semplicemente l'elenco di comandi che è necessario eseguire per raggiungere 
 Tale obiettivo .

 Esempio: 
 grb spiega create 
 grb explain create my_branch github 

 Tutti i comandi hanno anche alias: 
 crea: crea, nuovo 
 delete: delete, destroy, kill, remove, rm 
 pubblicare: pubblica, rimuovi 
 rinomina: rinomina, rn, mv, sposta 
 traccia: traccia, segui, afferra, recupera 

tutte le risposte che ho visto qui sono valide, ma c'è un modo molto più pulito per clonare un repository e tirare tutti i rami contemporaneamente. 

Quando cloni un repository tutte le informazioni dei rami vengono effettivamente scaricate ma i rami sono nascosti. Con il comando

$ git branch -a

puoi mostrare tutti i rami del repository e con il comando

$ git checkout -b branchname Origin/branchname

è quindi possibile "scaricarli" manualmente uno alla volta. 

Tuttavia, quando si vuole clonare un repository con un sacco di rami, tutti i modi illustrati sopra sono lunghi e noiosi rispetto a un modo molto più pulito e veloce che mostrerò, anche se è un po 'complicato. Hai bisogno di tre passaggi per realizzare questo:

1. Primo passo

crea una nuova cartella vuota sul tuo computer e clona una copia speculare della cartella .git dal repository:

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

il repository locale all'interno della cartella my_repo_folder è ancora vuoto, c'è solo una cartella .git nascosta ora che puoi vedere con un comando "ls -alt" dal terminale.

2. Secondo passo

passare questo repository da un repository vuoto (nudo) ad un repository regolare, cambiando il valore booleano "bare" delle configurazioni git su false:

$ git config --bool core.bare false

3. Terzo passo

Prendi tutto ciò che è all'interno della cartella corrente e crea tutti i rami sulla macchina locale, quindi rendilo un normale repo. 

$ git reset --hard

Quindi ora puoi semplicemente digitare il comando "git branch" e puoi vedere che tutti i rami sono stati scaricati. 

Questo è il modo rapido in cui puoi clonare un repository git con tutti i rami contemporaneamente, ma non è qualcosa che vuoi fare per ogni singolo progetto in questo modo. 

Guardando una delle risposte alla domanda ho notato che è possibile accorciarlo:

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

Ma attenzione, se uno dei rami remoti è chiamato per es. admin_master non verrà scaricato!

Grazie a Big Fish per l'idea originale

OK, quando cloni il tuo repository, hai tutti i rami lì ...

Se fai solo git branch, sono un po 'nascosti ...

Quindi se vuoi vedere tutti i nomi dei rami, basta semplicemente aggiungere il flag --all in questo modo:

git branch --all o git branch -a

Se fai il checkout alla filiale, ottieni tutto ciò di cui hai bisogno.

Ma che ne dici se il ramo creato da qualcun altro dopo aver clonato?

In questo caso, basta fare:

git fetch

e controlla di nuovo tutti i rami ...

Se ti piace recuperare e ritirare allo stesso tempo, puoi fare:

git fetch && git checkout your_branch_name

Anche creato l'immagine qui sotto per voi per semplificare quello che ho detto:

La clonazione da un repository locale non funzionerà con git clone & git fetch: molti rami/tag rimarranno non aggiornati.

Per ottenere un clone con tutti i rami e tag.

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

Per ottenere un clone con tutti i rami e tag ma anche con una copia funzionante:

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

#!/bin/bash
for branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master `; do
   git branch --track ${branch#remotes/Origin/} $branch
done

Questo codice estrae tutto il codice di filiali remote al repository locale.

Per copia-incolla nella riga di 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

Per una maggiore leggibilità:

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

1. controlla master (in modo che possiamo eliminare il ramo su cui ci troviamo)
2. seleziona il telecomando per il checkout (cambialo in qualsiasi telecomando tu disponga)
3. passa attraverso tutti i rami del telecomando tranne master e HEAD
   1. delete ramo locale (in modo che possiamo controllare i rami aggiornati alla forza)
   2. check out diramazione dal telecomando
4. controlla master (per il gusto di farlo)

Basato su answer of VonC .

Ho scritto questa piccola funzione Powershell per poter eseguire il checkout di tutti i miei rami git, che si trovano sul telecomando Origin.

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>' #>
}

Altre funzioni git possono essere trovate su my reit settings repo

Dovevo fare esattamente la stessa cosa. Ecco il mio Ruby script.

#!/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]

Git di solito (quando non specificato) recupera tutti i rami e/o tag (refs, vedi: git ls-refs) da uno o più altri repository insieme agli oggetti necessari per completare le loro storie. In altre parole, recupera gli oggetti che sono raggiungibili dagli oggetti già scaricati. Vedi: Cosa fa veramente git fetch?

A volte potresti avere rami/tag che non sono direttamente collegati a quello corrente, quindi git pull --allgit fetch --all non sarà di aiuto in questo caso, ma puoi elencarli per:

git ls-remote -h -t Origin

e li preleva manualmente conoscendo i nomi dei ref.

Quindi per _/recuperarli tutti, prova:

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

^{Il parametro --depth=10000 può essere d'aiuto se hai un repository limitato.}

Quindi controlla di nuovo tutti i tuoi rami:

git branch -avv

Se sopra non sarà di aiuto, dovrai aggiungere manualmente i rami mancanti all'elenco tracciato (dato che sono stati persi in qualche modo):

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

di git remote set-branches come:

git remote set-branches --add Origin missing_branch

quindi può apparire sotto remotes/Origin dopo il recupero:

$ 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

Risoluzione dei problemi

Se ancora non riesci a ottenere altro che il ramo principale, controlla quanto segue:

• Controlla i tuoi telecomandi (git remote -v), ad esempio .
  • Convalidare che git config branch.master.remote sia Origin.
  • Controlla se Origin punta all'URL corretto tramite: git remote show Origin (vedi questo post ).

A partire dall'inizio del 2017, la risposta in questo commento funziona:

git fetch <Origin-name> <branch-name> porta il ramo verso il basso per te. Mentre questo non tira tutti i rami contemporaneamente, puoi eseguire singolarmente questo per ramo.

Nessuna di queste risposte la taglia, tranne che nessuno utente è sulla strada giusta.

Ho avuto problemi con lo spostamento di un repository da un server/sistema a un altro. Quando ho clonato il repository, ha creato solo un ramo locale per il master, quindi quando ho spinto sul nuovo telecomando, è stato spinto solo il ramo master.

Quindi ho trovato questi due metodi MOLTO utili. Spero che aiutino qualcun altro.

Metodo 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

Metodo 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

Usa i comandi che puoi ricordare

Sto usando Bitbucket, un servizio di hosting di repository di Atlassian. Quindi provo a seguire i loro documenti. E questo funziona perfettamente per me. Con i seguenti comandi semplici e brevi puoi controllare la tua filiale remota.

Per prima cosa clonare il repository, quindi passare alla cartella di destinazione. E, ultimo ma non meno importante, vai a prendere e checkout:

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

Questo è tutto. Ecco un esempio più realistico del mondo:

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

Troverai informazioni dettagliate sui comandi nei documenti: Clone Command , Fetch Command , Checkout Command

Ecco un altro breve comando one-liner che .__ crea rami locali per tutti i rami remoti:

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

Funziona anche correttamente se il tracciamento dei rami locali è già stato creato . Puoi chiamarlo dopo il primo git clone o in qualsiasi momento successivo.

Se non è necessario avere il ramo master estratto dopo la clonazione, utilizzare 

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

git clone --mirror sul repository originale funziona bene per questo.

git clone --mirror /path/to/original.git
git remote set-url Origin /path/to/new-repo.git
git Push -u Origin

Aggiungerò i miei 2 centesimi qui perché sono arrivato qui cercando di scoprire come tirare giù un ramo remoto che avevo eliminato localmente. L'origine non era mia e non volevo passare attraverso il fastidio di ri-clonare tutto 

Questo ha funzionato per me:

supponendo che sia necessario ricreare il ramo localmente:

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

Quindi, se ho biforcato da gituser/master a sjp e poi lo ho diramato a sjp/mynewbranch, sarebbe simile a questo:

$ 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

Un po 'tardi per la festa, ma penso che questo faccia il trucco:

mkdir YourRepo
cd YourRepo
git init --bare .git                       # create a bare repo
git remote add Origin REMOTE_URL           # add a remote
git fetch Origin refs/heads/*:refs/heads/* # fetch heads
git fetch Origin refs/tags/*:refs/tags/*   # fetch tags
git init                                   # reinit work tree
git checkout master                        # checkout a branch

Se questo fa qualcosa di indesiderabile, mi piacerebbe saperlo. Tuttavia, finora, questo funziona per me.

Questa variazione clonerà un repository remoto con tutti i rami disponibili localmente senza dover effettuare il checkout di ciascun ramo uno per uno. Non sono necessari script elaborati.

Crea una cartella con lo stesso nome del repository che desideri clonare e cd per esempio:

mkdir somerepo
cd somerepo

Ora esegui questi comandi ma con effettivi repository nome/ripeti 

git clone --bare [email protected]:someuser/somerepo.git .git
git config --bool core.bare false
git reset --hard
git branch

Voiala! hai tutti i rami lì!

Ecco uno script di bash per il recupero di tutti i rami e tag di un progetto git come snapshot in cartelle separate. 

https://Gist.github.com/hfossli/7562257

Forse non è quello che è stato chiesto direttamente, ma alcune persone potrebbero venire qui alla ricerca di questa soluzione.