it-swarm-tr.com

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

Her ikisi de GitHub 'e itilmiş bir master ve development dalına sahibim. cloned, pulled ve fetched var, ancak master şubesinden başka bir şey alamıyorum.

Belli bir şeyi özlediğimden eminim, ancak kılavuzu okudum ve hiç neşe alamıyorum.

3746
Peter Coulton

Öncelikle, bir uzaktan kumandayı Git deposunu ve cd içine klonlayın:

$ 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ı -a bayrağını kullanarak görebilirsiniz:

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

Sadece yukarı akış dalına hızlıca göz atmak istiyorsanız, doğrudan kontrol edebilirsiniz:

$ git checkout Origin/experimental

Ancak bu şube üzerinde çalışmak istiyorsanız, aşağıdakiler tarafından otomatik olarak yapılan bir yerel izleme şubesi 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'

Son satır bazı insanları fırlatıyor: "Yeni dal" - ha? Asıl anlamı, dalın endeksten alınması ve sizin için yerel olarak yaratılmış olmasıdır. Önceki satırı, size dalın uzaktaki dalı izlemek üzere ayarlandığını söylediği için daha bilgilendiricidir; bu, genellikle Kaynak/dal_adı dalı 

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

$ git branch
* experimental
  master

Aslında git remote kullanarak birden fazla uzak depoyu izleyebilirsiniz.

$ 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ına dönüyor, bu yüzden neler olup bittiğini görmek için gitk komutunu çalıştırın:

$ gitk --all &
4191
emk

Aynı anda almak istediğiniz birçok uzak dalınız varsa, şunu yapın:

$ git pull --all

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

763
Gabe Kopley

Bu Bash script bana yardım etti:

#!/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 klonlama komutundan almış olduğunuz) dışındaki tüm uzak dallar için izleme dalları oluşturacaktır. Bence hala bir şey yapmanız gerekebilir. 

git fetch --all
git pull --all

emin olmak.

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 Her zamanki gibi: rm -rf universe'yi bildiğimiz gibi kopyalamadan önce kurulumunuzu test edin 

Bir liner için krediler cfi kullanıcısına gider

388
bigfish

--mirror seçeneğinin kullanılması remote izleme dallarını düzgün bir şekilde kopyalıyor gibi görünüyor .. __ Ancak, havuzu çıplak bir havuz olarak ayarlar, bu nedenle daha sonra normal bir depoya dönüştü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 şubelerle bir havuzu nasıl klonlarım?

300
Dave

İstediğiniz gibi "git checkout -b somebranch Origin/somebranch" sözdizimini kullanmadan bir şubeye kolayca geçebilirsiniz. Sadece yapabilirsiniz:

git checkout somebranch

Git otomatik olarak doğru olanı yapacak:

$ 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 olup olmadığını kontrol eder ve varsa, uzak bir şube olduğunu açıkça belirttiğiniz şekilde izler. Git 1.8.2.1'deki git-check-man kılavuz sayfasından:

<branch> bulunmazsa, ancak .__ 'da bir izleme şubesi var ise. tam olarak bir uzaktan kumanda (<remote> olarak adlandırın) ile eşleşen bir ad verin. eşittir

$ git checkout -b <branch> --track <remote>/<branch>
208
Nikos C.

Ile ilgili olarak,

$ git ödeme -b deneysel Menşei/deneysel

kullanma

$ git checkout -t Origin/experimental

veya daha ayrıntılı ama hatırlaması kolay

$ git checkout --track Origin/experimental

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

90
murphytalk

Yaptığınız getirinin tüm uzak dalları alması gerekir, ancak bunlar için yerel dallar oluşturmaz. Gitk kullanıyorsanız, "remotes/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 ödeme -b dev refs/uzaktan/Origin/dev

Hangi gibi bir şey döndürmeli:

Şube dev uzak şubeyi takip etmek için ayarlandı refs/remotes/Origin/dev .
Yeni bir şubeye geçiş "dev"

Şimdi, dev dalı üzerindeyken, "git pull" yerel dev'inizi uzak dev dalıyla aynı noktaya güncelleyecektir. Tüm dalları alacağına dikkat edin, ancak yalnızca bulunduğunuz ağacın üstüne çekin.

78
Luuk Paulussen

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

Belirli bir uzak dalın üzerinde çalışmak için, Çıkış uzaktan kumanda olduğu varsayılarak:

git checkout -b branch Origin/branchname
57
elmarco

Takma ad kullanın. Herhangi bir yerel Git tek gömlek bulunmamakla birlikte, kendi

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

ve sonra kullanın

git clone-branches
49
nobody

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

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

git branch -a Bu size tüm uzak şubeleri 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ı belirten * işaretine dikkat edin.

44
Sam

Neden sadece "usta" yı görüyorsun

git clone tüm uzak uzak şubeleri indirir, ancak dosyalar yeni deponuzda bulunsa bile, onları hala "uzak" olarak görür. Bunun bir istisnası var; bu, klonlama işleminin "master" olarak adlandırılan uzak daldan "master" adı verilen yerel bir dal oluşturmasıdır. Varsayılan olarak, git branch yalnızca yerel dalları gösterir, bu nedenle yalnızca "usta" yı görürsünüz.

git branch -a tüm şubeleri gösterir, uzak şubeler dahil .


Yerel şubeler nasıl alınır

Eğer bir dal üzerinde çalışmak istiyorsanız, muhtemelen bunun “yerel” bir versiyonunu isteyeceksiniz. Uzak şubelerden basitçe yerel şubeler oluşturmak için (kontrol etmeden ve böylece çalışma dizininizin içeriğini değiştirmeden) , şöyle yapabilirsiniz:

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

Bu örnekte, branchone, Origin/branchone tabanlı olarak oluşturduğunuz yerel bir dalın adıdır; bunun yerine farklı adlarla yerel şubeler oluşturmak istiyorsanız, bunu yapabilirsiniz:

git branch localbranchname Origin/branchone

Yerel bir şube oluşturduktan sonra, bunu git branch ile görebilirsiniz (yerel şubeleri görmek için -a'ye ihtiyacınız olmadığını unutmayın).

43
Cerran

Her zamankinden daha iyi geç, 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, tüm şubeleriyle birlikte uzak deponun tam bir kopyasına sahipsiniz (git branch ile doğrulayın). Eğer uzak reponuzun kendi uzaktan kumandası varsa, --mirror yerine --bare kullanabilirsiniz.

42
Jacob Fike

Sadece şunu 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, dalları bile, onları kontrol etmeniz gerekir, o zaman yerel şubeniz oluşturulur.

38
rapher

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

git clone <your_http_url>

Sadece ana şubeyi görseniz bile, tüm şubeleri görmek için "git şube-a" kullanabilirsiniz.

git branch -a

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

git checkout <your_branch_name>

"Git klonu" ndan sonra, uzak repo ile bağlantı kurmanıza gerek yok, wifi 'nizi kapattığınızda "git branch-a" ve "git checkout" başarıyla çalıştırılabilir. Bu yüzden "git klonu" yaptığınızda, tüm şubeleri uzak depodan kopyaladığını kanıtladı. Ondan sonra, uzak depoya ihtiyacınız yoktur, yerel bölgenizde zaten tüm şubelerin kodları vardır. 

23
Haimei

Deponun tamamını kopyalamak için bir git clone gerekiyordu. Klonlamayı deneyin ve ardından git branch -a komutunu çalıştırın. Bütün dalları listelemeli. Eğer "master" yerine "foo" dalına geçmek istiyorsanız, git checkout foo kullanın.

22
MattoxBeckman

Git_remote_branch aracımı kullanın (makinenizde Ruby yüklü olmalıdır). Uzak dal manipülasyonlarının kolayca ölü hale getirilmesi için özel olarak üretilmiştir.

Sizin adınıza bir işlem yaptığında, konsolda kırmızı renkte yazdırır. Zamanla, sonunda beynine sadık kalı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 yürütülmek yerine konsolunuza yazdırılacaktır.

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

Bunun alpha yazılımı olduğunu unutmayın ;-)

Grb yardımını çalıştırdığınızda yardım İşte:

 git_remote_branch sürüm 0.2.6 

 Kullanımı: 

 grb şube oluştur adı_adı [Origin_server] 

 grb yayınla dal_adı [Origin_server] 

 grb yeniden adlandırın dal_adı [Origin_server] 

 grb dal_adı sil [Origin_server] 

 grb track branch_name [Origin_server] 



 Notlar: 
 - Eğer Origin_server belirtilmemişse, 'Origin' ismi varsayalım. (git varsayılan). - Yeniden adlandır işlevselliği geçerli dalı değiştirir. Açıklama meta komutu: Ayrıca, 
 Anahtar kelimesi 'opens' ile herhangi bir komutu da hazırlayabilirsiniz. Komutu uygulamak yerine, git_remote_branch 
 Basitçe gerçekleştirmek için çalıştırmanız gereken komutların listesini çıkarır. Örnek: 
 grb açıkla create 
 grb açıkla my_branch github 

 Tüm komutların ayrıca takma adları vardır: 
 yarat: oluştur, yeni. sil: sil, yok et, öldür, kaldır, rm 
 yayınlamak: yayınlamak, remotize 
 yeniden adlandır: yeniden adlandır, rn, mv, taşı. parça: parça, takip et, al, yakala.
19
webmat

burada gördüğüm tüm cevaplar geçerlidir ancak bir havuzu klonlamanın ve tüm dalları aynı anda çekmenin daha temiz bir yolu vardır. 

Bir havuzu klonladığınızda, şubelerin tüm bilgileri gerçekte indirilir ancak şubeler gizlenir. Komut ile

$ git branch -a

sen deposunun tüm dalları gösterebilir ve komut ile

$ git checkout -b branchname Origin/branchname

daha sonra bir defada manuel olarak "indirebilirsiniz". 


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

  1. İlk adım

makinenizde yeni bir boş klasör oluşturun ve depodan .git klasörünün bir ayna kopyasını klonlayı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ştur, şimdi terminalden bir "ls -alt" komutu ile görebileceğiniz gizli bir .git klasörü var.

  1. İkinci adım

git yapılandırmalarının "bare" boole değerini false olarak değiştirerek bu depoyu boş (çıplak) bir depodan normal bir depoya geçirin:

$ git config --bool core.bare false
  1. Üçü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 depo haline getirir. 

$ git reset --hard

Artık sadece "git branch" komutunu yazıp tüm şubelerin indirildiğini görebilirsiniz. 

Bu, bir şubeyi tüm şubelerle aynı anda klonlayabileceğiniz hızlı yoldur, ancak bu şekilde her proje için yapmak istediğiniz bir şey değildir. 

15
FedericoCapaldo

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

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

Ancak uzak dallardan birinin örneğin; admin_master indirilmeyecek!

Özgün fikir için bigfish için teşekkürler

12
Tebe

OK, deponuzu kopyaladığınızda, orada tüm şubeleriniz var ...

Eğer sadece git branch yaparsanız, biraz gizlidirler ...

Yani tüm dalların adını görmek istiyorsanız, şunun gibi sadece --all flag ekleyin:

git branch --all veya git branch -a

Sadece şubeye ödeme yaparsanız, ihtiyacınız olan her şeyi alırsınız.

Peki ya siz klonladıktan sonra başka birisinin oluşturduğu şube?

Bu durumda, sadece yapın:

git fetch

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

Aynı anda hem almak hem de satın almak isterseniz, şunları yapabilirsiniz:

git fetch && git checkout your_branch_name

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

 git branch --all to get all branches

12
Alireza

Yerel bir repo'dan klonlamak git clone & git fetch ile çalışmaz: çok sayıda dal/etiket dokunmadan kalır.

Tüm dallar ve etiketlerle 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 kopya ile 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
11
raisercostin
#!/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 dal kodlarını yerel depoya çeker.

11
Albert.Qing

Kopyala yapıştır komut satırına yapıştırmak 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


Bu irade:

  1. ustayı kontrol et (bulunduğumuz şubeyi silebilmemiz için)
  2. kumandayı kontrol etmek için kontrol edin (sahip olduğunuz uzaktan kumandayı değiştirin)
  3. master, master ve HEAD .__ dışındaki tüm uzaktan kumanda dallarının arasından geçer.
    1. delete yerel şube (böylece zorla güncellenen dalları kontrol edebiliriz)
    2. uzaktaki şubeyi kontrol et
  4. ustayı kontrol et (bunun uğruna)

cevabı / VonC 'e dayanır

10
ikaruss

Origin kumandasındaki tüm git şubelerimi kontrol edebilmek için bu küçük Powershell fonksiyonlarını 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ım repo 'da daha fazla git işlevi bulunabilir.

8
gringo_dave

Aynısını yapmam gerekiyordu. İşte benim 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]
8
user43685

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

Bazen geçerli olanla doğrudan bağlantısı olmayan dallar/etiketler olabilir, bu nedenle git pull --all/git fetch --all bu durumda yardımcı olmaz, ancak bunları şöyle sıralayabilirsiniz:

git ls-remote -h -t Origin

ve ref adlarını bilerek elle getir.

Öyleyse hepsini getir için dene:

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

--depth=10000 parametresi, havuzu sığarsanız yardımcı olabilir.

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

git branch -avv

Eğer yukarıdakiler yardımcı olmazsa, izlenen listesine manuel olarak eksik dallar eklemeniz gerekir (bir şekilde kayboldukları için):

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

git remote set-branches tarafından:

git remote set-branches --add Origin missing_branch

bu nedenle, alma işleminden sonra remotes/Origin altında 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 alamıyorsanız, aşağıdakileri kontrol edin:

  • Uzaktan kumandalarınızı iki kez kontrol edin (git remote -v), ör.
    • git config branch.master.remote __Origin olduğunu doğrulayın.
    • Origin öğesinin doğru URL'yi: git remote show Origin ile işaret edip etmediğini kontrol edin (bu post ).
6
kenorb

2017 yılının başından itibaren cevap bu yorumdaki işler:

git fetch <Origin-name> <branch-name> şubeyi sizin için yıkar. Bu, tüm şubeleri aynı anda çekmese de, bu dal başına tekil olarak uygulayabilirsiniz.

6
ashes999

Bu cevapların hiçbiri, kullanıcı kimsenin doğru yolda olmadığı durumlar dışında kesildi.

Bir repoyu bir sunucudan/sistemden diğerine taşımakla ilgili sorun yaşıyordum. Repoyu klonladığımda, yalnızca master için yerel bir şube oluşturduğundan, yeni uzaktan kumandaya bastığımda yalnızca ana dalın itilmesi sağlandı.

Bu yüzden bu iki yöntemi çok faydalı 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
6
Gaui

Hatırlayabileceğiniz komutları kullan

Atlassian'ın Depo Barındırma Hizmeti olan Bitbucket'i kullanıyorum. Bu yüzden doktorlarını takip etmeye çalışıyorum. Ve bu benim için mükemmel çalışıyor. Aşağıdaki kolay ve kısa komutlarla uzaktaki şubenizi kontrol edebilirsiniz.

İlk önce havuzunuzu kopyalayın, ardından hedef klasöre geçin. Ve son fakat en az olmayan ve satın alma:

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

Bu kadar. İşte bir litte daha gerçek dünya örneği:

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

Komutlarla ilgili ayrıntılı bilgileri şu belgelerde bulabilirsiniz: Klon Komutu , Komut Al , Satın Alma Komutu

6
Phil

Burada, Tüm uzak dallar için yerel dallar oluşturan başka bir kısa tek satırlık komut:

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

Yerel şubeleri izlemek zaten oluşturulduysa da düzgün çalışır .. .. İlk git clone'dan sonra veya sonra istediğiniz zaman arayabilirsiniz.

Klonladıktan sonra master dalını kontrol ettirmeniz gerekmiyorsa, 

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

İşte awk kullanan bir cevap. Yeni bir depoda kullanılıyorsa, bu yöntem yeterlidir.

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

Mevcut dallar basitçe kontrol edilecektir veya içinde olduğu gibi ilan edilir, ancak çatışmaları önlemek için filtreler eklenebilir.

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

Bu cevap Nikos C. 's fikir ' i izler.


Alternatif olarak uzak şubeyi de belirleyebiliriz. Bu dayanarak murphytalk 's cevap .

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

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


Her iki komut da takma ad olabilir.

nobody 's answer referans olarak kullanarak, takma adları oluşturmak için aşağıdaki komutları kullanabiliriz:

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 track-all veya track-all-branches kullanırdım.

4
konsolebox

Orijinal repodaki git clone --mirror bunun için iyi çalışır.

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

Buraya 2 kuruş ekleyeceğim çünkü buraya yerel olarak sildiğim uzak bir şubeyi nasıl çekeceğimi bulmaya çalıştım. Köken benim değildi, ve her şeyi yeniden klonlama zahmetinden geçmek istemedim. 

Bu benim için çalıştı:

şubeyi yerel olarak yeniden oluşturmanız gerektiğini varsayalım:

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

Eğer gituser/master 'den sjp' ye çatalladım ve sjp/mynewbranch 'e dallandıysam şöyle olurdu:

$ 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
2
Camwyn

Partiye biraz geç kaldım, ama sanırım püf nokta:

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

Bu istenmeyen bir şey yaparsa bilmek isterim. Ancak, şu ana kadar bu benim için çalışıyor.

0
Andy

Bu varyasyon, her bir şubeyi tek tek kontrol etmek zorunda kalmadan tüm şubeler yerel olarak mevcut olacak şekilde uzak bir repo klonlayacaktır. Süslü betiklere gerek yok.

Örneğin, kopyalamak ve kopyalamak istediğiniz aynı adı taşıyan bir klasör oluşturun:

mkdir somerepo
cd somerepo

Şimdi bu komutları yapın, ancak gerçek repo username/reponame ile 

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

Voiala! orada tüm şubelere sahipsin!

0
lacostenycoder

Bir git projesinin tüm dallarını ve etiketlerini ayrı ayrı klasörlere anlık görüntüler olarak getirmek için kullanılan bash betiği. 

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

Belki doğrudan sorulan şey değil, ama bazı insanlar buraya bu çözümü aramaya gelebilir.

0
hfossli