Git'teki tüm uzak dalları nasıl kopyalayabilirim?

Her ikisi de GitHub'a itilen bir masterve bir şubem var . Ben ettik d, ed ve ed ama başka bir şey alamıyorsanız kalır şube arka.developmentclonepullfetchmaster

Eminim bariz bir şeyi kaçırıyorum ama kılavuzu okudum ve hiç neşe duymuyorum.

İlk olarak, klon uzak Git depo ve cd içine:

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

Ardından, deponuzdaki yerel şubelere bakın:

$ git branch
* master

Ancak deponuzda saklanan başka şubeler var! Bunları -abayrağı kullanarak görebilirsiniz :

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

Bir akış yukarı şubesine hızlıca göz atmak istiyorsanız, doğrudan kontrol edebilirsiniz:

$ git checkout origin/experimental

Ancak bu dalda çalışmak istiyorsanız, otomatik olarak şu şekilde yapılan bir yerel izleme dalı oluşturmanız gerekir:

$ git checkout experimental

ve göreceksin

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

Bu son satır bazı insanları atar: "Yeni dal" - ha? Bunun anlamı, şubenin dizinden alınması ve sizin için yerel olarak oluşturulmasıdır. Önceki o dal genellikle köken / branch_name dalı demektir uzak şube, izlemek üzere oluşturulmuş ediliyor anlatır gibi çizgi aslında daha bilgilendirici

Şimdi, yerel şubelerinize bakarsanız, göreceğiniz şey budur:

$ git branch
* experimental
  master

Aslında kullanarak birden fazla uzak havuzu izleyebilirsiniz 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

Bu noktada, işler oldukça çılgınlaşıyor, gitkneler olduğunu görmek için koşun :

$ gitk --all &

Aynı anda almak istediğiniz çok sayıda uzak dalınız varsa, şunları yapın:

$ git pull --all

Artık uzak depoya çarpmadan istediğiniz şubeyi istediğiniz gibi kontrol edebilirsiniz.

Bu Bash betiği bana yardımcı oldu:

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

Master (muhtemelen orijinal klon komutundan aldığınız) hariç tüm uzak dallar için izleme dalları oluşturacaktır. Bence hala bir

git fetch --all
git pull --all

emin olmak.

Bir astar : 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
Her zamanki gibi: rm -rf evrenini bildiğimiz gibi kopyalamadan önce kurulumunuzda test edin

Tek astarlı krediler cfi kullanıcısına gider

--mirrorSeçeneği kullanmak remoteizleme dallarını düzgün kopyalıyor gibi görünüyor . Ancak, depoyu çıplak bir havuz olarak ayarlar, bu nedenle daha sonra normal bir depoya geri döndürmeniz gerekir.

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

^{Referans: Git SSS: Uzaktan izlenen tüm şubelere sahip bir havuzu nasıl klonlayabilirim?}

Süslü "git checkout -b somebranch origin / somebranch" sözdizimini kullanmadan bir şubeye kolayca geçebilirsiniz. Sadece şunları yapabilirsiniz:

git checkout somebranch

Git otomatik olarak doğru şeyi yapar:

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

Git, aynı ada sahip bir dalın tam olarak bir uzaktan kumandada var olup olmadığını kontrol eder ve eğer varsa, uzak bir dal olduğunu açıkça belirtmiş olduğunuz gibi izler. Git 1.8.2.1'in git-checkout el sayfasından:

<branch> bulunmazsa, ancak tam olarak bir uzaktan kumandada eşleşen bir ada sahip bir izleme dalı varsa (<uzaktan> olarak adlandırın),

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

ile ilgili olarak,

$ git checkout -b deneysel kaynak / deneysel

kullanma

$ git checkout -t origin/experimental

ya da daha ayrıntılı ama hatırlaması daha kolay

$ git checkout --track origin/experimental

uzak bir depoyu izleme açısından daha iyi olabilir.

Yaptığınız getirme tüm uzak dalları almalı, ancak onlar için yerel dallar oluşturmayacak. Gitk kullanırsanız, "uzaktan kumanda / origin / dev" veya benzeri bir şey olarak tanımlanan uzak dalları görmelisiniz.

Uzak bir dalı temel alan yerel bir şube oluşturmak için aşağıdakileri yapın:

git checkout -b dev refs / uzaktan kumandalar / origin / dev

Hangi gibi bir şey dönmelidir:

Şube dev uzak şube ref / / uzaktan / kökeni / dev izlemek için kuruldu.
Yeni bir "dev" dalına geçildi

Şimdi, dev dalında olduğunuzda, "git pull" yerel geliştiricinizi uzak dev dalıyla aynı noktaya güncelleyecektir. Tüm dalları getireceğini unutmayın, ancak yalnızca bulunduğunuz dalı ağacın üstüne çekin.

"Git clone git: // location" yaptığınızda, tüm dallar ve etiketler getirilir.

Belirli bir uzak dalın üstünde çalışmak için, başlangıç ​​uzaklığı olduğu varsayılarak:

git checkout -b branch origin/branchname

Takma ad kullanın. Yerli Git tek gömlekleri olmamasına rağmen, kendi gömleklerinizi

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

ve sonra onu

git clone-branches

Neden sadece "efendi" yi görüyorsunuz?

git clonetüm uzak dalları indirir, ancak dosyalar yeni deponuzda bulunsa bile yine de "uzak" olarak kabul eder. Bunun bir istisnası vardır, bu da klonlama işleminin uzak daldan "master" adlı yerel bir dal oluşturmasıdır. Varsayılan olarak, git branchyalnızca yerel şubeleri gösterir, bu nedenle yalnızca "master" ı görürsünüz.

git branch -auzak dallar da dahil olmak üzere tüm dalları gösterir .

Yerel şubeler nasıl edinilir

Aslında bir dalda çalışmak istiyorsanız, muhtemelen "yerel" bir sürümünü isteyeceksiniz. Uzak şubelerden yerel şubeler oluşturmak için (onları kontrol etmeden ve böylece çalışma dizininizin içeriğini değiştirmeden) , bunu şu şekilde yapabilirsiniz:

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

Bu örnekte, branchoneoluşturduğunuz yerel bir şubenin adıdır origin/branchone; bunun yerine farklı adlara sahip yerel şubeler oluşturmak istiyorsanız, bunu yapabilirsiniz:

git branch localbranchname origin/branchone

Yerel bir şube oluşturduktan sonra, ile birlikte görebilirsiniz git branch(unutmayın, -ayerel şubeleri görmenize gerek yoktur ).

Bu çok karmaşık değil, çok basit ve basit adımlar aşağıdaki gibidir;

git fetch origin Bu, tüm uzak dalları yerelinize getirecektir.

git branch -a Bu size tüm uzak dalları gösterecektir.

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

Aşağıdaki komutla istediğiniz dalda olup olmadığınızı doğrulayın;

git branch

Çıktı böyle olacak;

*your current branch 
some branch2
some branch3 

Geçerli dalı gösteren * işaretine dikkat edin.

Hiç olmamasından daha iyi, ama işte bunu yapmanın en iyi yolu:

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

Bu noktada, uzak repo'nun tüm şubeleriyle birlikte tam bir kopyasına sahip olursunuz (ile doğrulayın git branch). Sen kullanabilirsiniz --mirroryerine --bareuzak repo kendi uzaktan kumanda varsa.

Sadece bunu yap:

$ 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

Gördüğünüz gibi, 'git clone git: //example.com/myprojectt' her şeyi getirir, şubeleri bile, sadece onları kontrol etmeniz gerekir, ardından yerel şubeniz oluşturulur.

Tüm dalları almak için sadece "git clone" kullanmanız gerekir.

git clone <your_http_url>

Sadece ana dalı görseniz bile, tüm dalları görmek için "git branch -a" kullanabilirsiniz.

git branch -a

Ve zaten sahip olduğunuz herhangi bir şubeye geçebilirsiniz.

git checkout <your_branch_name>

Eğer "git klon" sonra, uzak repo ile bağlanmak gerekmez endişelenmeyin, "git branch -a" ve "git checkout" wifi kapattığınızda başarıyla çalıştırılabilir. Yani "git klonu" yaptığınızda, uzak repodaki tüm dalları kopyalamış olduğu kanıtlanmıştır. Bundan sonra, uzak repoya ihtiyacınız yok, yerel olarak zaten tüm şubelerin kodları var.

A'nın git clonetüm deposu kopyalaması gerekiyor. Klonlamayı deneyin ve ardından çalıştırın git branch -a. Tüm dalları listelemelidir. O zaman "master" yerine "foo" dalına geçmek istiyorsanız, kullanın git checkout foo.

Aracımı kullan git_remote_branch (makinenize Ruby yüklemeniz gerekir). Uzaktan şube manipülasyonlarını kolaylaştırmak için özel olarak üretilmiştir.

Sizin adınıza her işlem yaptığında, konsolda kırmızı olarak yazdırır. Zamanla, nihayet beynine yapışırlar :-)

Grb'nin sizin adınıza komut çalıştırmasını istemiyorsanız, sadece 'açıkla' özelliğini kullanın. Komutlar sizin için yerine konsolunuza yazdırılacaktır.

Son olarak, ezberlemeyi kolaylaştırmak için tüm komutların takma adları vardır.

Bu alfa yazılımı olduğunu unutmayın ;-)

Grb help komutunu çalıştırdığınızda yardım:

git_remote_branch sürüm 0.2.6

  Kullanımı:

  grb create_name [origin_server] 

  grb yayınla şube_adı [origin_server] 

  grb yeniden adlandırın şube_adı [origin_server] 

  grb sil şube_adı [origin_server] 

  grb track branch_name [origin_server] 



  Notlar:
  - origin_server belirtilmezse, 'origin' adı varsayılır 
    (git varsayılanı)
  - Yeniden adlandırma işlevi geçerli dalı yeniden adlandırır

  Açıkla meta-komutu: herhangi bir komutu 
anahtar kelime 'açıkla'. Komutu yürütmek yerine git_remote_branch
gerçekleştirmek için çalıştırmanız gereken komutların listesini çıkarır 
bu hedef.

  Misal: 
    grb açıklamak oluştur
    grb açıklamak oluşturmak my_branch github

  Tüm komutların diğer adları da vardır:
  oluştur: oluştur, yeni
  Sil: sil, yok et, öldür, kaldır, rm
  yayınla: yayınla, remotize et
  yeniden adlandır: yeniden adlandır, rn, mv, taşıma
  parça: parça, takip, kapmak, getir

Burada gördüğüm tüm cevaplar geçerlidir, ancak bir havuzu klonlamanın ve tüm dalları bir kerede çekmenin çok daha temiz bir yolu vardır.

Bir havuzu klonladığınızda, dalların tüm bilgileri gerçekten indirilir, ancak dallar gizlenir. Komutu ile

$ git branch -a

deponun tüm dallarını ve komutuyla gösterebilirsiniz.

$ git checkout -b branchname origin/branchname

daha sonra bunları teker teker manuel olarak "indirebilirsiniz".

Ancak, çok sayıda şubesi olan bir repoyu klonlamak istediğinizde, yukarıda gösterilen tüm yollar, biraz karmaşık olsa da, göstereceğim çok daha temiz ve daha hızlı bir şekilde uzun ve sıkıcıdır. Bunu yapmak için üç adıma ihtiyacınız vardır:

1. İlk adım

makinenizde yeni bir boş klasör oluşturun ve .git klasörünün aynadaki bir kopyasını depodan kopyalayın:

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

my_repo_folder klasörü içindeki yerel depo hala boş, terminalden "ls -alt" komutuyla görebileceğiniz gizli bir .git klasörü var.

2. İkinci adım

git yapılandırmalarının "bare" boolean değerini false olarak değiştirerek bu havuzu boş (çıplak) bir depodan normal bir depoya değiştirin:

$ git config --bool core.bare false

3. Üçüncü adım

Geçerli klasörün içindeki her şeyi alın ve yerel makinedeki tüm dalları oluşturun, bu nedenle bunu normal bir repo yapar.

$ git reset --hard

Şimdi sadece "git branch" komutunu yazabilirsiniz ve tüm şubelerin indirildiğini görebilirsiniz.

Bu, bir git deposunu tüm şubelerle aynı anda klonlamanın hızlı yoludur, ancak her bir proje için bu şekilde yapmak istediğiniz bir şey değildir.

Yerel bir repodan klonlama git clone & git fetch ile çalışmaz: birçok şube / etiket kaldırılmayacak.

Tüm dalları ve etiketleri ile bir klon almak için.

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

Tüm dallar ve etiketlerle birlikte çalışan bir kopyayla bir klon almak için:

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

Tamam, repoyu klonladığında, orada bütün şubeler var ...

Sadece yaparsan git branch, bir çeşit gizli ...

Tüm şubelerin adını görmek istiyorsanız, sadece --allböyle bir bayrak ekleyin :

git branch --all veya git branch -a

Sadece şubeye ödeme yaparsanız, ihtiyacınız olan her şeyi elde edersiniz.

Peki, klonlamadan sonra başka biri tarafından oluşturulan dalın durumu ne olacak?

Bu durumda, şunları yapın:

git fetch

ve tüm şubeleri tekrar kontrol et ...

Aynı anda almak ve ödeme yapmak istiyorsanız, şunları yapabilirsiniz:

git fetch && git checkout your_branch_name

Ayrıca söylediklerimi basitleştirmek için aşağıdaki resmi oluşturdu:

Sorunun cevaplarından birine bakarak, kısaltmanın mümkün olduğunu fark ettim:

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

Ancak, uzak şubelerden biri örneğin admin_master olarak adlandırılırsa indirilmeyecektir!

Orijinal fikir için bigfish'e teşekkürler

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

Bu kod tüm uzak şube kodlarını yerel repoya çeker.

Komut satırına kopyala yapıştır için:

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

Daha fazla okunabilirlik için:

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. master'a göz at (böylece bulunduğumuz şubeyi silebiliriz)
2. Ödeme için uzaktan kumandayı seçin (sahip olduğunuz uzaktan kumandayla değiştirin)
3. Master ve HEAD hariç uzaktan kumandanın tüm dallarında döngü
   1. yerel şubeyi sil (böylece zorunlu olarak güncellenen şubelere göz atabiliriz)
   2. uzaktan kumandadan şubeyi kontrol et
4. efendiye göz at (uğruna)

Dayanarak cevap ait VonC .

Bu küçük Powershell işlevlerini, uzaktaki tüm git şubelerimi kontrol edebilmek için yazdım .

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

Git ayarları deposumda daha fazla git işlevi bulunabilir

İşte awk kullanan bir cevap. Yeni bir repoda kullanılırsa bu yöntem yeterli olmalıdır.

git branch -r | awk -F/ '{ system("git checkout " $NF) }'

Mevcut şubeler basitçe kullanıma alınacak ya da halihazırda olduğu gibi ilan edilecek, ancak çakışmaları önlemek için filtreler eklenebilir.

Ayrıca, açık bir git checkout -b <branch> -t <remote>/<branch>komut çağıracak şekilde değiştirilebilir .

Bu cevap şu Nikos C. 'nin fikri .

Alternatif olarak bunun yerine uzak dalı da belirleyebiliriz. Bu dayanmaktadır murphytalk 'ın cevabı .

git branch -r | awk '{ system("git checkout -t " $NF) }'

Çatışmalara ölümcül hata mesajları atıyor ama zararsız görüyorum.

Her iki komut da takma adlandırılabilir.

Kullanılması kimsenin 'ın cevabı referans olarak biz takma ad oluşturmak için aşağıdaki komutları sahip olabilir:

git config --global alias.clone-branches '! git branch -r | awk -F/ "{ system(\"git checkout \" \$NF) }"'
git config --global alias.clone-branches '! git branch -r | awk "{ system(\"git checkout -t \" \$NF) }"'

Şahsen ben kullanırım track-allya track-all-branches.

Ben de aynısını yapmam gerekiyordu. İşte Ruby senaryom.

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

Bu cevapların hiçbiri kesmedi, ancak kullanıcı doğru yolda değil.

Bir sunucuyu bir sunucudan / sistemden diğerine taşıma konusunda sorun yaşıyordum. Repoyu klonladığımda, sadece master için yerel bir şube yarattı, bu yüzden yeni uzaktan kumandayı ittiğimde sadece ana şube itildi.

Bu yüzden bu iki yöntemi ÇOK yararlı buldum. Umarım başka birine yardım ederler.

Yöntem 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

Yöntem 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

git clone --mirror orijinal repo bunun için iyi çalışıyor.

git clone --mirror /path/to/original.git
git remote set-url origin /path/to/new-repo.git
git push -u origin

Git genellikle (belirtilmediğinde) git ls-refsgeçmişlerini tamamlamak için gerekli nesnelerle birlikte bir veya daha fazla havuzdaki tüm dalları ve / veya etiketleri (refs, see:) getirir . Başka bir deyişle, önceden indirilmiş olan nesneler tarafından erişilebilen nesneleri getirir. Bakınız: Gerçekten ne yapar git fetch?

Bazen geçerli olana doğrudan bağlı olmayan dallarınız / etiketleriniz olabilir, bu nedenle git pull --all/ git fetch --allbu durumda yardımcı olmaz, ancak bunları şu şekilde listeleyebilirsiniz:

git ls-remote -h -t origin

ve ref adlarını bilerek bunları manuel olarak getirin.

Yani için hepsini getir , deneyin:

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

^{--depth=10000Eğer depo shallowed verdiyseniz parametre yardımcı olabilir.}

Ardından tüm şubelerinizi tekrar kontrol edin:

git branch -avv

Yukarıdakiler yardımcı olmazsa, izlenen listeye eksik dalları manuel olarak eklemeniz gerekir (bir şekilde kayboldukları için):

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

tarafından git remote set-branchesgibi:

git remote set-branches --add origin missing_branch

remotes/origingetirme işleminden sonra görünebilir :

$ 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

Sorun giderme

Ana daldan başka bir şey hala alamıyorsanız, aşağıdakileri kontrol edin:

• Uzaktan kumandalarınızı tekrar kontrol edin (git remote -v ) , ör.
  • Doğrulama git config branch.master.remoteolduğunuorigin .
  • Olmadığını kontrol edin origin: aracılığıyla doğru URL'ye noktaları git remote show origin(bu bkz yazı ).

2017 başında, bu yorumun cevabı işe yarıyor:

git fetch <origin-name> <branch-name>şubeyi sizin için indiriyor. Bu, tüm dalları bir kerede çekmemesine rağmen, bu şube başına tek tek çalıştırabilirsiniz.

İşte tüm uzak dallar için yerel dallar oluşturan bir kısa tek satırlık komut:

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

Yerel şubeleri izleme zaten oluşturulmuşsa da düzgün çalışır. İlkinden sonra git cloneveya daha sonra istediğiniz zaman arayabilirsiniz .

masterKlonlamadan sonra şubenin kontrol edilmesine gerek yoksa ,

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