Bagaimana cara mengkloning semua cabang jarak jauh di Git?

Saya memiliki masterdan developmentcabang, keduanya didorong ke GitHub . Saya sudah cloned, pulled, dan fetched, tetapi saya tetap tidak bisa mendapatkan apa pun selain mastercabang kembali.

Saya yakin saya kehilangan sesuatu yang jelas, tetapi saya telah membaca manual dan saya tidak mendapatkan sukacita sama sekali.

Pertama, klon repositori Git jarak jauh dan masukkan ke dalamnya:

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

Selanjutnya, lihat cabang lokal di repositori Anda:

$ git branch
* master

Tetapi ada cabang-cabang lain yang bersembunyi di repositori Anda! Anda dapat melihat ini menggunakan -aflag:

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

Jika Anda hanya ingin mengintip cabang hulu, Anda dapat memeriksanya secara langsung:

$ git checkout origin/experimental

Tetapi jika Anda ingin bekerja di cabang itu, Anda harus membuat cabang pelacakan lokal yang dilakukan secara otomatis dengan:

$ git checkout experimental

dan kamu akan lihat

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

Baris terakhir itu melempar beberapa orang: "Cabang baru" - ya? Apa artinya sebenarnya adalah bahwa cabang diambil dari indeks dan dibuat secara lokal untuk Anda. Baris sebelumnya sebenarnya lebih informatif karena memberitahu Anda bahwa cabang sedang disiapkan untuk melacak cabang jarak jauh, yang biasanya berarti cabang asal / branch_name

Sekarang, jika Anda melihat cabang lokal Anda, inilah yang akan Anda lihat:

$ git branch
* experimental
  master

Anda sebenarnya dapat melacak lebih dari satu repositori jarak jauh menggunakan 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

Pada titik ini, segalanya menjadi sangat gila, jadi lari gitkuntuk melihat apa yang terjadi:

$ gitk --all &

Jika Anda memiliki banyak cabang jarak jauh yang ingin Anda ambil sekaligus, lakukan:

$ git pull --all

Sekarang Anda dapat checkout cabang apa pun yang Anda butuhkan, tanpa mengenai repositori jarak jauh.

Skrip Bash ini membantu saya:

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

Ini akan membuat cabang pelacakan untuk semua cabang jarak jauh, kecuali master (yang mungkin Anda dapatkan dari perintah klon asli). Saya pikir Anda mungkin masih perlu melakukan

git fetch --all
git pull --all

untuk memastikan.

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
Seperti biasa: uji dalam pengaturan Anda sebelum menyalin rm -rf universe seperti yang kita kenal

Kredit untuk one-liner diberikan kepada pengguna cfi

Menggunakan --mirroropsi tampaknya menyalin remotecabang pelacakan dengan benar. Namun, ini mengatur repositori sebagai repositori kosong, jadi Anda harus mengubahnya kembali menjadi repositori normal setelahnya.

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

^{Referensi: FAQ Git: Bagaimana saya mengkloning repositori dengan semua cabang yang dilacak dari jarak jauh?}

Anda dapat dengan mudah beralih ke cabang tanpa menggunakan sintaks "git checkout -b somebranch origin / somebranch". Anda bisa melakukannya:

git checkout somebranch

Git secara otomatis akan melakukan hal yang benar:

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

Git akan memeriksa apakah cabang dengan nama yang sama ada di persis satu remote, dan jika ya, itu melacaknya dengan cara yang sama seperti jika Anda secara eksplisit menentukan bahwa itu adalah cabang jarak jauh. Dari halaman manual git-checkout dari Git 1.8.2.1:

Jika <cabang> tidak ditemukan tetapi ada cabang pelacakan di persis satu remote (sebut saja <remote>) dengan nama yang cocok, perlakukan setara dengan

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

Mengenai,

$ git checkout -b asal eksperimental / eksperimental

menggunakan

$ git checkout -t origin/experimental

atau lebih verbose tetapi lebih mudah diingat

$ git checkout --track origin/experimental

mungkin lebih baik, dalam hal melacak repositori jarak jauh.

Pengambilan yang Anda lakukan harus mendapatkan semua cabang jarak jauh, tetapi itu tidak akan membuat cabang lokal untuk mereka. Jika Anda menggunakan gitk, Anda akan melihat cabang jarak jauh yang dijelaskan sebagai "remote / origin / dev" atau yang serupa.

Untuk membuat cabang lokal berdasarkan cabang jarak jauh, lakukan sesuatu seperti:

git checkout -b ref ref / remote / origin / dev

Yang seharusnya mengembalikan sesuatu seperti:

Cabang dev diatur untuk melacak referensi / remote cabang remote / asal / dev.
Beralih ke "dev" cabang baru

Sekarang, ketika Anda berada di cabang dev, "git pull" akan memperbarui dev lokal Anda ke titik yang sama dengan cabang dev jarak jauh. Perhatikan bahwa ia akan mengambil semua cabang, tetapi hanya tarik cabang yang ada di bagian atas pohon.

Ketika Anda melakukan "git clone git: // location", semua cabang dan tag diambil.

Untuk bekerja di atas cabang jarak jauh tertentu, dengan asumsi itu adalah asal jarak jauh:

git checkout -b branch origin/branchname

Gunakan alias. Meskipun tidak ada Git satu-liner asli, Anda dapat mendefinisikannya sendiri

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

dan kemudian menggunakannya sebagai

git clone-branches

Mengapa Anda hanya melihat "master"

git clonemengunduh semua cabang jarak jauh tetapi masih menganggapnya "jauh", meskipun file-file tersebut berada di repositori baru Anda. Ada satu pengecualian untuk ini, yaitu proses kloning membuat cabang lokal yang disebut "master" dari cabang jarak jauh yang disebut "master". Secara default, git branchhanya menampilkan cabang lokal, itulah sebabnya Anda hanya melihat "master".

git branch -amemperlihatkan semua cabang, termasuk cabang yang jauh .

Cara mendapatkan cabang lokal

Jika Anda benar-benar ingin bekerja di cabang, Anda mungkin menginginkan versi "lokal". Untuk hanya membuat cabang lokal dari cabang jarak jauh (tanpa memeriksanya dan dengan demikian mengubah isi direktori kerja Anda) , Anda dapat melakukannya seperti ini:

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

Dalam contoh ini, branchoneadalah nama cabang lokal yang Anda buat berdasarkan origin/branchone; jika Anda ingin membuat cabang lokal dengan nama berbeda, Anda bisa melakukan ini:

git branch localbranchname origin/branchone

Setelah membuat cabang lokal, Anda dapat melihatnya dengan git branch(ingat, Anda tidak perlu -amelihat cabang lokal).

Ini tidak terlalu rumit, langkah yang sangat sederhana dan lurus adalah sebagai berikut;

git fetch origin Ini akan membawa semua cabang jarak jauh ke lokal Anda.

git branch -a Ini akan menunjukkan semua cabang jarak jauh.

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

Verifikasi apakah Anda berada di cabang yang diinginkan dengan perintah berikut;

git branch

Outputnya akan seperti ini;

*your current branch 
some branch2
some branch3 

Perhatikan tanda * yang menunjukkan cabang saat ini.

Lebih baik terlambat daripada tidak pernah, tetapi di sini adalah cara terbaik untuk melakukan ini:

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

Pada titik ini Anda memiliki salinan lengkap repo jarak jauh dengan semua cabangnya (verifikasi dengan git branch). Anda dapat menggunakan --mirroralih-alih --barejika repo jarak jauh Anda memiliki remote-nya sendiri.

Lakukan ini:

$ 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

Anda lihat, 'git clone git: //example.com/myprojectt' mengambil semuanya, bahkan cabang, Anda hanya perlu checkout, lalu cabang lokal Anda akan dibuat.

Anda hanya perlu menggunakan "git clone" untuk mendapatkan semua cabang.

git clone <your_http_url>

Meskipun Anda hanya melihat cabang master, Anda dapat menggunakan "git branch -a" untuk melihat semua cabang.

git branch -a

Dan Anda dapat beralih ke cabang apa pun yang sudah Anda miliki.

git checkout <your_branch_name>

Jangan khawatir setelah Anda "git clone", Anda tidak perlu terhubung dengan repo jarak jauh, "git branch -a" dan "git checkout" dapat berjalan dengan sukses ketika Anda menutup wifi Anda. Jadi terbukti bahwa ketika Anda melakukan "git clone", ia sudah menyalin semua cabang dari repo jarak jauh. Setelah itu, Anda tidak perlu repo jarak jauh, lokal Anda sudah memiliki kode semua cabang.

A git cloneseharusnya menyalin seluruh repositori. Coba kloning, lalu jalankan git branch -a. Seharusnya daftar semua cabang. Jika kemudian Anda ingin beralih ke cabang "foo" alih-alih "master", gunakan git checkout foo.

Gunakan alat saya git_remote_branch (Anda perlu menginstal Ruby pada mesin Anda). Itu dibangun khusus untuk membuat manipulasi cabang jauh mati mudah.

Setiap kali ia melakukan operasi atas nama Anda, ia mencetaknya dengan warna merah di konsol. Seiring waktu, mereka akhirnya menempel di otak Anda :-)

Jika Anda tidak ingin grb menjalankan perintah atas nama Anda, cukup gunakan fitur 'jelaskan'. Perintah akan dicetak ke konsol Anda alih-alih dieksekusi untuk Anda.

Akhirnya, semua perintah memiliki alias, untuk memudahkan menghafal.

Perhatikan bahwa ini adalah perangkat lunak alfa ;-)

Inilah bantuan ketika Anda menjalankan bantuan grb:

git_remote_branch versi 0.2.6

  Pemakaian:

  grb buat branch_name [origin_server] 

  grb publish branch_name [origin_server] 

  grb ganti nama branch_name [origin_server] 

  grb hapus branch_name [origin_server] 

  grb track branch_name [origin_server] 



  Catatan:
  - Jika origin_server tidak ditentukan, nama 'asal' diasumsikan 
    (default git)
  - Fungsi ganti nama mengubah nama cabang saat ini

  Jelaskan meta-command: Anda juga dapat menambahkan setiap perintah dengan 
kata kunci 'jelaskan'. Alih-alih mengeksekusi perintah, git_remote_branch
hanya akan menampilkan daftar perintah yang perlu Anda jalankan untuk menyelesaikannya 
tujuan itu.

  Contoh: 
    grb jelaskan buat
    grb jelaskan buat my_branch github

  Semua perintah juga memiliki alias:
  buat: buat, baru
  hapus: hapus, hancurkan, bunuh, hapus, rm
  publish: publish, remotize
  rename: rename, rn, mv, move
  track: track, follow, grab, fetch

semua jawaban yang saya lihat di sini valid tetapi ada cara yang jauh lebih bersih untuk mengkloning repositori dan menarik semua cabang sekaligus.

Ketika Anda mengkloning repositori, semua informasi cabang sebenarnya diunduh tetapi cabang disembunyikan. Dengan perintah itu

$ git branch -a

Anda bisa memperlihatkan semua cabang repositori, dan dengan perintah

$ git checkout -b branchname origin/branchname

Anda kemudian dapat "mengunduh" secara manual satu per satu.

Namun, ketika Anda ingin mengkloning repo dengan banyak cabang, semua cara yang diilustrasikan di atas panjang dan membosankan sehubungan dengan cara yang jauh lebih bersih dan lebih cepat yang akan saya tunjukkan, meskipun agak rumit. Anda perlu tiga langkah untuk mencapai ini:

1. Langkah pertama

buat folder kosong baru di mesin Anda dan tiru salinan mirror dari folder .git dari repositori:

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

repositori lokal di dalam folder my_repo_folder masih kosong, hanya ada folder .git tersembunyi sekarang yang bisa Anda lihat dengan perintah "ls -alt" dari terminal.

2. Tahap kedua

alihkan repositori ini dari repositori kosong (kosong) ke repositori biasa dengan mengalihkan nilai boolean "bare" dari konfigurasi git ke false:

$ git config --bool core.bare false

3. Langkah ketiga

Raih semua yang ada di dalam folder saat ini dan buat semua cabang pada mesin lokal, oleh karena itu buatlah ini repo yang normal.

$ git reset --hard

Jadi sekarang Anda cukup mengetik perintah "git branch" dan Anda dapat melihat bahwa semua cabang diunduh.

Ini adalah cara cepat di mana Anda dapat mengkloning git repositori dengan semua cabang sekaligus, tetapi itu bukan sesuatu yang ingin Anda lakukan untuk setiap proyek dengan cara ini.

Kloning dari repo lokal tidak akan berfungsi dengan git clone & git fetch: banyak cabang / tag akan tetap tidak diambil.

Untuk mendapatkan klon dengan semua cabang dan tag.

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

Untuk mendapatkan klon dengan semua cabang dan tag tetapi juga dengan copy pekerjaan:

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

BAIK, ketika Anda mengkloning repo Anda, Anda memiliki semua cabang di sana ...

Jika Anda melakukannya git branch , mereka agak tersembunyi ...

Jadi jika Anda ingin melihat semua nama cabang, cukup tambahkan --all bendera seperti ini:

git branch --all atau git branch -a

Jika Anda hanya checkout ke cabang, Anda mendapatkan semua yang Anda butuhkan.

Tetapi bagaimana jika cabang dibuat oleh orang lain setelah Anda mengkloning?

Dalam hal ini, lakukan saja:

git fetch

dan periksa semua cabang lagi ...

Jika Anda suka mengambil dan checkout pada saat yang sama, Anda dapat melakukan:

git fetch && git checkout your_branch_name

Juga buat gambar di bawah ini untuk menyederhanakan apa yang saya katakan:

Melihat salah satu jawaban untuk pertanyaan yang saya perhatikan adalah mungkin untuk mempersingkat:

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

Namun berhati-hatilah, jika salah satu cabang jarak jauh dinamai eg admin_master tidak akan diunduh!

Terima kasih kepada bigfish untuk ide orisinalnya

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

Kode ini akan menarik semua kode cabang jarak jauh ke repo lokal.

Untuk salin-tempel ke baris perintah:

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

Untuk lebih mudah diingat:

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. lihat master (sehingga kami dapat menghapus cabang tempat kami berada)
2. pilih remote untuk checkout (ubah ke remote apa pun yang Anda miliki)
3. loop melalui semua cabang remote kecuali master dan HEAD
   1. hapus cabang lokal (sehingga kami dapat memeriksa cabang yang diperbarui secara paksa)
   2. periksa cabang dari jarak jauh
4. lihat master (demi itu)

Berdasarkan jawaban dari VonC .

Saya menulis fungsi Powershell kecil ini untuk dapat mengecek semua cabang git saya, yang ada pada remote asal.

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

Lebih banyak fungsi git dapat ditemukan di repo pengaturan git saya

Inilah jawaban yang menggunakan awk. Metode ini sudah cukup jika digunakan pada repo baru.

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

Cabang yang ada hanya akan diperiksa, atau dinyatakan sudah ada di dalamnya, tetapi filter dapat ditambahkan untuk menghindari konflik.

Itu juga dapat dimodifikasi sehingga ia memanggil git checkout -b <branch> -t <remote>/<branch>perintah eksplisit .

Jawaban ini berikut Nikos C. 's ide .

Sebagai alternatif, kita dapat menentukan cabang jarak jauh sebagai gantinya. Hal ini didasarkan pada murphytalk 's jawaban .

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

Itu melempar pesan kesalahan fatal pada konflik tapi saya lihat itu tidak berbahaya.

Kedua perintah itu bisa alias.

Menggunakan tidak ada 's jawaban sebagai referensi, kita dapat memiliki perintah berikut untuk membuat alias:

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) }"'

Secara pribadi saya akan menggunakan track-allatau track-all-branches.

Saya perlu melakukan hal yang persis sama. Ini skrip Ruby saya .

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

Tidak satu pun dari jawaban ini yang memotongnya, kecuali pengguna tidak ada di jalur yang benar.

Saya mengalami masalah dengan memindahkan repo dari satu server / sistem ke yang lain. Ketika saya mengkloning repo, itu hanya membuat cabang lokal untuk master jadi ketika saya mendorong ke remote baru, hanya cabang master yang didorong.

Jadi saya menemukan dua metode ini SANGAT berguna. Semoga mereka membantu orang lain.

Metode 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

Metode 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 pada repo asli berfungsi dengan baik untuk ini.

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

Git biasanya (ketika tidak ditentukan) mengambil semua cabang dan / atau tag (referensi, lihat:) git ls-refsdari satu atau lebih repositori lainnya bersama dengan objek yang diperlukan untuk melengkapi sejarahnya. Dengan kata lain, ia mengambil objek yang bisa dijangkau oleh objek yang sudah diunduh. Lihat: Apa yang git fetchsebenarnya dilakukan?

Kadang-kadang Anda mungkin memiliki cabang / tag yang tidak terhubung langsung ke yang saat ini, jadi git pull --all/ saya git fetch --alltidak akan membantu dalam hal ini, tetapi Anda dapat mendaftar dengan:

git ls-remote -h -t origin

dan ambil secara manual dengan mengetahui nama-nama referensi.

Jadi untuk mengambil semuanya , coba:

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

^{The --depth=10000parameter dapat membantu jika Anda sudah shallowed repositori.}

Kemudian periksa semua cabang Anda lagi:

git branch -avv

Jika di atas tidak membantu, Anda perlu menambahkan cabang yang hilang secara manual ke daftar yang dilacak (karena entah bagaimana tersesat):

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

dengan git remote set-branchessuka:

git remote set-branches --add origin missing_branch

jadi mungkin muncul di bawah remotes/originsetelah mengambil:

$ 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

Penyelesaian masalah

Jika Anda masih tidak bisa mendapatkan apa pun selain cabang utama, periksa yang berikut ini:

• Periksa ulang remote Anda ( git remote -v), mis
  • Validasi yang git config branch.master.remotemerupakan origin.
  • Periksa apakah originmenunjuk ke URL yang benar melalui: git remote show origin(lihat posting ini ).

Pada awal 2017, jawaban dalam komentar ini berfungsi:

git fetch <origin-name> <branch-name>membawa cabang ke bawah untuk Anda. Meskipun ini tidak menarik semua cabang sekaligus, Anda bisa menjalankan per-cabang ini secara tunggal.

Berikut ini perintah satu-liner pendek lain yang membuat cabang lokal untuk semua cabang jarak jauh:

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

Ini juga berfungsi dengan baik jika pelacakan cabang lokal sudah dibuat. Anda dapat memanggilnya setelah yang pertama git cloneatau beberapa saat kemudian.

Jika Anda tidak perlu mastermemeriksa cabang setelah kloning, gunakan

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