จะทำการโคลนนิ่งรีโมตทั้งหมดใน Git ได้อย่างไร?

ฉันมีmasterและdevelopmentสาขาทั้งผลักดันให้GitHub ฉันcloned, pulled และfetched แต่ฉันยังคงไม่สามารถรับสิ่งอื่นนอกเหนือจากmasterสาขากลับ

ฉันแน่ใจว่าฉันพลาดอะไรบางอย่างที่ชัดเจน แต่ฉันได้อ่านคู่มือแล้วและฉันก็ไม่รู้สึกดีใจเลย

ขั้นแรกคัดลอกที่เก็บGitระยะไกลและcdไปที่:

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

ถัดไปดูสาขาในพื้นที่เก็บข้อมูลของคุณ:

$ git branch
* master

แต่มีสาขาอื่นซ่อนตัวอยู่ในที่เก็บของคุณ! คุณสามารถดูสิ่งเหล่านี้ได้โดยใช้-aธง:

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

หากคุณเพียงต้องการที่จะมองอย่างรวดเร็วที่สาขาต้นน้ำคุณสามารถตรวจสอบได้โดยตรง:

$ git checkout origin/experimental

แต่ถ้าคุณต้องการทำงานในสาขานั้นคุณจะต้องสร้างสาขาการติดตามในพื้นที่ซึ่งดำเนินการโดยอัตโนมัติโดย:

$ git checkout experimental

และคุณจะเห็น

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

บรรทัดสุดท้ายนั้นทำให้บางคน: "สาขาใหม่" - ใช่มั้ย ความหมายจริงๆคือสาขานั้นนำมาจากดัชนีและสร้างขึ้นในเครื่องสำหรับคุณ ก่อนหน้านี้สายเป็นจริงข้อมูลมากขึ้นตามที่บอกคุณว่าสาขาจะถูกสร้างขึ้นมาเพื่อติดตามสาขาที่ห่างไกลซึ่งมักจะหมายถึงแหล่งที่มา / สาขา branch_name

ตอนนี้ถ้าคุณดูสาขาท้องถิ่นของคุณนี่คือสิ่งที่คุณจะเห็น:

$ git branch
* experimental
  master

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

เมื่อมาถึงจุดนี้สิ่งต่าง ๆ ก็เริ่มค่อนข้างบ้าคลั่งดังนั้นgitkโปรดลองดูว่าเกิดอะไรขึ้น:

$ gitk --all &

หากคุณมีสาขาระยะไกลมากมายที่คุณต้องการดึงข้อมูลในครั้งเดียวให้ทำ:

$ git pull --all

ตอนนี้คุณสามารถเช็คเอาต์สาขาใดก็ได้ตามที่คุณต้องการโดยไม่ต้องกดที่เก็บระยะไกล

สคริปต์Bashนี้ช่วยฉันออก:

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

มันจะสร้างสาขาการติดตามสำหรับสาขาระยะไกลทั้งหมดยกเว้นต้นแบบ (ซึ่งคุณอาจได้รับจากคำสั่งโคลนต้นฉบับ) ฉันคิดว่าคุณยังอาจต้องทำ

git fetch --all
git pull --all

เพื่อให้แน่ใจว่า.

หนึ่งซับ : 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
ตามปกติ: ทดสอบในการตั้งค่าของคุณก่อนที่จะคัดลอก rm -rf จักรวาลที่เรารู้

เครดิตสำหรับหนึ่งสายการบินไปยังผู้ใช้ CFI

--mirrorดูเหมือนว่าใช้ตัวเลือกเพื่อคัดลอกremoteสาขาการติดตามอย่างถูกต้อง อย่างไรก็ตามมันตั้งค่าพื้นที่เก็บข้อมูลเป็นพื้นที่เก็บข้อมูลเปลือยดังนั้นคุณต้องเปลี่ยนกลับไปเป็นพื้นที่เก็บข้อมูลปกติหลังจากนั้น

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

^{การอ้างอิง: คำถามที่พบบ่อย Git: ฉันจะโคลนที่เก็บที่มีสาขาที่ติดตามจากระยะไกลทั้งหมดได้อย่างไร}

คุณสามารถเปลี่ยนเป็นสาขาได้โดยไม่ต้องใช้ไวยากรณ์ "git checkout -b originbranch / somebranch" แฟนซี คุณสามารถทำได้:

git checkout somebranch

Git จะทำสิ่งที่ถูกต้องโดยอัตโนมัติ:

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

Git จะตรวจสอบว่าสาขาที่มีชื่อเดียวกันนั้นมีอยู่ในรีโมตเดียวหรือไม่และหากเป็นเช่นนั้นมันจะติดตามแบบเดียวกับที่คุณระบุไว้อย่างชัดเจนว่าเป็นสาขาระยะไกล จากหน้าคนชำระเงิน git ของ Git 1.8.2.1:

หากไม่พบ <branch> แต่มีสาขาการติดตามอยู่ในรีโมทหนึ่งตัว (เรียกว่า <remote>) ด้วยชื่อที่ตรงกันให้ถือว่าเหมือนกับ

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

เกี่ยวกับ,

$ git checkout -b แหล่งกำเนิดการทดลอง / การทดลอง

การใช้

$ git checkout -t origin/experimental

หรือยิ่งละเอียดมากขึ้น แต่ง่ายต่อการจดจำ

$ git checkout --track origin/experimental

อาจดีกว่าในแง่ของการติดตามที่เก็บระยะไกล

การดึงข้อมูลที่คุณกำลังทำควรจะได้รับสาขาระยะไกลทั้งหมด แต่จะไม่สร้างสาขาท้องถิ่นให้พวกเขา หากคุณใช้ gitk คุณจะเห็นสาขาระยะไกลที่อธิบายว่า "รีโมต / แหล่งกำเนิด / dev" หรือสิ่งที่คล้ายกัน

ในการสร้างสาขาในพื้นที่โดยยึดตามสาขาระยะไกลให้ทำดังนี้

git checkout -b dev อ้างอิง / รีโมท / กำเนิด / dev

ซึ่งควรส่งคืนสิ่งที่ชอบ:

Branch dev ตั้งค่าให้ติดตามการอ้างอิงรีโมต / รีโมท / แหล่งกำเนิด / dev ของรีโมตสาขา
เปลี่ยนเป็น "dev" สาขาใหม่

ตอนนี้เมื่อคุณอยู่ในสาขา dev "git pull" จะอัปเดต dev ในพื้นที่ของคุณเป็นจุดเดียวกับสาขา dev ระยะไกล โปรดทราบว่ามันจะดึงกิ่งก้านสาขาทั้งหมด แต่ดึงกิ่งที่คุณอยู่บนต้นไม้

เมื่อคุณทำ "git clone git: // location" จะดึงสาขาและแท็กทั้งหมด

เพื่อทำงานบนสุดของสาขาระยะไกลที่เฉพาะเจาะจงสมมติว่ามันเป็นจุดกำเนิดระยะไกล:

git checkout -b branch origin/branchname

ใช้นามแฝง แม้ว่าจะไม่มี linet หนึ่ง Git พื้นเมืองคุณสามารถกำหนดของคุณเองเป็น

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

แล้วใช้มันเป็น

git clone-branches

ทำไมคุณเห็น "อาจารย์" เท่านั้น

git cloneดาวน์โหลดสาขาระยะไกลทั้งหมด แต่ยังถือว่าพวกเขาเป็น "ระยะไกล" แม้ว่าไฟล์จะอยู่ในที่เก็บใหม่ของคุณ มีข้อยกเว้นหนึ่งข้อสำหรับเรื่องนี้ซึ่งก็คือกระบวนการโคลนสร้างสาขาท้องถิ่นที่เรียกว่า "ต้นแบบ" จากสาขาระยะไกลที่เรียกว่า "ต้นแบบ" ตามค่าเริ่มต้นgit branchจะแสดงเฉพาะสาขาในพื้นที่ซึ่งเป็นสาเหตุที่คุณเห็นเฉพาะ "ต้นแบบ" เท่านั้น

git branch -aแสดงให้เห็นทุกสาขา, รวมทั้งสาขาที่ห่างไกล

วิธีการรับสาขาท้องถิ่น

หากคุณต้องการทำงานในสาขาคุณอาจต้องการรุ่น "ท้องถิ่น" หากต้องการสร้างสาขาท้องถิ่นจากสาขาระยะไกล(โดยไม่ต้องตรวจสอบและเปลี่ยนเนื้อหาของไดเรกทอรีการทำงานของคุณ)คุณสามารถทำสิ่งนี้:

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

ในตัวอย่างนี้branchoneเป็นชื่อของสาขาในประเทศที่คุณกำลังสร้างอยู่บนพื้นฐานของorigin/branchone; หากคุณต้องการสร้างสาขาท้องถิ่นที่มีชื่อแตกต่างกันคุณสามารถทำได้:

git branch localbranchname origin/branchone

เมื่อคุณสร้างสาขาท้องถิ่นแล้วคุณสามารถดูได้ด้วยgit branch(โปรดจำไว้ว่าคุณไม่จำเป็นต้อง-aดูสาขาในท้องถิ่น)

นี่ไม่ซับซ้อนเกินไปขั้นตอนที่ง่ายและตรงไปตรงมามีดังนี้

git fetch origin สิ่งนี้จะนำกิ่งไม้ที่อยู่ห่างไกลมาสู่ท้องที่ของคุณ

git branch -a นี่จะแสดงให้คุณเห็นทุกสาขาที่อยู่ห่างไกล

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

ตรวจสอบว่าคุณอยู่ในสาขาที่ต้องการโดยคำสั่งดังต่อไปนี้;

git branch

ผลลัพธ์จะเป็นเช่นนี้

*your current branch 
some branch2
some branch3 

สังเกตเห็นเครื่องหมาย * ที่แสดงถึงสาขาปัจจุบัน

ดีกว่าไม่สาย แต่นี่เป็นวิธีที่ดีที่สุดในการทำสิ่งนี้:

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

ณ จุดนี้คุณมีสำเนา repo ระยะไกลที่สมบูรณ์พร้อมด้วยสาขาทั้งหมดของมัน (ยืนยันด้วยgit branch) คุณสามารถใช้--mirrorแทน--bareถ้า repo ระยะไกลของคุณมีรีโมทของตัวเอง

แค่ทำสิ่งนี้:

$ 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

คุณเห็นแล้วว่า 'git clone git: //example.com/myprojectt' ดึงข้อมูลทุกอย่างแม้แต่กิ่งก้านคุณต้องชำระเงินพวกเขาจากนั้นสาขาท้องถิ่นของคุณจะถูกสร้างขึ้น

คุณจะต้องใช้ "git clone" เพื่อรับทุกสาขา

git clone <your_http_url>

แม้ว่าคุณจะเห็นเฉพาะสาขาหลักคุณสามารถใช้ "git branch -a" เพื่อดูสาขาทั้งหมด

git branch -a

และคุณสามารถเปลี่ยนเป็นสาขาใดก็ได้ที่คุณมีอยู่แล้ว

git checkout <your_branch_name>

ไม่ต้องกังวลว่าหลังจากคุณ "git clone" คุณไม่จำเป็นต้องเชื่อมต่อกับ repo ระยะไกล "git branch -a" และ "git checkout" สามารถทำงานได้สำเร็จเมื่อคุณปิด wifi ดังนั้นจึงพิสูจน์ได้ว่าเมื่อคุณทำ "git clone" มันได้ทำการคัดลอกกิ่งทั้งหมดจาก repo ระยะไกลแล้ว หลังจากนั้นคุณไม่จำเป็นต้องซื้อ repo ระยะไกลท้องถิ่นของคุณมีรหัสสาขาทั้งหมดแล้ว

A git cloneควรจะคัดลอกที่เก็บทั้งหมด git branch -aลองโคลนมันและเรียกใช้ มันควรจะแสดงรายการทุกสาขา ถ้าท่านต้องการเปลี่ยนไปสาขา "foo" แทนที่จะเป็น "ต้นแบบ" git checkout fooการใช้งาน

ใช้เครื่องมือของฉันgit_remote_branch (คุณต้องติดตั้ง Ruby บนเครื่องของคุณ) มันถูกสร้างขึ้นโดยเฉพาะเพื่อให้การจัดการสาขาระยะไกลเป็นเรื่องง่าย

ทุกครั้งที่ดำเนินการในนามของคุณมันจะพิมพ์เป็นสีแดงที่คอนโซล เมื่อเวลาผ่านไปในที่สุดพวกเขาก็ติดอยู่ในสมองของคุณ :-)

หากคุณไม่ต้องการให้ grb รันคำสั่งในนามของคุณเพียงใช้คุณสมบัติ 'อธิบาย' คำสั่งจะถูกพิมพ์ไปยังคอนโซลของคุณแทนการดำเนินการสำหรับคุณ

ในที่สุดคำสั่งทั้งหมดมีนามแฝงเพื่อให้การท่องจำง่ายขึ้น

โปรดทราบว่านี่เป็นซอฟต์แวร์อัลฟ่า ;-)

นี่คือความช่วยเหลือเมื่อคุณเรียกใช้ความช่วยเหลือ grb:

git_remote_branch รุ่น 0.2.6

  การใช้งาน:

  grb สร้าง branch_name [origin_server] 

  grb เผยแพร่ branch_name [origin_server] 

  grb เปลี่ยนชื่อ branch_name [origin_server] 

  grb ลบ branch_name [origin_server] 

  ติดตาม GR_ branch_name [origin_server] 



  หมายเหตุ:
  - หากไม่ได้ระบุ origin_server ระบบจะถือว่าชื่อ 'ต้นกำเนิด' 
    (ค่าเริ่มต้นของคอมไพล์)
  - ฟังก์ชั่นการเปลี่ยนชื่อเปลี่ยนชื่อสาขาปัจจุบัน

  คำอธิบาย meta-command: คุณยังสามารถผนวกคำสั่งใด ๆ ด้วย 
คำหลัก 'อธิบาย' แทนที่จะเรียกใช้คำสั่ง git_remote_branch
จะเอาท์พุทรายการคำสั่งที่คุณต้องการเพื่อให้ทำงานได้ 
เป้าหมายนั้น

  ตัวอย่าง: 
    grb อธิบายการสร้าง
    grb อธิบายสร้าง my_branch github

  คำสั่งทั้งหมดมีนามแฝงด้วย:
  สร้าง: สร้างใหม่
  ลบ: ลบ, ทำลาย, ฆ่า, ลบ, rm
  เผยแพร่: เผยแพร่, Remotize
  เปลี่ยนชื่อ: เปลี่ยนชื่อ, rn, mv, move
  ติดตาม: ติดตามติดตามคว้าดึงข้อมูล

คำตอบทั้งหมดที่ฉันเห็นที่นี่ถูกต้อง แต่มีวิธีที่สะอาดกว่ามากในการโคลนที่เก็บและดึงสาขาทั้งหมดในครั้งเดียว

เมื่อคุณโคลนที่เก็บข้อมูลทั้งหมดของสาขาจะถูกดาวน์โหลดจริง แต่สาขาจะถูกซ่อน ด้วยคำสั่ง

$ git branch -a

คุณสามารถแสดงสาขาทั้งหมดของที่เก็บและด้วยคำสั่ง

$ git checkout -b branchname origin/branchname

จากนั้นคุณสามารถ "ดาวน์โหลด" ด้วยตนเองทีละรายการ

อย่างไรก็ตามเมื่อคุณต้องการที่จะลอกเลียนแบบ repo ที่มีกิ่งไม้มากมายวิธีที่แสดงอยู่ด้านบนนั้นยาวและน่าเบื่อเมื่อเทียบกับวิธีที่สะอาดกว่าและเร็วกว่าที่ฉันจะแสดงแม้ว่ามันจะซับซ้อนเล็กน้อย คุณต้องการสามขั้นตอนในการทำสิ่งนี้:

1. ขั้นแรก

สร้างโฟลเดอร์ว่างใหม่บนเครื่องของคุณและคัดลอกสำเนาของโฟลเดอร์. git จากที่เก็บ:

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

ที่เก็บโลคัลภายในโฟลเดอร์ my_repo_folder ยังคงว่างเปล่ามีเพียงโฟลเดอร์. git ที่ซ่อนอยู่ซึ่งคุณสามารถดูได้ด้วยคำสั่ง "ls -alt" จากเทอร์มินัล

2. ขั้นตอนที่สอง

เปลี่ยนที่เก็บนี้จากที่เก็บที่ว่างเปล่า (เปลือย) เป็นที่เก็บปกติโดยเปลี่ยนค่าบูลีน "bare" ของการกำหนดค่า git เป็น false:

$ git config --bool core.bare false

3. ขั้นตอนที่สาม

หยิบทุกอย่างที่อยู่ในโฟลเดอร์ปัจจุบันและสร้างกิ่งก้านทั้งหมดในเครื่องท้องถิ่นดังนั้นจึงเป็น repo ปกติ

$ git reset --hard

ดังนั้นตอนนี้คุณสามารถพิมพ์คำสั่ง "กิ่งสาขา" และคุณจะเห็นว่าสาขาทั้งหมดถูกดาวน์โหลด

นี่เป็นวิธีที่รวดเร็วที่คุณสามารถโคลนพื้นที่เก็บข้อมูลคอมไพล์กับสาขาทั้งหมดในครั้งเดียว แต่มันไม่ใช่สิ่งที่คุณต้องการทำสำหรับทุกโครงการในวิธีนี้

การโคลนนิ่งจาก repo ในพื้นที่จะไม่ทำงานกับ git clone & git fetch: กิ่ง / แท็กจำนวนมากจะยังไม่ถูกดึงออกมา

เพื่อให้ได้โคลนกับกิ่งและแท็กทั้งหมด

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

ในการรับโคลนที่มีสาขาและแท็กทั้งหมด แต่มีสำเนาที่ใช้งานได้:

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

ตกลงเมื่อคุณโคลน repo คุณมีสาขาทั้งหมดที่นั่น ...

หากคุณเพิ่งทำgit branchพวกเขาเป็นชนิดที่ซ่อนอยู่ ...

ดังนั้นหากคุณต้องการเห็นชื่อสาขาทั้งหมดเพียงเพิ่ม--allแฟลกแบบนี้:

git branch --all หรือ git branch -a

หากคุณเพียงแค่ชำระเงินที่สาขาคุณจะได้รับทุกอย่างที่ต้องการ

แต่ถ้าสาขาที่สร้างโดยคนอื่นหลังจากที่คุณโคลน?

ในกรณีนี้เพียงทำ:

git fetch

และตรวจสอบทุกสาขาอีกครั้ง ...

หากคุณต้องการดึงข้อมูลและชำระเงินในเวลาเดียวกันคุณสามารถทำได้:

git fetch && git checkout your_branch_name

สร้างภาพด้านล่างเพื่อให้คุณเข้าใจสิ่งที่ฉันพูดด้วย:

ดูหนึ่งในคำตอบของคำถามที่ฉันสังเกตเห็นว่าเป็นไปได้ที่จะย่อให้สั้นลง:

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

แต่ระวังถ้าหนึ่งในสาขาระยะไกลมีชื่อเป็นเช่น admin_master มันจะไม่ได้รับการดาวน์โหลด!

ขอบคุณ Bigfish สำหรับแนวคิดดั้งเดิม

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

รหัสเหล่านี้จะดึงรหัสสาขาระยะไกลทั้งหมดไปยัง repo ท้องถิ่น

สำหรับการคัดลอกวางลงในบรรทัดคำสั่ง:

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

สำหรับการอ่านเพิ่มเติม:

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. ตรวจสอบหลัก (เพื่อให้เราสามารถลบสาขาที่เราอยู่)
2. เลือกรีโมตเพื่อเช็คเอาต์ (เปลี่ยนเป็นรีโมตที่คุณมี)
3. วนซ้ำผ่านรีโมททั้งหมดยกเว้นมาสเตอร์และ HEAD
   1. ลบสาขาในพื้นที่ (เพื่อให้เราสามารถตรวจสอบสาขาที่อัปเดตแรง)
   2. ตรวจสอบสาขาจากระยะไกล
4. ตรวจสอบอาจารย์ (เพื่อประโยชน์ของมัน)

ขึ้นอยู่กับคำตอบของVonC

ฉันได้เขียนฟังก์ชั่นPowershellขนาดเล็กนี้เพื่อให้สามารถชำระเงินสาขา git ทั้งหมดของฉันซึ่งอยู่ห่างไกลจากแหล่งกำเนิด

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 เพิ่มเติมสามารถพบได้บนrepo settings git

นี่คือคำตอบที่ใช้ awk วิธีนี้ควรพอเพียงถ้าใช้กับ repo ใหม่

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

สาขาที่มีอยู่จะถูกเช็คเอาท์หรือประกาศเป็นสาขาอยู่แล้ว แต่สามารถเพิ่มตัวกรองเพื่อหลีกเลี่ยงความขัดแย้ง

มันยังสามารถแก้ไขได้ดังนั้นจึงเรียกgit checkout -b <branch> -t <remote>/<branch>คำสั่งที่ชัดเจน

คำตอบนี้ดังนี้Nikos ซี 's ความคิด

หรือเราสามารถระบุสาขาระยะไกลแทน นี้อยู่บนพื้นฐานmurphytalk 's คำตอบ

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

มันส่งข้อความแสดงข้อผิดพลาดร้ายแรงถึงข้อขัดแย้ง แต่ฉันเห็นว่าไม่เป็นอันตราย

คำสั่งทั้งสองสามารถเป็นนามแฝง

ใช้คำตอบของไม่มีใครเป็นข้อมูลอ้างอิงเราสามารถมีคำสั่งต่อไปนี้เพื่อสร้างนามแฝง:

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

ส่วนตัวผมต้องการใช้หรือtrack-alltrack-all-branches

ฉันต้องการทำสิ่งเดียวกัน นี่คือสคริปต์Rubyของฉัน

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

ไม่มีคำตอบใด ๆ ที่ถูกตัดออกไปยกเว้นผู้ใช้ที่ไม่มีใครติดตามถูกต้อง

ฉันมีปัญหาในการย้าย repo จากเซิร์ฟเวอร์ / ระบบหนึ่งไปยังอีกระบบหนึ่ง เมื่อฉันโคลน repo มันสร้างเฉพาะสาขาในท้องถิ่นสำหรับต้นแบบดังนั้นเมื่อฉันผลักไปที่รีโมตใหม่มีการผลักสาขาหลักเท่านั้น

ดังนั้นฉันจึงพบว่าทั้งสองวิธีมีประโยชน์มาก หวังว่าพวกเขาจะช่วยคนอื่น

วิธีที่ 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

วิธีที่ 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 ใน repo เดิมทำงานได้ดีสำหรับเรื่องนี้

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

โดยทั่วไป Git (เมื่อไม่ได้ระบุ) จะดึงสาขาและ / หรือแท็กทั้งหมด (อ้างอิงโปรดดู:) git ls-refsจากที่เก็บอื่น ๆ หนึ่งแห่งขึ้นไปพร้อมกับวัตถุที่จำเป็นในการเติมเต็มประวัติของพวกเขา กล่าวอีกนัยหนึ่งคือดึงวัตถุที่สามารถเข้าถึงได้โดยวัตถุที่ดาวน์โหลดมาแล้ว ดู: ทำอะไรgit fetchจริงเหรอ?

บางครั้งคุณอาจมีสาขา / แท็กที่ไม่ได้เชื่อมต่อโดยตรงกับสาขาปัจจุบันดังนั้นgit pull --all/ git fetch --allจะไม่ช่วยในกรณีนั้น แต่คุณสามารถแสดงรายการโดย:

git ls-remote -h -t origin

และดึงข้อมูลด้วยตนเองโดยรู้จักชื่ออ้างอิง

หากต้องการดึงข้อมูลทั้งหมดให้ลอง:

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

^{--depth=10000พารามิเตอร์อาจช่วยถ้าคุณได้ shallowed พื้นที่เก็บข้อมูล}

จากนั้นตรวจสอบสาขาทั้งหมดของคุณอีกครั้ง:

git branch -avv

ถ้าข้างต้นไม่ช่วยคุณต้องเพิ่มสาขาที่ขาดหายไปด้วยตนเองในรายการที่ติดตาม (เพราะพวกเขาหลงทาง)

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

โดยgit remote set-branchesชอบ:

git remote set-branches --add origin missing_branch

ดังนั้นจึงอาจปรากฏภายใต้การremotes/originดึงข้อมูล:

$ 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

การแก้ไขปัญหา

หากคุณยังไม่สามารถรับสิ่งอื่นนอกเหนือจากสาขาหลักให้ตรวจสอบสิ่งต่อไปนี้:

• ตรวจสอบรีโมทของคุณอีกครั้ง ( git remote -v) เช่น
  • ตรวจสอบว่าเป็นgit config branch.master.remoteorigin
  • ตรวจสอบว่าoriginชี้ไปยัง URL ที่ถูกต้องผ่าน: git remote show origin(ดูโพสต์นี้)

ตั้งแต่ต้นปี 2560 คำตอบในความคิดเห็นนี้ใช้ได้ผล:

git fetch <origin-name> <branch-name>นำสาขาลงมาเพื่อคุณ แม้ว่าสิ่งนี้จะไม่ดึงสาขาทั้งหมดในครั้งเดียว แต่คุณสามารถดำเนินการต่อสาขาได้อย่างแปลกประหลาด

นี่เป็นอีกหนึ่งคำสั่งสั้นซับหนึ่งซึ่งสร้างสาขาท้องถิ่นสำหรับสาขาระยะไกลทั้งหมด:

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

มันทำงานได้อย่างถูกต้องเช่นกันหากสร้างการติดตามสาขาในพื้นที่อยู่แล้ว คุณสามารถโทรหามันหลังจากครั้งแรกgit cloneหรือเวลาใดก็ได้ในภายหลัง

หากคุณไม่จำเป็นต้องmasterเช็คเอาต์สาขาหลังจากการโคลนให้ใช้

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