Come clonare tutti i rami remoti in Git?

Question

Ho un master e un development ramo, entrambi spinti verso GitHub.Io ho cloneD, pulled. e fetched, ma non riesco a ottenere altro che il file master ramo indietro.

Sono sicuro che mi sfugge qualcosa di ovvio, ma ho letto il manuale e non ne provo alcuna gioia.

Answer 1

Innanzitutto, clona un telecomando Idiota deposito e CD dentro:

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

Successivamente, guarda i rami locali nel tuo repository:

$ git branch
* master

Ma ci sono altri rami nascosti nel tuo repository!Puoi vederli usando il file -a bandiera:

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

Se vuoi solo dare una rapida occhiata a un ramo a monte, puoi verificarlo direttamente:

$ git checkout origin/experimental

Ma se vuoi lavorare su quel ramo, dovrai creare un ramo di tracciamento locale che viene eseguito automaticamente da:

$ git checkout experimental

e vedrai

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

L'ultima riga sconcerta alcune persone:"Nuova filiale" - eh?Ciò che significa realmente è che il ramo viene preso dall'indice e creato localmente per te.IL precedente è in realtà più informativa in quanto ti dice che il ramo è stato configurato per tracciare il ramo remoto, che di solito significa il ramo origin/branch_name

Ora, se guardi le tue filiali locali, questo è ciò che vedrai:

$ git branch
* experimental
  master

Puoi effettivamente tenere traccia di più di un repository remoto utilizzando 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

A questo punto le cose stanno diventando piuttosto pazze, quindi corri gitk per vedere cosa sta succedendo:

$ gitk --all &

Answer 2

Se hai molti rami remoti che vuoi recuperare contemporaneamente, fai:

$ git pull --all

Ora puoi effettuare il checkout di qualsiasi ramo di cui hai bisogno, senza accedere al repository remoto.

Answer 3

Questo Bash lo 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à rami di tracciamento per tutti i rami remoti, eccetto master (che probabilmente hai ottenuto dal comando clone originale).Penso che potresti ancora aver bisogno di fare a

git fetch --all
git pull --all

per essere sicuro.

Una fodera: 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 di solito:prova nella tua configurazione prima di copiare rm -rf Universe come lo conosciamo

I crediti per la battuta vanno all'utente cfi

Answer 4

Usando il --mirror l'opzione sembra copiare il file remote monitorare correttamente i rami.Tuttavia, configura il repository come repository semplice, quindi in seguito è necessario trasformarlo nuovamente in un repository normale.

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

^{Riferimento: Domande frequenti su Git:Come posso clonare un repository con tutti i rami tracciati in remoto?}

Answer 5

Puoi passare facilmente a un ramo senza utilizzare la sintassi "git checkout -b somebranch origin/somebranch".Puoi semplicemente 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 controllerà se esiste un ramo con lo stesso nome esattamente in un ramo remoto e, in tal caso, lo terrà traccia come se avessi specificato esplicitamente che si tratta di un ramo remoto.Dalla pagina man git-checkout di Git 1.8.2.1:

Seu003Cbranch> non si trova ma esiste un ramo di tracciamento esattamente in un telecomando (chiamalou003Cremote> ) con un nome corrispondente, trattare come equivalente a

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

Answer 6

Per quanto riguarda,

$ git checkout -b sperimentale origine/sperimentale

utilizzando

$ git checkout -t origin/experimental

oppure quello più prolisso ma più facile da ricordare

$ git checkout --track origin/experimental

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

Answer 7

Il recupero che stai eseguendo dovrebbe ottenere tutti i rami remoti, ma non creerà rami locali per essi.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 del tipo:

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

Che dovrebbe restituire qualcosa come:

Branch dev set up to track remote branch refs/remotes/origin/dev.
Switched to a new branch "dev"

Ora, quando ti trovi 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 su cui ti trovi in ​​cima all'albero.

Answer 8

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

Per lavorare su un ramo remoto specifico, supponendo che sia il telecomando di origine:

git checkout -b branch origin/branchname

Answer 9

Usa gli alias.Sebbene non ci siano battute Git native, puoi definirne una tua come

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

e poi usarlo come

git clone-branches

Answer 10

Perché vedi solo "master"

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

git branch -a mostra tutti i rami, comprese le filiali remote.

---

Come ottenere filiali locali

Se vuoi davvero lavorare su un ramo, probabilmente ne vorrai una versione "locale".Per creare semplicemente filiali locali da filiali remote (senza controllarli e quindi modificare il contenuto della directory di lavoro), puoi farlo in questo modo:

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 su cui stai creando origin/branchone;se invece vuoi creare filiali locali con nomi diversi puoi fare così:

git branch localbranchname origin/branchone

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

Answer 11

Questo non è troppo complicato, i passaggi molto semplici e diretti sono i seguenti;

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

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

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

Verifica se ti trovi nel ramo desiderato con il seguente comando;

git branch

L'output sarà simile a questo;

*your current branch 
some branch2
some branch3 

Notare il segno * che denota il ramo corrente.

Answer 12

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 tutti i suoi rami (verifica con git branch).Puoi usare --mirror invece di --bare se il tuo repository remoto ha telecomandi propri.

Answer 13

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

Vedi, 'git clone git://example.com/myprojectt' recupera tutto, anche i rami, devi solo checkout, quindi verrà creato il tuo ramo locale.

Answer 14

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

git clone <your_http_url>

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

git branch -a

E puoi passare a qualsiasi ramo che già possiedi.

git checkout <your_branch_name>

Non preoccuparti che dopo aver eseguito "git clone", non è necessario connettersi al repository remoto, "git branch -a" e "git checkout" possono essere eseguiti correttamente quando chiudi il Wi-Fi.Quindi è dimostrato che quando esegui "git clone", ha già copiato tutti i rami dal repository remoto.Dopodiché non hai bisogno del repository remoto, il tuo locale ha già i codici di tutte le filiali.

Answer 15

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

Answer 16

Usa il mio strumento git_remote_branch (è necessario che Ruby sia installato sul tuo computer).È costruito appositamente per rendere estremamente semplici le manipolazioni dei rami remoti.

Ogni volta che esegue un'operazione per tuo conto, la stampa in rosso sulla console.Con il passare del tempo, alla fine si attaccano al tuo cervello :-)

Se non vuoi che grb esegua comandi per tuo conto, usa semplicemente la funzione "spiega".I comandi verranno stampati sulla tua console invece che eseguiti per te.

Infine, tutti i comandi hanno degli alias, per facilitarne la memorizzazione.

Nota che questo è software alfa ;-)

Ecco l'aiuto quando esegui grb help:

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

Answer 17

tutte le risposte che ho visto qui sono valide ma esiste un modo molto più semplice per clonare un repository ed estrarre 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

potrai poi "scaricarli" manualmente uno alla volta.

---

Tuttavia, quando vuoi clonare un repository con molti 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.Per raggiungere questo obiettivo sono necessari tre passaggi:

1. Primo passo

crea una nuova cartella vuota sul tuo computer e clona una copia mirror 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" da terminale.

2. Secondo passo

cambia questo repository da un repository vuoto (bare) a 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 si trova nella cartella corrente e crea tutti i rami sul computer locale, rendendolo quindi un normale repository.

$ git reset --hard

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

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

Answer 18

Osservando una delle risposte alla domanda ho notato che è possibile accorciarla:

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 ad es.admin_master non verrà scaricato!

Grazie a bigfish per l'idea originale

Answer 19

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

Per ottenere un clone con tutti i rami e i 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

Answer 20

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

Se lo fai e basta git branch, sono un po' nascosti...

Quindi, se desideri vedere il nome di tutti i rami, basta semplicemente aggiungere --all bandiera in questo modo:

git branch --all O git branch -a

Se fai il check-out in filiale, ottieni tutto ciò di cui hai bisogno.

Ma che ne dici se il ramo creato da qualcun altro dopo lo clonassi?

In questo caso basta fare:

git fetch

e controlla di nuovo tutti i rami...

Se desideri recuperare ed effettuare il checkout allo stesso tempo, puoi fare:

git fetch && git checkout your_branch_name

Ho creato anche l'immagine qui sotto per semplificare ciò che ho detto:

Answer 21

#!/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 inserirà il codice di tutte le filiali remote nel repository locale.

Answer 22

Per copiare e incollare 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

---

Questo sarà:

1. controlla master (in modo da poter eliminare il ramo in cui ci troviamo)
2. selezionare remoto alla cassa (cambialo con qualunque telecomando tu abbia)
3. passare attraverso tutti i rami del telecomando tranne master e HEAD
   1. eliminare filiale locale (in modo da poter controllare le filiali aggiornate forzatamente)
   2. guardare ramo dal telecomando
4. controlla maestro (per il gusto di farlo)

Basato su risposta Di VonC.

Answer 23

Avevo bisogno di fare esattamente la stessa cosa.Ecco il mio Rubino sceneggiatura.

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

Answer 24

L'ho scritto in piccolo PowerShell funzioni per poter controllare tutti i miei rami git, che si trovano su origin remote.

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

È possibile trovare altre funzioni git su il mio repository delle impostazioni Git

Answer 25

Git solitamente (quando non specificato) recupera tutti i rami e/o i tag (riferimenti, vedere: git ls-refs) da uno o più altri repository insieme agli oggetti necessari per completare le loro storie.In altre parole recupera gli oggetti raggiungibili dagli oggetti già scaricati.Vedere: Cosa fa git fetch fallo davvero?

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

git ls-remote -h -t origin

e recuperarli manualmente conoscendo i nomi di riferimento.

Quindi a prendeteli tutti, Tentativo:

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

^{IL --depth=10000 il parametro può essere d'aiuto se hai ridotto il repository.}

Quindi controlla di nuovo tutti i tuoi rami:

git branch -avv

---

Se quanto sopra non aiuta, devi aggiungere manualmente i rami mancanti all'elenco tracciato (poiché si sono persi in qualche modo):

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

di git remote set-branches Piace:

git remote set-branches --add origin missing_branch

quindi potrebbe 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 master, controlla quanto segue:

• Ricontrolla i tuoi telecomandi (git remote -v), per esempio.
  • Convalidalo git config branch.master.remote È origin.
  • Controlla se origin punta all'URL corretto tramite: git remote show origin (guarda questo inviare).

Answer 26

Nessuna di queste risposte è stata efficace, tranne che per l'utente nessuno è sulla strada giusta.

Avevo 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 master, quindi quando ho eseguito il push sul nuovo remoto, è stato inviato 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

Answer 27

Usa i comandi che puoi ricordare

Sto utilizzando 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.

Inizialmente clona il tuo repository, quindi passa alla cartella di destinazione.E ultimo ma non meno importante recupero e checkout:

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

Questo è tutto.Ecco un esempio un po' più reale:

git clone https://username@bitbucket.org/team/repository.git project_folder
cd project_folder
git fetch && git checkout develop

Troverai informazioni dettagliate sui comandi nella documentazione:Comando clonazione, Recupera comando, Comando di cassa

Answer 28

A partire dall’inizio del 2017, la risposta in questo commento lavori:

git fetch <origin-name> <branch-name> ti abbassa il ramo.Sebbene questo non esegua il pull di tutti i rami contemporaneamente, puoi eseguirlo singolarmente per ramo.

Answer 29

Ecco un altro breve comando a una linea che crea filiali locali per tutte le filiali remote:

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

Funziona correttamente anche se sono già state create le filiali locali di tracciamento.Puoi chiamarlo dopo il primo git clone o in qualsiasi momento successivo.

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

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

Answer 30

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