Git में सभी दूरस्थ शाखाओं को कैसे क्लोन करें?

Question

मैं एक है masterऔर एक developmentशाखा, दोनों को धक्का दे GitHub । मैंने cloned, pulled और fetched लिया है, लेकिन मैं masterशाखा के अलावा कुछ भी प्राप्त करने में असमर्थ हूं ।

मुझे यकीन है कि मुझे कुछ स्पष्ट याद आ रहा है, लेकिन मैंने मैनुअल पढ़ा है और मुझे बिल्कुल भी खुशी नहीं हो रही है।

Comments

यहां स्वीकृत उत्तर ( git branch -a) आपको दूरस्थ में शाखाएं दिखाता है, लेकिन यदि आप उनमें से किसी को भी जांचने का प्रयास करते हैं, तो आप 'अलग-थलग पड़ने' की स्थिति में होंगे। अगला उत्तर नीचे (दूसरा सबसे ऊपर) एक अलग सवाल का जवाब देता है (बुद्धि के लिए: सभी शाखाओं को कैसे खींचें, और, फिर, यह केवल उन लोगों के लिए काम करता है जिन्हें आप स्थानीय रूप से ट्रैक कर रहे हैं)। टिप्पणियों में से कई बताते हैं कि आप git branch -aपरिणामों को शेल स्क्रिप्ट के साथ पार्स कर सकते हैं जो स्थानीय रूप से सभी दूरस्थ शाखाओं को ट्रैक करेगा। सारांश: आप क्या चाहते हैं यह करने के लिए कोई देशी तरीका नहीं है और यह वैसे भी एक महान विचार नहीं हो सकता है।

— डे डेविस वाटरबरी

शायद पूरे फ़ोल्डर को पुराने ढंग से कॉपी करें? scp [e-mail]:/home/some_user/project_folder ~यकीन नहीं होता है कि अगर यह समाधान github के लिए काम करता है ..

— Snapfractalpop

यह कहने के बजाय "मुझे क्लोन किया गया है, खींचा गया है, और उठाया गया है," हमें निष्पादित किए गए सटीक आदेशों को दिखाने के लिए बहुत बेहतर है ।

— बॉब गिलमोर

यह हमेशा मुझे परेशान करता है कि "क्लोन" एक सटीक प्रति के अर्थ में क्यों नहीं है। यदि यह एक सटीक क्लोन है, तो क्या सभी शाखाओं को स्थानीय भंडार का हिस्सा नहीं होना चाहिए? मेरा मतलब है कि वितरित होने के बिंदु में से एक नहीं है? इसलिए जब कुछ रिपॉजिटरी चली गई तो आपके पास अभी भी हर चीज की पूरी कॉपी मौजूद है। या क्या यह तथाकथित "रिमोट" वास्तव में पहले से ही स्थानीय भंडार का हिस्सा है?

— हुगली

सभी उत्थान, उत्तर, उत्तर पर टिप्पणियों और विचारों की मनमौजी संख्या को देखते हुए, मुझे लगता है कि यह समय है जीआईटी ने ऐसा करने के लिए एक आदेश जोड़ा। और सही है आप @ सुग्गी, मेरे विचार बिल्कुल।

— SAN16ошƒаӽ

Answer 1

सबसे पहले, एक दूरस्थ Git रिपॉजिटरी और सीडी में क्लोन करें :

$ 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 &

Comments

कोई व्यक्ति सभी दूरस्थ शाखाओं को स्वचालित रूप से कैसे बना सकता है, उदाहरण के लिए प्रायोगिक / प्रायोगिक?

— क्रिस्टियन सियुपिटु

क्रिश्चियन: मैं हमेशा हर शाखा 'मूल / फू' के लिए एक शाखा 'फू' बनाता था, लेकिन इससे दो समस्याएं पैदा हुईं: (1) मैं वास्तव में बासी ट्रैकिंग शाखाओं के बहुत से घाव कर रहा हूं जो कि संबंधित दूरस्थ शाखा के पीछे कई कमियां थीं। , और (2) git के पुराने संस्करणों में, 'git push' चलाने से मेरी सभी स्थानीय शाखाओं को रिमोट पर धकेलने का प्रयास किया जाएगा, तब भी जब वे शाखाएँ बासी थीं। इसलिए अब मैं केवल स्थानीय शाखाओं को उन चीजों के लिए रखता हूं, जिन्हें मैं सक्रिय रूप से विकसित कर रहा हूं, और अगर मुझे उनके बारे में जानकारी की आवश्यकता है, तो मूल / * शाखाओं तक सीधे पहुंचें। (उस ने कहा, आप 'git

— Branch

"git लाने के लिए <मूल-नाम> <शाखा-नाम>" आपके लिए स्थानीय रूप से शाखा को नीचे लाता है।

अच्छा जवाब, लेकिन थोड़े सवाल याद आती है। मैं सभी दूरस्थ शाखाओं की जांच के लिए एक-लाइनर की तलाश कर रहा था।

— cmcginty

सवाल सभी दूरस्थ शाखाओं की क्लोनिंग के बारे में था, उन्हें जाँचने का नहीं। और, जैसा कि मैंने ऊपर उल्लेख किया है, आप वास्तव में आवश्यकता से अधिक स्थानीय ट्रैकिंग शाखाएं नहीं बनाना चाहते हैं, क्योंकि जब वे वास्तव में बासी हो जाते हैं, तो वे सिरदर्द पैदा कर सकते हैं।

— emk

Answer 2

यदि आपके पास कई दूरस्थ शाखाएँ हैं जिन्हें आप एक बार में लाना चाहते हैं, तो यह करें:

$ git pull --all

दूरस्थ रिपॉजिटरी से टकराने के बिना, अब आप किसी भी शाखा की जांच कर सकते हैं।

Comments

अगर मैं क्लोन क्लोन करता हूं, तो मेरे पास स्थानीय रूप से मास्टर शाखा और 10 शाखाएं "रिमोट" हैं। तो गेब द्वारा किया गया यह जवाब बहुत मददगार था और सवाल का जवाब देता है।

— बेसजेरो

यह केवल दूरस्थ शाखाओं कि है स्थानीय स्तर पर नहीं जोड़ दिया लाने किसी भी दूरदराज के शाखा

— jujule

पहला आदेश निरर्थक है। बस git pull --allएक ही करेंगे - यह सिर्फ दो बार नहीं मिलेगा। और infosec812 सही है कि यह वैसे भी सवाल का जवाब नहीं देता है। मुझे आश्चर्य है कि यह इतने सारे उत्थान कैसे हुआ।

— स्वेन मार्नाच

जब मैंने किया git remote update, तब कोशिश की git branch, मैं केवल स्थानीय शाखाओं को देखता हूं। लेकिन अगर मैं करूँ तो git branch -aमैं अब दूरस्थ शाखाएँ देख सकता हूँ और मैं अपनी git pull <branchname>इच्छित शाखा प्राप्त करने के लिए कर सकता हूँ। - मैं एक Google खोज से इस प्रश्न पर उतरा, और यह उत्तर मेरी समस्या का हल करता है।

— WNRosenberg

यह बिल्कुल भी मददगार नहीं है, इसके अलावा कोई भी दूरस्थ शाखा नहीं खींचता है।

— अविनाश आर

Answer 3

इस बैश स्क्रिप्ट ने मेरी मदद की:

#!/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 में जाते हैं

Comments

यह वास्तव में एक सही समाधान होने के करीब है .. केवल एक चीज जो इसे बेहतर बनाती है, अगर यह कार्यक्षमता जीआईटी में एक विकल्प के रूप में अंतर्निहित थी।

— डेवेन फिलिप्स

"वन लाइनर": 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 universe as we know it

— सीएफआई

यह कमांड सुदूर शाखाओं को सामान्य शाखाओं के रूप में बनाता है (फीचर शाखाएं नहीं) - इसे कैसे ठीक करें?

— Alex2php

अगर आप शाखा नामों में "/" के साथ समस्याओं में भाग लेते हैं, तो नीचे दिए गए एक समाधान का उपयोग कर एक उपनाम है। "कोई नहीं" द्वारा "15 मई को 11:02 बजे उत्तर दिया" पर उत्तर देखें

— wemu

मैं केवल remotes/origin/नामस्थानों को संरक्षित करने के लिए ट्रिमिंग कर रहा हूं :for BRANCH in $(git branch -a | grep remotes | grep -v HEAD | grep -v master); do git branch --track "${BRANCH#remotes/origin/}" "${BRANCH}"; done

— kgadek

Answer 4

--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 FAQ: मैं सभी दूरस्थ ट्रैक की गई शाखाओं के साथ एक रिपॉजिटरी को कैसे क्लोन करूं?}

Comments

आप जानते हैं कि यह वास्तव में एक अच्छा जवाब है, भले ही इसके पास कोई वोट न हो। क्या इस तरह से करने के लिए कोई नुकसान हैं? मुझे उन कमांडों को चलाने के बाद एक शाखा को स्पष्ट रूप से जांचना था।

— लूप

Git push --mirror के साथ संयुक्त रूप से यह वही है जो मुझे github एंटरप्राइज़ इंस्टॉल करने के लिए github.com से आगे बढ़ने पर एक दूरस्थ गिट रेपो के सटीक डुप्लिकेट बनाने के लिए आवश्यक है। धन्यवाद!

— जैकब फिक

@Dave: git checkoutअंतिम आदेश के रूप में एक क्लोन जोड़ें अंत में क्लोन किए गए रेपो पर वर्तमान शाखा के प्रमुख की जांच करें। यह एक महान जवाब है, अब तक का सबसे अच्छा। बहादुर बनो, आखिरकार हम आपको शीर्ष पर

— पहुंचेंगे

@ डव: एचएम। मुझे दूसरा विचार आ रहा है: - मर्मर सभी शाखाओं को ट्रैक करने के रूप में स्थापित करने से अधिक है। यह मूल से सभी रेफरी को कॉपी करता है और बाद में git remote updateफिर से ऐसा करेगा। खींचतान का व्यवहार बदल जाता है। मुझे विश्वास है कि पूरी कॉपी के लिए एक-लाइन स्क्रिप्ट की आवश्यकता होगी।

— cfi

git clone --mirrorआपके git रिपॉजिटरी ^ _ ^ का समर्थन करने के लिए बहुत अच्छा है

— TrinitronX

Answer 5

आप फैंसी "git चेकआउट -b somebranch मूल / 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 यह जाँच करेगा कि क्या एक ही नाम वाली शाखा ठीक एक रिमोट में मौजूद है, और यदि ऐसा होता है, तो यह उसी तरह से ट्रैक करता है जैसे कि आपने स्पष्ट रूप से निर्दिष्ट किया था कि यह एक दूरस्थ शाखा है। गिट-चेकआउट मैन पेज से जीआईटी 1.8.2.1:

यदि <शाखा> नहीं मिला है, लेकिन एक मिलान शाखा में एक ट्रैकिंग शाखा मौजूद है (इसे कॉल करें <रिमोट>) एक मिलान नाम के साथ, इसके बराबर इलाज करें

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

Comments

इसलिए, यदि शाखा का नाम आप checkoutदूरस्थ शाखा के नाम के समान है, तो सब कुछ "/" के बाद होगा, तो git उसी नाम की एक शाखा बनाएगा, "/", "ट्रैकिंग" के बाद का सब कुछ ? और ट्रैकिंग के द्वारा, हम मतलब है: git push, git pull, आदि कि दूरदराज पर किया जाएगा? यदि यह सही है, तो अधिक जानकारी के साथ अपने उत्तर पर विस्तार करें, क्योंकि मैं @ डैनियल से सहमत हूं, यह उत्तर अधिक प्रतिनिधि के योग्य है।

— गेरार्ड रोश

@BullfrogBlues, आपके सभी सवालों का जवाब हाँ प्रतीत होता है (मैं git v1.7.7.4 का उपयोग कर रहा हूँ)। मैं मानता हूं कि इस व्यवहार का बेहतर पता होना चाहिए। (यह git के इस संस्करण के लिए मैनुअल में नहीं है।) मुझे वास्तव में यह व्यवहार पसंद नहीं है, मुझे एक त्रुटि मिलेगी और मुझे git checkout --track origin/somebranchस्पष्ट रूप से कहना होगा ।

— डबियसजिम 13

@dubiousjim: वास्तव में, यह मैनुअल में है। git-checkout (1) कहता है: "यदि <शाखा> नहीं मिली है, लेकिन एक मिलान शाखा में एक ट्रैकिंग शाखा मौजूद है (एक मेल को दूरस्थ नाम से पुकारें) इसे 'git checkout -b <शाखा के समकक्ष माना जाता है > - ट्रैक <रिमोट> / <शाखा> '"(Git V.1.8.1.1)।

— 27'13

हमें $ git पुल की आवश्यकता है * <रिमोट> / * - जहां "*" एक वाइल्डकार्ड है, इसलिए यह सभी शाखाओं को खींचता है, जिनमें स्थानीय प्रणाली शामिल नहीं है। यह कैसे करना है? क्या हम वास्तव में हर शाखा को चेकआउट / पुल करना चाहते हैं ताकि कोड को हमारे स्थानीय सिस्टम में खींचा जा सके?

— जोसेफ

Answer 6

के बारे में,

$ git चेकआउट -b प्रयोगात्मक मूल / प्रयोगात्मक

का उपयोग करते हुए

$ git checkout -t origin/experimental

या अधिक क्रिया लेकिन याद रखना आसान है

$ git checkout --track origin/experimental

एक रिमोट रिपॉजिटरी पर नज़र रखने के मामले में बेहतर हो सकता है।

Comments

तो आपका मतलब है कि दूसरा रूप केवल याद रखना आसान है और कोई अन्य अंतर नहीं है?

— एड्रॉक्सॉक्स

Answer 7

जो आप कर रहे हैं वह सभी दूरस्थ शाखाओं को मिलना चाहिए, लेकिन यह उनके लिए स्थानीय शाखाएँ नहीं बनाएगा। यदि आप gitk का उपयोग करते हैं, तो आपको "दूरस्थ / मूल / देव" या कुछ समान के रूप में वर्णित दूरस्थ शाखाओं को देखना चाहिए।

एक दूरस्थ शाखा के आधार पर स्थानीय शाखा बनाने के लिए, कुछ ऐसा करें:

git checkout -b dev refs / remotes / मूल / देव

जो कुछ इस तरह लौटाना चाहिए:

दूरस्थ शाखा को ट्रैक करने के लिए स्थापित शाखा देव / रिफॉर्म्स / मूल / देव।
एक नई शाखा "देव" पर स्विच किया गया

अब, जब आप देव शाखा पर होते हैं, तो "गिट पुल" आपके स्थानीय देव को दूरस्थ देव शाखा के समान बिंदु पर अद्यतन करेगा। ध्यान दें कि यह सभी शाखाओं को लाएगा, लेकिन केवल उसी को खींचे जो आप पेड़ की चोटी पर हैं।

Comments

आपको यहाँ refs / remotes की आवश्यकता नहीं है। git चेकआउट -b देव उत्पत्ति / देव ठीक काम करेगा।

— emk

यह हमेशा काम करेगा git checkout -b newlocaldev --track origin/dev:। यदि आप चाहते हैं कि स्थानीय शाखा का रिमोट के समान नाम हो, और रिमोट का एक मुश्किल नाम न हो, तो आप इसे छोड़ सकते हैं -b newlocaldev। डिफ़ॉल्ट branch.autosetupmergeकॉन्फ़िगरेशन सेटिंग के साथ, और यह मानते हुए कि आपके पास एक स्थानीय शाखा का नाम नहीं है dev, ये दोनों कमांड एक ही काम कर सकते हैं: git checkout -b dev origin/devऔर सिर्फ सादा git checkout dev। अंत में, git checkout origin/devएक नई शाखा नहीं बनाता है, लेकिन सिर्फ आपको अलग राज्य में रखता है।

— डबियसजिम

क्या होता है जब रिमोट मौजूद नहीं होता है, लेकिन Git को हटाने के लिए स्वीकार करना बेवकूफी है? यह आपको अपडेट करता है और git branch -aइसे दूरस्थ शाखा के रूप में सूचीबद्ध करता है।

— jww

और हम दर्जनों शाखाओं के लिए ऐसा करते हैं?

— जोसेफ

Answer 8

जब आप "git क्लोन git: // लोकेशन" करते हैं, तो सभी ब्रांच और टैग मिल जाते हैं।

एक विशिष्ट दूरस्थ शाखा के शीर्ष पर काम करने के लिए, यह मूल रिमोट है:

git checkout -b branch origin/branchname

Comments

मैं आपके नोट की सराहना करता हूं "सभी शाखाएं और टैग प्रचलित हैं"। मैं आपके उत्तर के गलत होने पर टिप्पणी करने जा रहा था, लेकिन फिर मैंने इसकी जाँच की और पाया, आप बिल्कुल सही हैं। तो एक तरह से, आपने सबसे छोटा उत्तर प्रदान किया है - यदि आपने क्लोन किया है, तो आपके पास पहले से ही है। अच्छा लगा। कोई जोड़ने की कोशिश कर सकता है: $ git branch -aसीखने की कोशिश करें, जो दूरस्थ शाखाएं पहले से उपलब्ध हैं।

— जनवरी Vlcinsky

मेरे द्वारा पोस्ट किए गए उत्तर पर एक नज़र डालें। यह उपयोगी हो सकता है यदि आप जानते हैं कि आप स्थानीय रूप से दूरस्थ शाखाओं में से कई पर काम करना चाहते हैं और उन्हें एक-एक करके जांचना नहीं है।

— लैकोस्टेनकोडर

क्या आप मुझे समझा सकते हैं कि क्या अंतर है git checkout -b master origin/masterऔर git checkout --track origin/masterकृपया?

— जेरॉक्स

@aderchox आजकल, मुझे नहीं लगता है।

— एल्मर्को

Answer 9

उपनाम का प्रयोग करें। यद्यपि कोई भी देशी 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

Comments

धन्यवाद। यह वास्तव में अन्य जवाबों के कई के विपरीत सभी दूरस्थ शाखाओं को क्लोन करता है

— फियरलेसहैना

Answer 10

आप केवल "मास्टर" क्यों देखते हैं

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स्थानीय शाखाएँ देखने की आवश्यकता नहीं है )।

Comments

यदि origin/branchoneमौजूद है, तो आप केवल git checkout branchoneउसी नाम से एक स्थानीय शाखा बनाने के लिए भी उपयोग कर सकते हैं और इसे दूरस्थ ट्रैक करने के लिए सेट कर सकते हैं।

— इवान

Answer 11

यह बहुत अधिक जटिल नहीं है, बहुत सरल और सीधे आगे के कदम इस प्रकार हैं;

git fetch origin यह सभी दूरस्थ शाखाओं को आपके स्थानीय में लाएगा।

git branch -a यह आपको सभी दूरस्थ शाखाओं को दिखाएगा।

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

सत्यापित करें कि क्या आप निम्न कमांड द्वारा वांछित शाखा में हैं;

git branch

आउटपुट इस तरह होगा;

*your current branch 
some branch2
some branch3 

सूचना * साइन जो वर्तमान शाखा को दर्शाता है।

Comments

धन्यवाद सुराज। इसकी वजह यह है कि इसके लिए ज्यादा मतदान नहीं हुआ। और ans प्रश्नकर्ता द्वारा स्वीकार नहीं किया जाता है।

— सैम

"गिट लाने की उत्पत्ति" ने मेरे स्थानीय में कोई दूरस्थ शाखा नहीं लाई - या वे कहीं छिपे हैं? ऊपर दिए गए सभी उत्तरों को पढ़कर मुझे सिरदर्द हुआ। हम "स्थानीय सभी शाखाओं को लाने के लिए" देख रहे हैं। ऐसा करने के लिए बैश-स्क्रिप्ट से अलग एक रास्ता होना चाहिए।

— जोसेफ

आपके द्वारा "git लाने के मूल" को निष्पादित करने के ठीक बाद, यह आपके टर्मिनल में इस तरह के आउटपुट को दिखाएगा - "* [नई शाखा] Branch_name -> मूल / शाखा_नाम", लेकिन जब आप "git शाखा" चलाते हैं, तो यह आपको केवल आपका स्थानीय दिखाएगा इसके बजाय शाखाएं, इसलिए सभी शाखाओं को देखने के लिए आप "गिट शाखा-ए" कर सकते हैं और फिर दूरस्थ शाखा में स्विच करने के लिए आपको "गिट चेकआउट - ट्रैक मूल / <शाखा जिसे आप चेकआउट करना चाहते हैं" को चलाना होगा। उम्मीद है की यह मदद करेगा। :-)

— सैम

सूरज, क्योंकि सवाल था, "सभी दूरस्थ शाखाओं को क्लोन कैसे करें" - एक समय में मैन्युअल रूप से अपडेट करने का तरीका नहीं। ऐसा प्रतीत होता है कि वास्तविक प्रश्न का कोई उत्तर नहीं है - यदि आपके पास बहुत सी शाखाएँ हैं, तो बहुत सारे टाइपिंग करने के तरीके।

— जोसेफ

Answer 12

देर से बेहतर कभी नहीं, लेकिन यहाँ यह करने का सबसे अच्छा तरीका है:

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

इस बिंदु पर आपके पास सभी शाखाओं (इसके साथ सत्यापित git branch) के साथ रिमोट रेपो की एक पूरी प्रति है । आप --mirrorइसके बजाय उपयोग कर सकते हैं --bareयदि आपका रिमोट रेपो अपने स्वयं के रिमोट है।

Comments

यहां संपादन के दौरान कुछ गड़बड़ हो गई। अब इस जवाब का कोई मतलब नहीं है। --bareअंतिम वाक्य में उल्लिखित कमांड सूची में " " मौजूद नहीं है।

— सेरन

नीचे दवे के जवाब से ले रहा है। 'Git config unbate core.bare' के बजाय 'git config --bool core.bare false' का उपयोग करने से लगता है कि यह काम कर रहा है।

— कन्फ्यूज्ड वोरलोन

मेरे पास है error: key does not contain a section: unset। डेव जवाब बेहतर काम करता है।

— ओलिबर

यह git config --unset core.bareवास्तव में है ... मेरे लिए, यह यहाँ के जवाब में प्रस्तुत सभी का सबसे साफ समाधान लगता है। एक दया यह बहुत कुछ upvotes है ...

— डिर्क हिलब्रैच

धन्यवाद @ChrisSim मैं इसके लिए सहमत हूं git config --bool core.bare false। यही कारण है कि मैं डेव के जवाब के बजाय सलाह देता हूं । डेव के जवाब के बारे में आप क्या सोचते हैं ? चीयर्स

— ओलिब्रे

Answer 13

बस यह करें:

$ 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' सब कुछ प्राप्त करता है, यहां तक ​​कि शाखाएं भी, आपको बस उन्हें चेकआउट करना है, फिर आपकी स्थानीय शाखा बनाई जाएगी।

Answer 14

आपको केवल सभी शाखाओं को प्राप्त करने के लिए "गिट क्लोन" का उपयोग करने की आवश्यकता है।

git clone <your_http_url>

यद्यपि आप केवल मास्टर शाखा देखते हैं, आप सभी शाखाओं को देखने के लिए "गिट शाखा-ए" का उपयोग कर सकते हैं।

git branch -a

और आप किसी भी शाखा में स्विच कर सकते हैं जो आपके पास पहले से है।

git checkout <your_branch_name>

चिंता न करें कि "git clone" के बाद, आपको रिमोट रेपो, "git Branch -a" और "git checkout" से जुड़ने की आवश्यकता नहीं है जब आप अपना वाईफाई बंद करते हैं तो सफलतापूर्वक चलाया जा सकता है। तो यह साबित होता है कि जब आप "गिट क्लोन" करते हैं, तो यह पहले से ही रिमोट रेपो से सभी शाखाओं की नकल कर चुका है। उसके बाद, आपको दूरस्थ रेपो की आवश्यकता नहीं है, आपके स्थानीय में पहले से ही सभी शाखाओं के कोड हैं।

Comments

यहाँ बहुत स्पष्ट प्रतिक्रिया। बहुत से लोगों ने इस विषय को लेकर उलझन की।

— XMAN

जब आप अपने वाईफाई को बंद करते हैं तो मैं आपका कथन "सफलतापूर्वक चलाया जा सकता हूं"। "गिट क्लोन" वास्तव में सभी शाखाओं वाले रेपो में परिणाम करता है।

— bvgheluwe

एक बड़ा स्पष्ट सीधा सा जवाब।

— अमृत

Answer 15

A git cloneको पूरे रिपॉजिटरी को कॉपी करना है। इसे क्लोन करने की कोशिश करें, और फिर चलाएं git branch -a। इसे सभी शाखाओं को सूचीबद्ध करना चाहिए। यदि आप "मास्टर" के बजाय शाखा "फू" पर स्विच करना चाहते हैं, तो उपयोग करें git checkout foo।

Comments

आप हाइफ़न के साथ या उसके बिना git कमांड चला सकते हैं। "गिट-शाखा" और "गिट शाखा" दोनों काम करेंगे।

— पीटर बुफटन

शायद यह जवाब बहुत समय पहले दिया गया था जब git ने अलग तरीके से काम किया था, लेकिन मुझे लगता है कि यह आज भ्रामक है। git cloneसभी दूरस्थ शाखाओं को डाउनलोड करता है, लेकिन यह केवल मास्टर की एक स्थानीय शाखा बनाता है। चूंकि git branchकेवल स्थानीय शाखाएं दिखाती हैं, इसलिए आपको git branch -aदूरस्थ शाखाओं को भी देखने की आवश्यकता है।

— सेरान

धन्यवाद। यह एक तरह का अजीब डिफॉल्ट व्यवहार IMO है। मैं बस इसे और अधिक गूढ़ गवाह तक चाक करूँगा। अगर यह शाखाओं को डाउनलोड करता है, तो यह गिट शाखा को कॉल करते समय उन्हें क्यों छिपाएगा?

— एडम ह्यूजेस

@ केरन, धन्यवाद; मैंने उसी हिसाब से अपना जवाब अपडेट किया है।

— MattoxBeckman

"सभी दूरस्थ शाखाओं को डाउनलोड करता है, लेकिन यह केवल मास्टर की एक स्थानीय शाखा बनाता है"। मुझे इसे समझने में मदद चाहिए। ऐसा लगता है कि git क्लोन मास्टर के अलावा किसी भी शाखा को क्लोन नहीं करता है, जब आप "git branch -a" करते हैं तो यह दर्शाता है कि "विकसित" शाखा केवल "remotes / मूल / विकास" पर है। यह कहना होगा कि आपके पास स्थानीय रूप से कहीं भी यह शाखा नहीं है, यह केवल वर्तमान में ही सही पर मौजूद है?

— जॉन लिटिल

Answer 16

मेरे टूल git_remote_branch का उपयोग करें (आपको अपनी मशीन पर रूबी स्थापित करने की आवश्यकता है)। यह विशेष रूप से रिमोट शाखा जोड़तोड़ को आसान बनाने के लिए बनाया गया है।

हर बार जब यह आपकी ओर से एक ऑपरेशन करता है, तो यह कंसोल में लाल रंग में प्रिंट करता है। समय के साथ, वे अंततः आपके मस्तिष्क में चिपके रहते हैं :-)

यदि आप अपनी ओर से आदेशों को चलाने के लिए grb नहीं चाहते हैं, तो बस 'व्याख्या' सुविधा का उपयोग करें। कमांड आपके लिए निष्पादित होने के बजाय आपके कंसोल पर प्रिंट हो जाएंगे।

अंत में, सभी कमांड में मेमरीकरण को आसान बनाने के लिए उपनाम हैं।

ध्यान दें कि यह अल्फा सॉफ्टवेयर है ;-)

जब आप grb सहायता चलाते हैं तो यहां सहायता दी जाती है:

git_remote_branch संस्करण 0.2.6

  उपयोग:

  grb ब्रांच_नाम बनाएं [Origin_server] 

  grb प्रकाशित ब्रांच_नाम [ओरिजिन_सर्वर] 

  grb का नाम बदलकर Branch_name [मूल_सर्वर] 

  grb को हटाएं Branch_name [Origin_server] 

  जीआरबी ट्रैक ब्रांच_नाम [ओरिजिन_सर्वर] 



  टिप्पणियाँ:
  - अगर Origin_server निर्दिष्ट नहीं है, तो 'मूल' नाम मान लिया गया है 
    (गिट डिफ़ॉल्ट)
  - नाम की कार्यक्षमता वर्तमान शाखा का नाम बदल देती है

  व्याख्या मेटा-कमांड: आप किसी भी कमांड के साथ प्रीपेन्ड कर सकते हैं 
कीवर्ड 'व्याख्या'। कमांड निष्पादित करने के बजाय, git_remote_branch
केवल उन कमांड की सूची को आउटपुट करेगा जिन्हें आपको पूरा करने के लिए चलाने की आवश्यकता है 
वह लक्ष्य।

  उदाहरण: 
    जीआरबी व्याख्या बनाएँ
    grb व्याख्या my_branch github बनाएँ

  सभी आदेशों में भी उपनाम है:
  create: create, new
  हटाना: हटाना, नष्ट करना, मारना, हटाना, rm
  प्रकाशित करें: प्रकाशित करें, रीमोट करें
  नाम बदलें: नाम बदलें, आरएन, एमवी, चाल
  ट्रैक: ट्रैक, पालन, हड़पने, लाने के लिए

Comments

बुद्धिमान को वचन: ऐसा लगता है कि इस परियोजना को उस समय के आसपास छोड़ दिया गया था जब यह उत्तर पोस्ट किया गया था। मुझे 2008 के बाद कोई अपडेट नहीं मिल रहा। कैविट एमप्टर और वह सब। अगर मैं गलत हूं, तो मुझे उम्मीद है कि कोई व्यक्ति वर्तमान पॉइंटर को संपादित और प्रदान करेगा, क्योंकि मुझे इस तरह का टूल पसंद आएगा।

— ब्रैडहिंट्ज़

@bradheintz इस उत्तर की जाँच करें, यह एक उर्फ ​​सेट करता है: stackoverflow.com/a/16563327/151841

— user151841

Answer 17

मेरे द्वारा यहां देखे गए सभी उत्तर मान्य हैं, लेकिन एक रिपॉजिटरी को क्लोन करने और एक ही बार में सभी शाखाओं को खींचने के लिए बहुत क्लीनर तरीका है।

जब आप एक रिपॉजिटरी को क्लोन करते हैं तो शाखाओं की सभी जानकारी वास्तव में डाउनलोड हो जाती है लेकिन शाखाएं छिपी होती हैं। आज्ञा के साथ

$ git branch -a

आप रिपॉजिटरी की सभी शाखाओं और कमांड के साथ दिखा सकते हैं

$ git checkout -b branchname origin/branchname

तब आप उन्हें एक बार में मैन्युअल रूप से "डाउनलोड" कर सकते हैं।

---

हालाँकि, जब आप बहुत सारी शाखाओं के साथ रेपो का क्लोन बनाना चाहते हैं, तो ऊपर बताए गए सभी तरीके लम्बे और थकाऊ होते हैं जो बहुत क्लीनर और तेज़ तरीके के संबंध में होते हैं जो मैं दिखाने जा रहा हूं, हालांकि यह थोड़ा जटिल है। इसे पूरा करने के लिए आपको तीन चरणों की आवश्यकता है:

1. पहला कदम

अपनी मशीन पर एक नया खाली फ़ोल्डर बनाएँ और रिपॉजिटरी से .it फ़ोल्डर की मिरर कॉपी क्लोन करें:

$ 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. दूसरा कदम

इस रिपॉजिटरी को खाली (नंगे) रिपॉजिटरी से नियमित रिपॉजिटरी से बूलियन वैल्यू के "नंगे" को गलत पर स्विच करें:

$ git config --bool core.bare false

3. तीसरा चरण

वर्तमान फ़ोल्डर के अंदर वह सब कुछ पकड़ो और स्थानीय मशीन पर सभी शाखाएं बनाएं, इसलिए यह एक सामान्य रेपो बनाता है।

$ git reset --hard

तो अब आप केवल कमांड "git Branch" टाइप कर सकते हैं और आप देख सकते हैं कि सभी शाखाएँ डाउनलोड हो चुकी हैं।

यह एक त्वरित तरीका है जिसमें आप एक बार में सभी शाखाओं के साथ गिट रिपॉजिटरी को क्लोन कर सकते हैं, लेकिन यह कुछ ऐसा नहीं है जिसे आप इस तरह से हर एक प्रोजेक्ट के लिए करना चाहते हैं।

Comments

मुझे शब्द "डाउनलोड" का आपका उपयोग पसंद नहीं है ... उन्हें एक बार में मैन्युअल रूप से "डाउनलोड" करें । सभी जानकारी, वास्तव में, पहले से ही रेपो क्लोन करने के बाद डाउनलोड की गई है। केवल एक चीज जो करने की आवश्यकता है वह है स्थानीय ट्रैकिंग शाखाएँ (जो ऑफ़लाइन होने पर भी संभव है, जो यह साबित करती है कि सभी जानकारी प्रत्यावर्तन में है)।

— bvgheluwe

@bvgheluwe इसीलिए यह उद्धरणों में है।

— FedericoCapaldo

Answer 18

एक स्थानीय रेपो से क्लोनिंग, क्लोन क्लोन और गिट के साथ काम नहीं करेगा: बहुत सी शाखाएं / टैग अनफिट रहेंगे।

सभी शाखाओं और टैग के साथ एक क्लोन प्राप्त करने के लिए।

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

Answer 19

ठीक है, जब आप अपने रेपो को क्लोन करते हैं, तो आपकी सभी शाखाएँ होती हैं ...

यदि आप बस करते हैं git branch, तो वे छिपे हुए हैं ...

इसलिए यदि आप सभी शाखाओं का नाम देखना चाहते हैं, तो बस --allइस तरह से झंडा जोड़ें :

git branch --all या git branch -a

यदि आप शाखा के लिए चेकआउट करते हैं, तो आपको अपनी ज़रूरत का सारा सामान मिल जाएगा।

लेकिन अगर आपके द्वारा क्लोन के बाद किसी और द्वारा बनाई गई शाखा के बारे में कैसे पता चलेगा?

इस मामले में, बस करें:

git fetch

और फिर से सभी शाखाओं की जाँच करें ...

यदि आप एक ही समय में लाना और चेकआउट करना चाहते हैं, तो आप कर सकते हैं:

git fetch && git checkout your_branch_name

मैंने जो कहा, उसे सरल बनाने के लिए आपके लिए नीचे दी गई छवि भी बनाई:

Comments

"आपके पास यह है" और "आप इसे देखते हैं" के बीच एक अंतर है। जब आप दूरस्थ रिपॉजिटरी को हटाते हैं तो git शाखा -all दूरस्थ शाखाओं को सूचीबद्ध नहीं करेगी।

— गुस्तेव

Answer 20

प्रश्न के उत्तर में से एक को देखकर मैंने पाया कि इसे छोटा करना संभव है:

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

लेकिन सावधान रहें, यदि दूरस्थ शाखाओं में से एक का नाम उदा। Admin_master है तो यह डाउनलोड नहीं होगा!

मूल विचार के लिए बिगफिश का धन्यवाद

Comments

आप grepझूठी सकारात्मकता से बचने के लिए फ़िल्टर को बेहतर बनाने के लिए , रेगेक्स में सुधार कर सकते हैं या शायद इसके बजाय Awk का उपयोग कर सकते हैं ।

— ट्रिपल

सभी शाखाएँ 'मूल' my_branch_name 'हैं, जो निश्चित रूप से मैं नहीं चाहती।

— संन्यासी

मैंने इससे पहले $ {शाखा ## * /} का निर्माण नहीं देखा है - वास्तव में उपयोगी लगता है - कोई भी विचार जहां मैं उस पर अधिक जानकारी पा सकता हूं? कहीं भी मार के तहत खोजने के लिए प्रतीत नहीं कर सकते। धन्यवाद।

— सैमिनोज

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

ये कोड सभी दूरस्थ शाखाओं के कोड को स्थानीय रेपो तक खींच लेंगे।

Comments

संदर्भ। coderwall.com/p/0ypmka/git-clone-all-remote-branches-locally

— arcseldon

Answer 22

कमांड लाइन में कॉपी-पेस्ट के लिए:

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 के उत्तर के आधार पर ।

Answer 23

मैंने लिखा है कि यह छोटी सी पॉवर्सहेल फंक्शंस मेरे सभी गिट शाखाओं की जांच करने में सक्षम है, जो मूल रिमोट पर हैं।

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 सेटिंग्स रेपो पर अधिक git फंक्शन मिल सकते हैं

Answer 24

यहाँ एक जवाब है जो awk का उपयोग करता है। इस विधि को एक नए रेपो पर उपयोग करने के लिए पर्याप्त होना चाहिए।

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

मौजूदा शाखाओं को बस चेक आउट किया जाएगा, या पहले से ही घोषित किया जाएगा, लेकिन टकरावों से बचने के लिए फ़िल्टर जोड़े जा सकते हैं।

इसे संशोधित भी किया जा सकता है, इसलिए यह एक स्पष्ट git checkout -b <branch> -t <remote>/<branch>आदेश कहता है ।

यह उत्तर निकोस सी के विचार का अनुसरण करता है ।

---

वैकल्पिक रूप से हम इसके बजाय दूरस्थ शाखा को निर्दिष्ट कर सकते हैं। यह murphytalk के उत्तर पर आधारित है ।

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-allया का उपयोग करेंगे track-all-branches।

Comments

बस आपको धन्यवाद देना चाहता था। यह पूरी तरह से काम किया है और यह एक नंगे रेपो क्लोनिंग से संबंधित विभिन्न समस्याओं से ग्रस्त नहीं है जैसे कि कुछ खींच व्यवहार बदल रहा है आदि

— mahonya

Answer 25

मुझे ठीक वैसा ही करने की जरूरत थी। यहाँ मेरी रूबी लिपि है।

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

Comments

जवाब देखें मैंने इस स्क्रिप्ट को चलाने के लिए बिल्कुल नीचे पोस्ट किया है।

— Lacostenycoder

Answer 26

इनमें से किसी भी उत्तर ने इसे नहीं काटा, उपयोगकर्ता को छोड़कर कोई भी सही रास्ते पर नहीं है।

मुझे रेपो को एक सर्वर / सिस्टम से दूसरे पर ले जाने में परेशानी हो रही थी। जब मैंने रेपो पर क्लोन किया, तो इसने केवल मास्टर के लिए एक स्थानीय शाखा बनाई, इसलिए जब मैंने नए रिमोट को धक्का दिया, तो केवल मास्टर शाखा को धक्का दिया गया।

इसलिए मुझे ये दोनों विधियाँ उपयोगी लगीं। आशा है कि वे किसी और की मदद करेंगे।

विधि 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

Answer 27

git clone --mirror इसके लिए मूल रेपो अच्छी तरह से काम करता है।

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

Answer 28

आमतौर पर (जब निर्दिष्ट नहीं किया जाता है) सभी शाखाओं और / या टैग (रेफरी, देखें:) 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.remoteहै origin।
  • जाँचें कि क्या इसके originमाध्यम से दाईं ओर के बिंदु हैं: git remote show origin(इस पोस्ट को देखें )।

Answer 29

2017 की शुरुआत में, इस टिप्पणी का जवाब काम करता है:

git fetch <origin-name> <branch-name>आपके लिए शाखा नीचे लाता है। हालांकि यह एक बार में सभी शाखाओं को नहीं खींचता है, आप इस प्रति-शाखा को विलक्षण रूप से निष्पादित कर सकते हैं।

Comments

इसके लिए आवश्यक है कि आप एक बार में प्रत्येक शाखा प्राप्त करें। बहुत अच्छी नहीं है यदि आपके पास बहुत सारी शाखाएं हैं।

— लैकोस्टेनकोडर

Answer 30

यहाँ एक और छोटी लाइनर कमांड है जो सभी दूरस्थ शाखाओं के लिए स्थानीय शाखाएँ बनाती है:

(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