सभी गिट शाखाओं को कैसे लाया जाए

1506

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

$ git branch
* master

मुझे पता है कि मैं सभी शाखाओं git branch -aको देखने के लिए कर सकता हूं , लेकिन मैं स्थानीय रूप से सभी शाखाओं को कैसे खींचूंगा, जब मैं ऐसा करता हूं , तो यह निम्नलिखित दिखाता है?git branch

$ git branch
* master
* staging
* etc...
git  branch  git-branch 
— David542
स्रोत
1
इसके अलावा stackoverflow.com/questions/67699/…
— gliptak
2
यह प्रश्न दिखाता है कि --single-branchक्लोनिंग करते समय सेटिंग का उपयोग करने के बाद सभी शाखाओं को कैसे प्राप्त करें : stackoverflow.com/questions/17714159/… ( git fetch --allयदि आपने केवल एक शाखा निर्दिष्ट की है तो कभी भी काम नहीं करेगा!)
— मैथ्यू विलकॉक्सन
2
आप उस आउटपुट को कभी नहीं देखेंगे क्योंकि तारांकन उस शाखा का प्रतिनिधित्व करता है जो वर्तमान में चेकआउट है। चूँकि आप एक बार में केवल एक शाखा की जाँच कर सकते हैं, आपके पास अपनी शाखा सूची के बाईं ओर केवल एक तारांकन हो सकता है।
— रोबिनो डे
5
मैंने बहुत से उत्तर देखे, लेकिन उनमें से किसी ने भी उल्लेख नहीं किया कि मुझे क्या लगता है कि आप जो चाहते हैं वह करने का शायद सबसे आसान तरीका है: git clone --bare <repo url> .git (ध्यान दें कि आपको रेपो को क्लोन करने के लिए अंत में "--bare" और ".git" को जोड़ना होगा। "नंगे" रेपो), फिर git config --bool core.bare false("नंगे" झंडे को झूठा सेट करता है), फिर git reset --hard(HEAD को वर्तमान HEAD को रेपो पर ले जाता है)। अब अगर आपको git branchरेपो से सभी शाखाओं को देखना चाहिए जिसे आपने क्लोन किया है।
— गेब्रियल फ़राज़
4
@GabrielFerraz तब आप स्टैक ओवरफ्लो पर टिप्पणी कार्यक्षमता का दुरुपयोग कर रहे हैं। उपयोगकर्ता आपकी टिप्पणी को अपडाउन कर सकते हैं लेकिन डाउनवोट नहीं।
— पाइप

जवाबों:

2049

आप इस तरह से सभी रीमोट से सभी शाखाओं को प्राप्त कर सकते हैं:

git fetch --all

यह मूल रूप से एक शक्ति चाल है ।

fetchअद्यतन करता है दूरस्थ शाखाओं के स्थानीय प्रतियां तो यह हमेशा अपने स्थानीय शाखाओं के लिए सुरक्षित है , लेकिन :

  1. fetchस्थानीय शाखाओं को अद्यतन नहीं करेगा (जो दूरस्थ शाखाओं को ट्रैक करता है ); यदि आप अपनी स्थानीय शाखाओं को अपडेट करना चाहते हैं तो भी आपको हर शाखा को खींचने की जरूरत है।

  2. fetchस्थानीय शाखाएं नहीं बनाएंगे (जो दूरस्थ शाखाओं को ट्रैक करते हैं), आपको इसे मैन्युअल रूप से करना होगा। यदि आप सभी दूरस्थ शाखाओं को सूचीबद्ध करना चाहते हैं: git branch -a

दूरस्थ शाखाओं को ट्रैक करने वाली स्थानीय शाखाओं को अपडेट करने के लिए :

git pull --all

हालांकि, यह अभी भी अपर्याप्त हो सकता है। यह केवल आपकी स्थानीय शाखाओं के लिए काम करेगा जो दूरस्थ शाखाओं को ट्रैक करती हैं। ट्रैक करने के लिए सभी दूरस्थ शाखाओं इस oneliner पर अमल करने से पहले git pull --all :

git branch -r | grep -v '\->' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done

टीएल; डीआर संस्करण

git branch -r | grep -v '\->' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done
git fetch --all
git pull --all

(ऐसा लगता है कि पुल सभी शाखाओं को सभी रिमोट से प्राप्त करता है, लेकिन मैं हमेशा सुनिश्चित करने के लिए पहले प्राप्त करता हूं।)

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

PS AFAIK git fetch --allऔर git remote updateसमतुल्य हैं।

कामिल सजोट की टिप्पणी , जिसे लोगों ने उपयोगी पाया है।

मुझे उपयोग करना था:

for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done

क्योंकि आपके कोड ने स्थानीय शाखाओं को नाम दिया था origin/branchnameऔर जब भी मैं इसे संदर्भित करता हूं तो मुझे "refname 'मूल / शाखा नाम मिल रहा है।

— Wookie88
स्रोत
41
माफ़ करना। मैं कल्पना नहीं कर सकता कि यह वही है जो वास्तव में ओपी चाहता है। The पुल ’कमांड ch fetch + merge’ है और मर्ज वाला हिस्सा एक-दूसरे के ऊपर सभी शाखाओं को ओवरले कर देगा - एक विशाल गंदगी छोड़ देगा।
— GoZoner
10
वह एक नई दूरस्थ शाखा नहीं बनाएगा जिसकी आपको अभी भी जाँच करनी हैgit checkout -b localname remotename/remotebranch
— Learath2
125
मुझे इसका उपयोग करना पड़ा for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done क्योंकि आपके कोड ने मूल / शाखा नाम की स्थानीय शाखाएँ बनाई थीं और जब भी मैं इसे संदर्भित करता हूं तो मुझे "refname 'मूल / शाखा नाम मिल जाता है।
— कामिल सोजोट
22
मुझे नहीं पता कि मैं GIT के किसी भिन्न संस्करण का उपयोग कर रहा हूं, लेकिन मुझे स्क्रिप्ट में संशोधन करना था git pull --all; for remote in `git branch -r | grep -v \>`; do git branch --track ${remote#origin/} $remote; done। परिवर्तन HEAD से बाहर निकलता है।
— किम 3
16
विंडोज के लोगों के लिए:for /F %remote in ('git branch -r') do ( git branch --track %remote) && git fetch --all && git pull --all
— मैक्स
718

दूरस्थ शाखाओं को सूचीबद्ध करने के लिए:
git branch -r

आप उन्हें स्थानीय शाखाओं के रूप में देख सकते हैं:
git checkout -b LocalName origin/remotebranchname

— Learath2
स्रोत
88
यह वही है जो मैं देख रहा था जब मुझे ऊपर प्रश्न मिला। मुझे लगता है कि एक दूरस्थ शाखा को खींचने के लिए देख रहे कई लोगों को संदेह है कि निश्चित रूप से शाखा को उनकी वर्तमान कार्यशील प्रति में विलय नहीं करना है, लेकिन वे एक स्थानीय शाखा को दूरस्थ के समान चाहते हैं।
— 19:03
11
यहां तक ​​कि अगर शाखा स्थानीय रूप से दिखाई नहीं दे रही है, तो मैं कर सकता हूं git checkout remotebranchnameऔर यह काम करता है। आपके समाधान में क्या अंतर है?
— फ्रांस्वा रोमेन
12
इसका डिफ़ॉल्ट व्यवहार अब। पुराने गिट संस्करणों पर मामला नहीं था। का git checkout remotebranchnameउपयोग करते हुए बस एक नई असंबंधित शाखा बनाने के लिए उपयोग किया जाता है जिसे रिमोटेब्रनचैम नाम दिया गया है ।
— लेरथ 2
12
स्वीकृत उत्तर कुछ मौलिक रूप से भिन्न होता है और स्पष्ट होने के लिए मुझे यह भी समझ में नहीं आता कि इसका स्वीकृत उत्तर क्यों है
— Learath2
8
ओपी ने सभी शाखाओं के लिए कहा। यह उत्तर केवल एक ही देता है।
— टेड बीघम
193

आपको दूरस्थ शाखाओं पर नज़र रखने वाली स्थानीय शाखाएँ बनाने की आवश्यकता होगी।

यह मानते हुए कि आपको केवल एक रिमोट कहा जाता है origin, यह स्निपेट सभी रिमोट ट्रैकिंग वालों के लिए स्थानीय शाखाएं बनाएगा:

for b in `git branch -r | grep -v -- '->'`; do git branch --track ${b##origin/} $b; done

उसके बाद, git fetch --allदूरस्थ शाखाओं की सभी स्थानीय प्रतियों को अपडेट करेगा।

इसके अलावा, git pull --allआपकी स्थानीय ट्रैकिंग शाखाओं को अपडेट करेगा, लेकिन आपके स्थानीय कमिट्स पर निर्भर करता है और 'मर्ज' कॉन्फिगर करने का विकल्प सेट होने पर यह मर्ज कमिट, फास्ट-फॉरवर्ड या फेल हो सकता है।

— माइकल रेनर
स्रोत
5
यह शाखा के नाम के साथ विलयन को मजबूत करता है जिसमें शेल मेटाचैकर (अन्य उत्तर पर पिंकीन की टिप्पणी के अनुसार), और नकली त्रुटि आउटपुट से बचा जाता है: गिट शाखा -r | grep -v - '->' | रिमोट पढ़ते समय; do git Branch - ट्रैक "$ {रिमोट # मूल /}" "$ रिमोट" 2> & 1 | grep -v 'पहले से मौजूद है'; किया
— दायरा हॉपवुड
6
क्या आप वाकई git pull --allसभी स्थानीय ट्रैकिंग शाखाओं को अपडेट करेंगे? जहां तक ​​मैं बता सकता हूं कि यह केवल सभी रिमोट से वर्तमान शाखा को अपडेट करता है।
— एंडी
3
इसे किया। दूरस्थ शाखाओं से मेल खाने वाली स्थानीय शाखाएँ नहीं बनाई गईं। क्या git कमांड है जो बस कहती है कि "सभी दूरस्थ शाखाओं को बनाएं जो स्थानीय लोगों को बनाते हैं यदि वे मौजूद नहीं हैं?"
— जोसेफ
@ जोसेफ को शायद आपका रिमोट नहीं कहा जाता origin? इस उत्तर को देखें जो सभी दूरस्थ नामों पर काम करेगा।
— टॉम हेल
@TomHale यह "मूल" था, लेकिन आपके उत्तर के लिए धन्यवाद - हालांकि पागल यह करने के लिए आवश्यक है कि एक या दो ध्वज होने चाहिए। मैं अब gitless की कोशिश कर रहा हूं, git के कुछ पहलुओं की पागलपन से बचने की कोशिश करता हूं।
— जोसेफ
116

यदि तुम करो:

git fetch origin

फिर वे सभी स्थानीय स्तर पर होंगे। यदि आप प्रदर्शन करते हैं:

git branch -a

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

git diff origin/branch-name

या

git merge origin/branch-name

या

git checkout -b some-branch origin/branch-name
— GoZoner
स्रोत
5
बस यह पृष्ठ Google पर मिला ... यह वास्तविक प्रकार का उत्तर था जो मैं चाह रहा था। मैंने पहली कमांड की कोशिश की, लेकिन एक त्रुटि मिली: [$ git fetch --all origin fatal: fetch --all कोई रिपॉजिटरी का तर्क नहीं लेता है] --- "git fetch --all" का उपयोग ट्रिक के लिए लगता है। नेतृत्व के लिए धन्यवाद!
— लोंगदा
1
फिक्स्ड (समाप्त --all)
— GoZoner
12
git fetch -allसभी की सभी शाखाओं को हटाता है। git fetch originरिमोट की सभी शाखाओं को प्राप्त करता है origin। बाद में ओपी पूछ रहा था।
— गोयनर
3
--allका अर्थ है "सभी रिमोट", "किसी दिए गए रिमोट की सभी शाखाएं" नहीं। बाद वाले को रिमोट से किसी भी भ्रूण द्वारा गर्भित किया जाता है।
— जागीर
2
यह रिमोट रेपो से सभी शाखाओं को स्थानीय रेपो में खींचने का तरीका नहीं है।
— व्लादिमीर डेस्पोटोविक
69 
$ git remote update
$ git pull --all

यह माना जाता है कि सभी शाखाओं को ट्रैक किया जाता है।

अगर वे नहीं हैं तो आप इसे बाश में जला सकते हैं:

for remote in `git branch -r `; do git branch --track $remote; done

फिर कमांड चलाएं।

— जॉननो नोलन
स्रोत
3
जब मैं कोशिश करता हूं कि मुझे अभी भी ऊपर जैसा परिणाम मिलता है।
— डेविड ५४२
4
@JacobLowe के रूप में भी, मुझे त्रुटि मिली, लेकिन इसने वैसे भी काम किया; 'घातक:' मूल / मास्टर 'नाम की एक शाखा पहले से मौजूद है।
— ऐनीइगाइल जूल
यह बदसूरत है क्योंकि यह एक शाखा बनाने की कोशिश करेगा ->जिसके लिए संभावित git branch -rरूप से `मूल / HEAD -> मूल / मास्टर` के उत्पादन में मौजूद होगा
— टॉम हेल
इसके अलावा, यह काम नहीं करता है। मुझे आउटपुट मिलता है: Branch 'origin/quote-filenames' set up to track local branch 'master'. वांछित आउटपुट है: Branch 'quote-filenames' set up to track remote branch 'quote-filenames' from 'origin'. यह पीछे की ओर है , रिमोट को ट्रैक करने के लिए मूल सेट करता है। एक फिक्स के लिए इस उत्तर को देखें ।
— टॉम हेल
मुझे जिस चीज की जरूरत थी। जब से मैंने मैक को स्विच किया, तब भी जब मैंने रेपो को क्लोन किया तो मैं अन्य दूरस्थ शाखाओं की जांच करने में सक्षम नहीं था और git fetchकाम नहीं कर रहा था । तो यहां सबक यह है कि आपको दूरस्थ शाखाओं को ट्रैक करने की आवश्यकता है। ग्रेसियस!
— विक्टर रामोस
58

बैश forलूप मेरे लिए काम नहीं कर रहा था, लेकिन यह वही था जो मैं चाहता था। मेरे मूल से सभी शाखाओं को स्थानीय रूप से एक ही नाम के रूप में दिखाया गया है।

git checkout --detach
git fetch origin '+refs/heads/*:refs/heads/*'

नीचे माइक ड्यूपॉन्ट की टिप्पणी देखें। मुझे लगता है कि मैं जेनकींस सर्वर पर ऐसा करने की कोशिश कर रहा था जो इसे अलग सिर मोड में छोड़ देता है।

— टिम लुम
स्रोत
6
यह fatal: Refusing to fetch into current branch refs/heads/master of non-bare repositoryएक साधारण क्लोन के बाद पैदा होता है । पहले सिर अलग करना होगा। मैंने इस के साथ कियाgit checkout <SHA>
— शाखायुक्त
6
इस का उपयोग कर मेरा समाधान है git checkout --detach # detach the headऔर फिरgit fetch origin \'+refs/heads/*:refs/heads/*
— माइक ड्यूपॉन्ट
1
यह एक मेरे लिए काम करता है, सिवाय इसके कि मैं --tags पैरामीटर का उपयोग करता हूं। काश वहाँ एक मानक, गिट के लिए सरल सामने अंत था, गिट में सरल चीजों की संख्या है कि 10 से अधिक स्टैक अतिप्रवाह जवाब की जरूरत हास्यास्पद है!
— kristianp
1
@kristianp क्या आपने अनगित या गिटक्राकेन की जाँच की है?
— ड्रैगन 788
@ dragon788 मैं एक जीयूआई GUI के लिए SourceTree का उपयोग कर रहा हूं, लेकिन मैं वास्तव में स्क्रिप्टिंग कार्यों के लिए एक सरल कमांड-लाइन के बारे में बात कर रहा था।
— kristianp
51

का उपयोग करें git fetch && git checkout RemoteBranchName।

यह मेरे लिए बहुत अच्छा काम करता है ...

— रेजिस ज़ालिमन
स्रोत
6
यह नया सबसे अच्छा उत्तर है, y'all। मुझे नहीं पता कि शायद यह पहले संभव नहीं था, लेकिन जीआईटी के हाल के संस्करणों में कम से कम ध्यान दिया जाएगा कि आप एक दूरस्थ शाखा की जांच करने की कोशिश कर रहे हैं और स्वचालित रूप से आपके लिए स्थानीय ट्रैकिंग शाखा स्थापित करेंगे (और आपको इसकी आवश्यकता नहीं है निर्दिष्ट करने के लिए origin/branch; यह केवल कहने के लिए पर्याप्त है branch)।
— नील ट्राफ
9
यह मूल प्रश्न का उत्तर नहीं देता है: "मैं स्थानीय रूप से सभी शाखाओं को कैसे खींचूंगा?" यह उन्हें एक-एक करके खींच रहा है, जो कि स्केलेबल नहीं है।
— ingyhere
यह एकमात्र उत्तर था जिसने मुझे हर स्थिति में दूरस्थ शाखाओं को खींचने की अनुमति दी
— इमैनुएल बख्शी
38

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

$ 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 कर सकते हैं और आप देख सकते हैं कि सभी शाखाएँ डाउनलोड हो चुकी हैं।

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

— FedericoCapaldo
स्रोत
1
छिपी हुई शाखाओं के उल्लेख के लिए उत्कीर्ण। स्थानीय शाखा ट्रैकिंग को अत्यधिक समझने में मेरी मदद की।
— mburke05
इसका एक अच्छा जवाब है, लेकिन सवाल हर दिन उपयोग के लिए कुछ का मतलब है। हर बार क्लोन करने के लिए इसका व्यावहारिक नहीं।
— ज़ुल्लाह
रीसेट स्थानीय रूप से सभी शाखाओं को क्यों बनाता है?
— जेड। खुल्लाह
@ Z.Khullah यह रीसेट नहीं है जो सभी शाखाओं को बनाता है, लेकिन क्लोन - मिरर। दुर्भाग्य से हमारे लिए, यह भी एक नंगे रेपो बनाता है, जो कि 2 और 3 कदम है।
— स्कॉट जे
29

आप सभी शाखाओं को प्राप्त कर सकते हैं:

git fetch --all

या:

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

--depth=10000पैरामीटर यदि आप भंडार shallowed गया है मदद मिल सकती है।

सभी शाखाओं को खींचने के लिए, उपयोग करें:

git pull --all

यदि ऊपर काम नहीं करेगा, तो उपरोक्त आदेश के साथ पूर्ववर्ती करें:

git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'

के रूप में remote.origin.fetchप्राप्त करते समय केवल समर्थन कर सकता है एक विशिष्ट शाखा है, खासकर जब आप के साथ अपने रेपो क्लोन --single-branch। इसके द्वारा जाँच करें:git config remote.origin.fetch।

उसके बाद आपको किसी भी शाखा की जांच करने में सक्षम होना चाहिए।

यह सभी देखें:

सभी शाखाओं को दूरस्थ में धकेलने के लिए, उपयोग करें:

git push --all

अंततः --mirrorसभी रेफरी को आइना दिखाने के लिए।

यदि आपका लक्ष्य एक रिपॉजिटरी को डुप्लिकेट करना है, तो देखें: गिटहब पर एक रिपॉजिटरी लेख को दोहराएं।

— kenorb
स्रोत
1
बहुत बढ़िया ... मैंने इस पृष्ठ में आपके समाधान से पहले बाकी सब कोशिश की। आपका बहुत बहुत धन्यवाद!
— सुजॉय
2
मैंने उथले क्लोनिंग ( depth=1) का उपयोग किया और इसके लिए विन्यास ने एक विशिष्ट शाखा भी निर्दिष्ट की fetch- depth=1000पैरामीटर वह फिक्स था जिसने मुझे एक विशिष्ट दूरस्थ शाखा की जांच करने में मदद की
— सैंड्रा
2
pull --allसभी शाखाओं को नहीं खींचता, लेकिन सभी
— रीमोट
हालांकि, विन्यास के साथ अच्छी चाल! उन सभी को, हर समय
— मिलेगा
मैंने कॉन्फ़िगर की जाँच की जैसा आपने लिखा था, अभी भी केवल वर्तमान शाखा के साथ काम करता है। ऐसा लगता है कि यहाँ सभी उत्तर मेरे काम नहीं आते ...
— एलेक्सी मार्टीनोव 13
25

मैं आमतौर पर और कुछ नहीं बल्कि इस तरह से कमांड का उपयोग करता हूं:

git fetch origin
git checkout --track origin/remote-branch

थोड़ा छोटा संस्करण:

git fetch origin
git checkout -t origin/remote-branch
— marioosh
स्रोत
17

मेरा मानना ​​है कि आपने रिपॉजिटरी को क्लोन कर लिया है:

git clone https://github.com/pathOfrepository

अब cd का उपयोग करके उस फोल्डर में जाएं:

cd pathOfrepository

यदि आप लिखते हैं git statusतो आप सभी देख सकते हैं:

   On branch master
Your branch is up-to-date with 'origin/master'.
nothing to commit, working directory clean

सभी छिपी शाखा प्रकार देखने के लिए:

 git branch -a

यह सभी दूरस्थ शाखाओं को सूचीबद्ध करेगा।

अब यदि आप किसी विशेष शाखा में चेकआउट करना चाहते हैं तो बस टाइप करें:

git checkout -b localBranchName origin/RemteBranchName
— अभिनव भारद्वाज
स्रोत
16

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

git clone <ORIGINAL_ORIGIN>
git branch -r | awk -F'origin/' '!/HEAD|master/{print $2 " " $1"origin/"$2}' | xargs -L 1 git branch -f --track 
git fetch --all --prune --tags
git pull --all

git remote set-url origin <NEW_ORIGIN>
git pull
<resolve_any_merge_conflicts>
git push --all
git push --tags
<check_NEW_ORIGIN_to_ensure_it_matches_ORIGINAL_ORIGIN>
— ingyhere
स्रोत
3
बहुत मददगार; वास्तव में मुझे क्या चाहिए। केवल एक चीज जिसे मुझे बदलना था दूसरी पंक्ति में था, 'हेड' और 'मास्टर' के आसपास एकल उद्धरण जोड़े; शायद इसलिए मैं zsh का उपयोग कर रहा हूं। धन्यवाद!
— sockmonk 16:15
यह मूल रूप से निम्नलिखित कर रहा है: (1) दूरस्थ शाखाओं के वास्तविक नामों को प्राप्त करना [न कि सिर, न मास्टर]; (2) पूरी तरह से उन्हें ट्रैक करने के लिए गिट से कह रहे हैं [सभी समाधान ऐसा नहीं करते हैं]; (३) इन शाखाओं से सब कुछ प्राप्त करना और खींचना [टैग सहित]; (4) एक नया मूल स्थापित करना और पूरी तरह से सब कुछ ऊपर धकेलने के माध्यम से चलना। फिर से, अधिकांश अन्य समाधान सभी टुकड़ों को स्थानांतरित करने में विफल होते हैं। यह सब करता है।
— ingyhere
1
मैंने grep चलाने के एंटीपार्टेन को हटा दिया और फिर gkp कमांड को awk कमांड में कंडक्ट किया। धन्यवाद ट्रिपल !
— ingyhere
इसे पढ़ें और कभी भी git fetch git pull stackoverflow.com/a/292359/1114926
— ग्रीन
Git pullवास्तव में एक क्या करता है fetchपहले, लेकिन यह करता है, तो समस्या से है बताने के लिए आसान है fetchका हिस्सा pullया बाद mergeके हिस्से pullजब fetchस्वतंत्र रूप से क्रियान्वित किया जाता है।
— पहुंचें
12

मास्टर रिपॉजिटरी को क्लोन करने के बाद, आप बस निष्पादित कर सकते हैं

git fetch && git checkout <branchname>
— Davidacce
स्रोत
1
सरल। और सुदूर मूल से एक शाखा प्राप्त करने के लिए काम किया
— सेर्वोन
3
यह मूल प्रश्न का उत्तर नहीं देता है: "मैं स्थानीय रूप से सभी शाखाओं को कैसे खींचूंगा?" यह उन्हें एक-एक करके खींच रहा है, जो कि स्केलेबल नहीं है। 100 शाखाओं के मामले पर विचार करें।
— ingyhere
10

सुनिश्चित करें कि सभी दूरस्थ शाखाएँ .git/configफ़ाइल में उपलब्ध हैं।

इस उदाहरण में, केवल origin/productionशाखा उपलब्ध है, भले ही आप git fetch --allकुछ भी करने की कोशिश करें लेकिन productionशाखा लाने से कुछ नहीं होगा :

[origin]
fetch = +refs/heads/production:refs/remotes/origin/production

इस लाइन को इसके द्वारा प्रतिस्थापित किया जाना चाहिए:

[origin]
fetch = +refs/heads/*:refs/remotes/origin/*

फिर भागो git fetchआदि ...

— अहमद
स्रोत
3
निरीक्षण करने के लिए: git config --get remote.origin.fetchऔर फिर (विध्वंसक रूप से) इसे सेट करें:git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'
— 22
या
— .IT डायरेक्टरी में कॉन्फिगर
9

मेरे लिए काम करना लूपिंग नहीं लगता था और मैं मूल / गुरु की उपेक्षा करना चाहता था। यहाँ मेरे लिए क्या काम किया है।

git branch -r | grep -v HEAD | awk -F'/' '{print $2 " " $1"/"$2}' | xargs -L 1 git branch -f --track

उसके बाद:

git fetch --all
git pull --all
— poxion
स्रोत
1
इसका एक रूपांतर इसका सही उत्तर है, लेकिन यह सभी मामलों में कारगर नहीं है। साथ ही, शाखा के नाम फंकी हो सकते हैं। इसलिए मैंने निम्नलिखित कार्य किया: git Branch -r | grep -v HEAD | grep -v मास्टर | awk -F'origin / '' {$ $ 2 "" $ 1 "मूल /" $ 2} '| xargs -L 1 गिट शाखा -f --track; git fetch - लंबा; गिट पुल --all; और यह सच है!
— पहुंचें
3
से बचने के लिए एक शैलीगत सुधार grep | awk antipattern : git branch -r | awk -F 'origin/' '!/HEAD|master/{...
— tripleee
7

बस इन तीन आदेशों को सभी शाखाएँ मिलेंगी:

git clone --mirror repo.git  .git     (gets just .git  - bare repository)

git config --bool core.bare false

git reset --hard
— इजाबेला स्किबिंस्का
स्रोत
यह वास्तव में ओपी की समस्या की जड़ है। यदि सही क्लोन किया जाता है, तो उसे करने की आवश्यकता नहीं होगी pull --all। लेकिन अगर अभी भी जरूरत है, तो अन्य उत्तर bellow, @ जॉननो नोला द्वारा, यह मानते हुए कि सभी शाखाओं को ट्रैक किया जाता है, इस उत्तर के साथ मिलाया जाता है।
— डॉ। बीको
7

क्यों कोई भी लोगों के सवाल का जवाब नहीं दे रहा है और समझा रहा है कि क्या हो रहा है?

  1. सुनिश्चित करें कि आप सभी दूरस्थ शाखाओं को ट्रैक कर रहे हैं (या जो भी आप ट्रैक करना चाहते हैं) ।
  2. दूरस्थ शाखाओं को प्रतिबिंबित करने के लिए अपनी स्थानीय शाखाओं को अपडेट करें।

सभी दूरस्थ शाखाओं को ट्रैक करें:

दूरस्थ रेपो में मौजूद सभी शाखाओं को ट्रैक करें।

मैन्युअल रूप से करते हैं:

आप <branch>उस शाखा से प्रतिस्थापित करेंगे जो आउटपुट से प्रदर्शित होती है git branch -r।

git branch -r
git branch --track <branch>

इसे बैश स्क्रिप्ट के साथ करें

for i in $(git branch -r | grep -vE "HEAD|master"); do git branch --track ${i#*/} $i; done

अपने स्थानीय कंप्यूटर पर दूरस्थ शाखाओं के बारे में जानकारी अपडेट करें:

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

git fetch --all

अपने स्थानीय कंप्यूटर पर दूरस्थ शाखाओं के बारे में जानकारी अपडेट करें और स्थानीय शाखाओं को अपडेट करें:

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

git pull --all
— कार्ल मॉरिसन
स्रोत
4

मैंने एक नई रेपो क्लोनिंग का प्रबंधन करने के लिए और सभी दूरस्थ शाखाओं के लिए स्थानीय शाखाएं बनाने के लिए एक छोटी सी स्क्रिप्ट लिखी।

आप यहाँ नवीनतम संस्करण पा सकते हैं :

#!/bin/bash

# Clones as usual but creates local tracking branches for all remote branches.
# To use, copy this file into the same directory your git binaries are (git, git-flow, git-subtree, etc)

clone_output=$((git clone "$@" ) 2>&1)
retval=$?
echo $clone_output
if [[ $retval != 0 ]] ; then
    exit 1
fi
pushd $(echo $clone_output | head -1 | sed 's/Cloning into .\(.*\).\.\.\./\1/') > /dev/null 2>&1
this_branch=$(git branch | sed 's/^..//')
for i in $(git branch -r | grep -v HEAD); do
  branch=$(echo $i | perl -pe 's/^.*?\///')
  # this doesn't have to be done for each branch, but that's how I did it.
  remote=$(echo $i | sed 's/\/.*//')
  if [[ "$this_branch" != "$branch" ]]; then
      git branch -t $branch $remote/$branch
  fi
done
popd > /dev/null 2>&1

इसका उपयोग करने के लिए, बस इसे अपने git बिन निर्देशिका (मेरे लिए, वह C:\Program Files (x86)\Git\bin\git-cloneall) में कॉपी करें , फिर, कमांड लाइन पर:

git cloneall [standard-clone-options] <url>

यह सामान्य रूप से क्लोन करता है, लेकिन सभी दूरस्थ शाखाओं के लिए स्थानीय ट्रैकिंग शाखाएं बनाता है।

— tstone2077
स्रोत
4

सिंगल रिमोट ट्रैकिंग करने वाले सभी गिट ब्रांच कैसे लाएं।

यह परीक्षण किया गया है और विंडोज 10 पर Red Hat और Git Bash पर कार्य किए गए हैं।

TLDR:

for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;

स्पष्टीकरण:

एक लाइनर बाहर की जाँच करता है और फिर HEAD को छोड़कर सभी शाखाओं को लाता है।

दूरस्थ-ट्रैकिंग शाखाओं की सूची बनाएं।

git branch -r

HEAD को नजरअंदाज करें।

grep -v ' -> '

रिमोट (एस) की शाखा का नाम लें।

cut -d"/" -f2

एकल रिमोट पर नज़र रखने वाली सभी शाखाओं की जाँच करें।

git checkout $branch

जाँच की गई शाखा के लिए प्राप्त करें।

git fetch

नई स्थानीय शाखाओं के लिए तकनीकी रूप से भ्रूण की आवश्यकता नहीं है।

यह fetchया तो इस्तेमाल किया जा सकता हैpull शाखाओं शाखाओं के जो दोनों नए हैं और रिमोट (एस) में परिवर्तन हैं।

केवल यह सुनिश्चित करें कि आप केवल तभी खींचते हैं जब आप विलय के लिए तैयार हों।

परीक्षण व्यवस्था

SSH URL के साथ एक रिपॉजिटरी देखें।

git clone git@repository.git

इससे पहले

स्थानीय में शाखाओं की जाँच करें।

$ git branch
* master

निष्पादित कमांड

एक लाइनर निष्पादित करें।

for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;

उपरांत

स्थानीय शाखाओं की जाँच करें जिसमें दूरस्थ (एस) शाखाएँ शामिल हैं।

$ git branch
  cicd
  master
* preprod
— ग्रेग वीगनर
स्रोत
4

PowerShell का उपयोग करने वाले Windows उपयोगकर्ताओं के लिए:

git branch -r | ForEach-Object {
    # Skip default branch, this script assumes
    # you already checked-out that branch when cloned the repo
    if (-not ($_ -match " -> ")) {
        $localBranch = ($_ -replace "^.*?/", "")
        $remoteBranch = $_.Trim()
        git branch --track "$localBranch" "$remoteBranch"
    }
}
git fetch --all
git pull --all
— kiewic
स्रोत
यह शाखाओं के साथ / नाम के साथ काम करता है: git branch -r | ForEach-Object { # Skip default branch, this script assumes # you already checked-out that branch when cloned the repo if (-not ($_ -match " -> ")) { $localBranch = ($_ -replace "^.*?/", "") $remoteBranch = $_.Trim() git branch --track "$localBranch" "$remoteBranch" } }
— मार्कस
3

यहाँ कुछ मैं मजबूत पर विचार करेंगे:

  • मौजूदा शाखाओं के लिए दूरस्थ ट्रैकिंग अपडेट नहीं करता है
  • HEADट्रैक करने के लिए अद्यतन करने का प्रयास नहीं करता हैorigin/HEAD
  • के अलावा अन्य नाम से छूट देता है origin
  • उचित रूप से खोल दिया गया
for b in $(git branch -r --format='%(refname:short)'); do
  [[ "${b#*/}" = HEAD ]] && continue
  git show-ref -q --heads "${b#*/}" || git branch --track "${b#*/}" "$b";
done
git pull --all

यह आवश्यक नहीं है git fetch --allइस विकल्प को आंतरिक में पास -allकरने के लिए git pullपासfetch ।

करने के लिए क्रेडिट इस जवाब ।

— टॉम हेल
स्रोत
2

यहां स्वीकृत उत्तर में दिए गए वन-लाइनर का एक पर्ल संस्करण है:

git branch -r | perl -e 'while(<>) {chop; my $remote = $_; my ($local) = ($remote =~ /origin\/(.*)/); print "git branch --track $local $remote\n";}' > some-output-file

यदि आप चाहें तो आउटपुट फ़ाइल को शेल स्क्रिप्ट के रूप में चला सकते हैं।

हमने दुर्घटना से हमारी Stash प्रोजेक्ट रिपॉजिटरी को डिलीट कर दिया। सौभाग्य से किसी ने आकस्मिक नुकसान से ठीक पहले एक कांटा बनाया था। मैंने अपने स्थानीय को कांटा क्लोन किया (मैंने यह कैसे किया, इसके विवरण को छोड़ दूंगा)। एक बार जब मैं अपने स्थानीय में पूरी तरह से कांटा था, तो मैंने एक-एक-लाइनर चलाया। हमने दूरस्थ URL को (मेरे मामले में उत्पत्ति) को संशोधित किया था ताकि हम उस लक्ष्य रिपॉजिटरी को इंगित कर सकें जो हम ठीक कर रहे थे:

git remote set-url origin <remote-url>

और अंत में सभी शाखाओं को मूल की तरह धकेल दिया:

git push --all origin

और हम व्यापार में वापस आ गए थे।

— जोस क्विजादा
स्रोत
1

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

git branch -r | grep origin | grep -v HEAD| awk -F/ '{print $NF}' > /tmp/all.txt
git tag -l >> /tmp/all.txt
for tag_or_branch in `cat /tmp/all.txt`; do git checkout $tag_or_branch; git pull origin $tag_or_branch; done
— anhlc
स्रोत
1

यदि आपको समस्या है fetch --allतो अपनी दूरस्थ शाखा को ट्रैक करें:

git checkout --track origin/%branchname%
— open-ecommerce.org
स्रोत
1

त्रुटि संदेश से बचने के लिए 'घातक:' मूल / मास्टर नाम की एक शाखा पहले से मौजूद है। ', आपको इसकी आवश्यकता है:

git branch -r | grep -v '\->'  | grep -v `git branch | awk '/\*/ { print $2; }'`| while read remote; do git branch --track "${remote#origin/}" "$remote"; done
— HaxtraZ
स्रोत
0

Learath2 द्वारा दिए गए उत्तर के आधार पर, यहां मैंने जो किया git clone [...]और cdबनाया निर्देशिका में करने के बाद किया :

git branch -r | grep -v master | awk {print\$1} | sed 's/^origin\/\(.*\)$/\1 &/' | xargs -n2 git checkout -b

मेरे लिए काम किया है, लेकिन मुझे नहीं पता कि यह आपके लिए काम करेगा। सावधान रहे।

— erikano
स्रोत
0 
git remote add origin https://yourBitbucketLink

git fetch origin

git checkout -b yourNewLocalBranchName origin/requiredRemoteBranch (use tab :D)

अब स्थानीय रूप से आपका yourNewLocalBranchNameहै requiredRemoteBranch।

— छोटू सरदार
स्रोत
0

विज़ुअल स्टूडियो उपयोगकर्ताओं के लिए, पैकेज मैनेजर कंसोल पर:

गिट शाखा | % {गिट अपस्ट्रीम; git मर्ज अपस्ट्रीम / मास्टर}

— जोस ऑर्टेगा
स्रोत
0

कई तरीके आजमाए हैं, केवल यह सरल है और मेरे लिए काम करता है।

for branch in $(git ls-remote -h git@<your_repository>.git | awk '{print $2}' | sed 's:refs/heads/::')
do
  git checkout "$branch"
  git pull
done
— पृष्ठ नहीं मिला
स्रोत
0

उपनाम सेट करें: (शीर्ष उत्तर पर आधारित)

git config --global alias.track-all-branches '!git fetch --all && for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done && git fetch --all'

अब सभी शाखाओं को ट्रैक करने के लिए:

git track-all-branches

— टोटके विटल
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.