git - गिट में सभी रिमोट शाखाओं को कैसे क्लोन करें?




github git-branch (20)

उन आदेशों का प्रयोग करें जिन्हें आप याद कर सकते हैं

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

पहले अपने संग्रह को क्लोन करें, फिर गंतव्य फ़ोल्डर में बदलें। और अंतिम लेकिन कम से कम लाने और चेकआउट नहीं:

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

बस। यहां एक वास्तविक दुनिया का उदाहरण है:

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

आपको दस्तावेज़ों में कमांड के बारे में विस्तृत जानकारी मिल जाएगी: क्लोन कमांड , लेट कमांड , चेकआउट कमांड

मेरे पास एक master और एक development शाखा है, दोनों गिटहब को धक्का दिया। मैंने clone डी किया है, एड pull , और एड को fetch , लेकिन मैं master शाखा के अलावा कुछ भी पाने में असमर्थ हूं।

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


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

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 शाखा origin/branchone शाखा के आधार पर origin/branchone स्थानीय शाखा का नाम है; यदि आप इसके बजाय अलग-अलग नामों के साथ स्थानीय शाखाएं बनाना चाहते हैं, तो आप यह कर सकते हैं:

git branch localbranchname origin/branchone

एक बार जब आप स्थानीय शाखा बना लेते हैं, तो आप इसे git branch साथ देख सकते हैं (याद रखें, आपको स्थानीय शाखाओं को देखने की ज़रूरत नहीं है)।


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

git clone <your_http_url>

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

git branch -a

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

git checkout <your_branch_name>

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


इस 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 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 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 सामान्य रूप से: आरएम-आरएफ ब्रह्मांड की प्रतिलिपि बनाने से पहले अपने सेटअप में परीक्षण करें क्योंकि हम इसे जानते हैं

एक लाइनर के लिए क्रेडिट उपयोगकर्ता सीएफआई पर जाते हैं


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


एक स्थानीय रेपो से क्लोनिंग गिट क्लोन और गिट fetch के साथ काम नहीं करेगा: कई शाखाओं / टैग unfetched रहेगा।

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

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

के बारे में,

$ गिट चेकआउट -बी प्रयोगात्मक उत्पत्ति / प्रयोगात्मक

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

$ git checkout -t origin/experimental

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

$ git checkout --track origin/experimental

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


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

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. मास्टर और हेड को छोड़कर रिमोट की सभी शाखाओं के माध्यम से लूप
    1. स्थानीय शाखा हटाएं (ताकि हम बल-अद्यतन शाखाओं की जांच कर सकें)
    2. रिमोट से शाखा की जांच करें
  4. मास्टर की जांच करें (इसके लिए)

VonC answer के आधार पर।


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

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

git checkout -b dev refs/remotes/origin/dev

जो कुछ इस तरह वापस करना चाहिए:

Branch dev set up to track remote branch refs/remotes/origin/dev.
Switched to a new branch "dev"

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


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

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

लेकिन सावधान रहें, अगर रिमोट शाखाओं में से एक को admin_master नाम दिया गया है तो यह डाउनलोड नहीं होगा!

मूल विचार के लिए bigfish के लिए धन्यवाद


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

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

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

अंत में, यादों को आसान बनाने के लिए, सभी आदेशों में उपनाम होते हैं।

ध्यान दें कि यह git_remote_branch ;-)

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

git_remote_branch version 0.2.6

  Usage:

  grb create branch_name [origin_server] 

  grb publish branch_name [origin_server] 

  grb rename branch_name [origin_server] 

  grb delete branch_name [origin_server] 

  grb track branch_name [origin_server] 



  Notes:
  - If origin_server is not specified, the name 'origin' is assumed 
    (git's default)
  - The rename functionality renames the current branch

  The explain meta-command: you can also prepend any command with the 
keyword 'explain'. Instead of executing the command, git_remote_branch 
will simply output the list of commands you need to run to accomplish 
that goal.

  Example: 
    grb explain create
    grb explain create my_branch github

  All commands also have aliases:
  create: create, new
  delete: delete, destroy, kill, remove, rm
  publish: publish, remotize
  rename: rename, rn, mv, move
  track: track, follow, grab, fetch

मेरे द्वारा यहां देखे गए सभी उत्तर वैध हैं लेकिन एक भंडार क्लोन करने और सभी शाखाओं को एक साथ खींचने के लिए एक बहुत साफ तरीका है।

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

$ git branch -a

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

$ git checkout -b branchname origin/branchname

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

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

  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" कमांड के साथ देख सकते हैं।

  1. दूसरा कदम

इस भंडार को रिक्त (नंगे) भंडार से नियमित भंडार में स्विच करें ताकि गिट कॉन्फ़िगरेशन के बूलियन मान "नंगे" को झूठी में बदलकर स्विच किया जा सके:

$ git config --bool core.bare false
  1. तीसरा चरण

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

$ git reset --hard

तो अब आप "गिट शाखा" कमांड टाइप कर सकते हैं और आप देख सकते हैं कि सभी शाखाएं डाउनलोड की गई हैं।

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


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

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

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

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

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

git branch

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

*your current branch 
some branch2
some branch3 

उस संकेत पर ध्यान दें जो वर्तमान शाखा को दर्शाता है।


सबसे पहले, एक रिमोट Git भंडार और cd में क्लोन करें:

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

इसके बाद, अपने भंडार में स्थानीय शाखाओं को देखें:

$ git branch
* master

लेकिन आपकी भंडार में छिपी हुई अन्य शाखाएं हैं! आप इन्हें ध्वज का उपयोग करके देख सकते हैं:

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

वह आखिरी पंक्ति कुछ लोगों को फेंकता है: "नई शाखा" - हुह? इसका वास्तव में क्या अर्थ है कि शाखा को इंडेक्स से लिया गया है और आपके लिए स्थानीय रूप से बनाया गया है। पिछली पंक्ति वास्तव में अधिक जानकारीपूर्ण है क्योंकि यह आपको बताती है कि शाखा को दूरस्थ शाखा को ट्रैक करने के लिए स्थापित किया जा रहा है, जिसका आमतौर पर मूल / शाखा_नाम शाखा का अर्थ होता है

अब, यदि आप अपनी स्थानीय शाखाओं को देखते हैं, तो आप यही देखेंगे:

$ 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 branch करते हैं, तो वे छिपे हुए हैं ...

तो यदि आप सभी शाखाओं के नाम देखना चाहते हैं, तो बस इस तरह के ध्वज को जोड़ दें:

git branch --all git branch -a या git branch -a

यदि आप सिर्फ शाखा में चेकआउट करते हैं, तो आपको अपनी आवश्यकता होती है।

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

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

git fetch

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

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

git fetch && git checkout your_branch_name

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


इनमें से कोई भी जवाब इसे काट नहीं देता है, सिवाय इसके कि उपयोगकर्ता कोई भी सही रास्ते पर नहीं है।

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

तो मैंने इन दो तरीकों को बहुत उपयोगी पाया। उम्मीद है कि वे किसी और की मदद करेंगे।

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

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

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


गिट आमतौर पर (निर्दिष्ट नहीं होने पर 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(इस post देखें )।

मैं यहां अपने 2 सेंट जोड़ने जा रहा हूं क्योंकि मैं यह पता लगाने की कोशिश कर रहा हूं कि एक दूरस्थ शाखा को कैसे खींचें जिसे मैंने स्थानीय रूप से हटा दिया था। उत्पत्ति मेरी नहीं थी, और मैं सबकुछ फिर से क्लोन करने की परेशानी से गुजरना नहीं चाहता था

यह मेरे लिए काम किया:

यह मानते हुए कि आपको स्थानीय रूप से शाखा को फिर से बनाना होगा:

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

तो अगर मैंने गिटुसर / मास्टर से एसजेपी तक फोर्क किया और फिर इसे एसजेपी / मायनब्रैंच में ब्रांच किया तो यह इस तरह दिखेगा:

$ git checkout -b mynewbranch
$ git branch -a
  master
  remotes/sjp/master
  remotes/sjp/mynewbranch
$ git fetch (habit to always do before)
$ git rebase remotes/sjp/mynewbranch

मैंने इस छोटे पावरहेल फ़ंक्शंस को अपनी सभी गिट शाखाओं को चेकआउट करने में सक्षम होने के लिए लिखा है , जो मूल रिमोट पर हैं।

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

मेरे गिट सेटिंग्स रेपो पर अधिक गिट फ़ंक्शन मिल सकते हैं







remote-branch