मैं उन सभी गिट शाखाओं को कैसे हटा सकता हूं जिनका विलय हो चुका है?

Question

मेरी कई गिट शाखाएं हैं। मैं उन शाखाओं को कैसे हटाऊं जिनका विलय पहले ही हो चुका है? क्या एक-एक करके उन्हें हटाने के बजाय उन सभी को हटाने का एक आसान तरीका है?

Comments

git branch -Dकिसी भी शाखा को थोड़ा अधिक विशिष्ट हटा दिया जाना चाहे वह विलय हो गई हो या नहीं।

— फिल

आप इसे सीधे GitHub से भी कर सकते हैं, यदि आप अपने रेपो के 'शाखाओं' अनुभाग (जैसे github.com/<username>/<repo_name>/branches ) पर जाते हैं। आपकी सभी शाखाओं की एक सूची होनी चाहिए, जिसके किनारे पर लाल ट्रैशकेन आइकन होगा जो चयनित शाखा को हटा देगा। टर्मिनल में करने की तुलना में बहुत तेज! यह भी दिखाएगा कि masterप्रत्येक शाखा कितनी आगे / पीछे है। हालाँकि, यदि आप चलाते हैं git branch -a, तो आपका स्थानीय क्लाइंट अभी भी पुरानी शाखाओं को सूचीबद्ध करेगा ; git fetch --pruneउन्हें निकालने के लिए उपयोग करें ( इस उत्तर के अनुसार )।

— user5359531

इसे स्थानीय रूप से या दूरस्थ रूप से करने के लिए स्क्रिप्ट - सुरक्षा जांच और पूर्व-कॉन्फ़िगर "सुरक्षित शाखाओं" के साथ: github.com/fatso83/dotfiles/tree/master/utils/… git delete-merged --doit origin याgit delete-merged --doit --local

— oligofren

आप इस ऐप को मर्ज की गई शाखाओं को ऑटो डिलीट करने के लिए भी इस्तेमाल कर सकते हैं।

— सेबास वैन बॉक्सेल

rm -fr work && git clone http://example.com/work.gitपिछले कुछ वर्षों में अचार से निकलने का सबसे आसान तरीका बन गया है।

— रिएक्टगुलर

Answer 1

अपडेट करें:

यदि आपके वर्कफ़्लो में संभावित पूर्वज के रूप में है, तो आप मास्टर और देव को बाहर करने के लिए अन्य शाखाएँ जोड़ सकते हैं। आमतौर पर मैं एक "स्प्रिंट-स्टार्ट" टैग से अलग हो जाता हूं और मास्टर, देव और क्यूए पूर्वज नहीं होते हैं।

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

git branch --merged

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

git branch --merged| egrep -v "(^\*|master|dev)"

यदि आप स्किप करना चाहते हैं, तो आप इसे निम्न की तरह egrep कमांड में जोड़ सकते हैं। शाखा skip_branch_nameहटाई नहीं जाएगी।

git branch --merged| egrep -v "(^\*|master|dev|skip_branch_name)"

सभी स्थानीय शाखाओं को हटाने के लिए जो पहले से ही वर्तमान में जाँच की गई शाखा में विलय हो चुकी हैं:

git branch --merged | egrep -v "(^\*|master|dev)" | xargs git branch -d

आप देख सकते हैं कि यदि वे पूर्वज हैं तो गुरु और देव को बाहर रखा गया है।

---

आप इसके साथ मर्ज की गई स्थानीय शाखा को हटा सकते हैं:

git branch -d branchname

यदि यह विलय नहीं हुआ है, तो उपयोग करें:

git branch -D branchname

दूरस्थ उपयोग से इसे हटाने के लिए:

git push --delete origin branchname

git push origin :branchname    # for really old git

एक बार जब आप शाखा को रिमोट से हटा देते हैं, तो आप दूरस्थ ट्रैकिंग शाखाओं से छुटकारा पाने के लिए prune कर सकते हैं:

git remote prune origin

या अलग-अलग दूरस्थ ट्रैकिंग शाखाएँ, जैसा कि अन्य उत्तर से पता चलता है:

git branch -dr branchname

उम्मीद है की यह मदद करेगा।

Comments

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

— गैरी हरण

चेतावनी के अवसर: रिफ्लक्स आपके बेकन को बचाएगा। तो चिंता मत करो।

— एडम डिमिट्रुक

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

— ifightcrime

PowerShell वैरिएंट, ताकि अगली बार जब भी मैं इसका उत्तर git branch --merged | %{$_.trim()} | ?{$_ -notmatch 'develop' -and $_ -notmatch 'master'} | %{git branch -d $_}

— पा सकूं

यह एक त्रुटि उत्पन्न करता है fatal: branch name requiredयदि आपकी कोई शाखा नहीं है जिसे हटा दिया जाना चाहिए। इससे बचने के लिए कि आप पास -rहो सकते हैं, अगर स्टड खाली है xargsतो यह नहीं चलेगा git branch -d। (यह GNU xargs एक्सटेंशन है, मैन पेज के अनुसार)।

— मारीस गेदमिनस

Answer 2

दूरस्थ सभी शाखाओं को हटाने के लिए जो पहले से ही मर्ज हैं:

git branch -r --merged | grep -v master | sed 's/origin\//:/' | xargs -n 1 git push origin

Git के अधिक हाल के संस्करणों में

git branch -r --merged | grep -v master | sed 's/origin\///' | xargs -n 1 git push --delete origin

अद्यतन (@oliver के बाद से; क्योंकि टिप्पणी में फिट नहीं है, लेकिन पहले से ही पर्याप्त जवाब) : यदि आप शाखा एबीसी पर हैं तो एबीसी परिणामों में दिखाई देगाgit branch -r --merged क्योंकि शाखा निर्दिष्ट नहीं है, इसलिए शाखा वर्तमान शाखा और एक शाखा में चूक करती है हमेशा अपने आप में विलीन हो जाता है (क्योंकि एक शाखा और खुद के बीच कोई मतभेद नहीं हैं!)।

तो या तो शाखा निर्दिष्ट करें:

git branch -r --merged master | grep -v master ...

या पहले चेकआउट मास्टर:

git checkout master | git branch -r --merged | grep -v ...

Comments

अब तक का सबसे अच्छा जवाब। बस एक नोट, मेरी मास्टर ब्रांच का नाम है devइसलिए मुझे यह बदलना पड़ा

— डोरियन

मैं जोड़ने के लिए किया था | grep originके बाद grep -v masterमूल करने के लिए अन्य रिमोट की शाखाओं को आगे बढ़ाने को रोकने के लिए। अत्यधिक उत्पादन की जांच करने की सिफारिश पहले से, उपयोग करgit branch -r --merged | grep -v master | grep origin | sed 's/origin\//:/' | xargs -n 1 echo

— L0LN1NJ4

मैंने developशाखा को अलग करने के लिए थोड़ा संशोधित किया । git branch -r --merged | grep -v master | grep -v develop | sed 's/origin\///' | xargs -n 1 git push --delete origin। अब यह मेरा उपनाम था।

— सरट

मैंने जो सबसे अच्छा उत्तर पढ़ा है, वह -rतर्क है, जिसे मैंने कहीं और नहीं देखा है। यह ध्यान में रखा जाता है कि केवल स्थानीय शाखाएँ ही कुछ हाउसकीपिंग करने लायक हैं। लेकिन अवशेष कचरे से भी भरे हैं।

— Asbjørn Ulsberg

सावधानी - बस एहसास हुआ: यह स्पष्ट रूप से वर्तमान शाखा में विलीन होने वाली शाखाओं को मिलेगा , न कि मास्टर, इसलिए यदि आप इस पर हैं myFeatureBranchतो यह मिटा देगा origin/myFeatureBranch। संभवतः यह सबसे git checkout masterपहले सबसे अच्छा है ।

— jakub.g

Answer 3

बस आदम के उत्तर को थोड़ा विस्तार देना:

इसे चलाकर अपने Git कॉन्फ़िगरेशन में जोड़ें git config -e --global

[alias]
    cleanup = "!git branch --merged | grep  -v '\\*\\|master\\|develop' | xargs -n 1 git branch -d"

और फिर आप एक सरल कार्य करने वाली सभी स्थानीय मर्ज की गई शाखाओं को हटा सकते हैं git cleanup।

Comments

पहला आदेश नहीं होना चाहिए: git branch --merged masterचूंकि आप यह देखना चाहते हैं कि मास्टर में क्या विलय किया गया है, वर्तमान में शाखा की जाँच नहीं की गई है?

— जो फिलिप्स

@JoePhilllips कुछ लोगों के पास मुख्य शाखा नहीं है, बल्कि मास्टर developया इसके बजाय devऔर इस मामले में कमांड के साथ विफल हो जाएगा fatal: malformed object nameयह एक सामान्य कमांड रखना बेहतर है और आपके पास इसे चलाने की जिम्मेदारी है

— smohamed

@JoePhilllips इस उत्तर का बिंदु एडम के जवाब (इस प्रश्न के लिए शीर्ष उत्तर) को सहायक उपनाम में पैकेज करना है। एडम का जवाब नहीं है कि आप क्या सुझाव दे रहे हैं और इतने सारे लोगों ने पाया है कि उपयोगी है तो मैं चाहूंगा कि मेरा बदलाव न हो। यदि आप इसके बारे में दृढ़ता से महसूस करते हैं तो मैं एडम के जवाब पर चर्चा खोलने की सलाह दूंगा

— real_ate

जोड़ने -rके लिए xargsअनावश्यक त्रुटियों को रोकने जाएगा ( branch name required) जब इस उर्फ कई बार चल रहे हैं या जब कोई शाखा हटाए जाने के लिए छोड़ दिया है। मेरा उपनाम इस तरह दिखता है:cleanup = "!git branch --merged | grep -v -P '^\\*|master|develop' | xargs -n1 -r git branch -d"

— स्पेजिफ़ंटा

वर्तमान कमांड मास्टर को फ़िल्टर नहीं करती है और शाखाओं का विकास करती है

— एंड्री एफ।

Answer 4

यह मास्टर को छोड़कर सभी मर्ज की गई शाखाओं को हटाने के लिए भी काम करता है।

git branch --merged | grep -v '^* master$' | grep -v '^  master$' | xargs git branch -d

Comments

अब इसमें कोई भी शाखा नहीं हटेगी master। grep -v ^master$बीच के लिए प्रयास करें ।

— वचर्जिन

| grep -v '^\*'यदि आप मास्टर पर नहीं

— svassr

यह बहुत अच्छा है, धन्यवाद! इसका उपयोग करने वाले किसी व्यक्ति के लिए एक चेतावनी: ध्यान दें कि इसमें दो स्थान हैं grep -v '^ master$'। यदि आप इसे अपने आप में टाइप करते हैं और एक को मिस करते हैं, तो masterयदि आप उस पर नहीं हैं , तो आप उसे हटा देंगे ।

— स्टाइलर

@ Mr.Polywhirl आपका संपादन कमांड को तोड़ता है और आपको इसे वापस करना चाहिए। दो रिक्त स्थान आवश्यक हैं, क्योंकि git branchप्रत्येक शाखा का नाम नई पंक्ति पर दो रिक्त स्थान के साथ बाईं ओर सूचीबद्ध होगा यदि यह वर्तमान में जाँच की गई शाखा नहीं है। आपने अनिवार्य रूप से गारंटी दी है कि जो कोई भी इस कमांड को चलाता है वह अपनी मास्टर शाखा को हटा देगा, जब तक कि वह वर्तमान में चेक की गई शाखा नहीं है।

— स्टाइलर

Answer 5

आप उन आदेशों से master& developशाखाओं को बाहर करना चाहेंगे ।

स्थानीय गिट स्पष्ट:

git branch --merged | grep -v '\*\|master\|develop' | xargs -n 1 git branch -d

दूरस्थ गिट स्पष्ट:

git branch -r --merged | grep -v '\*\|master\|develop' | sed 's/origin\///' | xargs -n 1 git push --delete origin

दूरस्थ शाखाओं की स्थानीय रजिस्ट्री सिंक करें:

git fetch -p

Comments

+1 दूरस्थ संस्करण के लिए भी (लेकिन कम आवश्यकता के रूप में हमारे पास रिमोट-prune) है। यह भी ध्यान देने योग्य है कि

— थियोस

git config --global --add fetch.prune trueस्वचालित रूप से लाने या खींचने के लिए।

— T3rm1

आप पर ध्यान दें, प्रून रिमोट के समान नहीं है। दूरस्थ स्पष्ट वास्तव में उन दूरस्थ शाखाओं को हटा देता है जो आपकी वर्तमान शाखा के साथ पूरी तरह से विलय हो जाती हैं। Prune केवल पहले से हटाई गई दूरस्थ शाखाओं की आपकी स्थानीय रजिस्ट्री को साफ़ करता है।

— गुइडो बोमन

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

— scones

एक कॉल में सभी मूल हटाने को हटाने के लिए, मैंने इसका इस्तेमाल किया:git branch -r --merged | grep -v '\*\|master\|develop' | grep '^\s*origin/' | sed 's/origin\///' | tr "\n" " " | xargs git push --delete origin

— GPHemsley

Answer 6

आप में से जो Windows पर हैं और PowerShell स्क्रिप्ट पसंद करते हैं, उनके लिए यहाँ स्थानीय विलय वाली शाखाओं को हटा दिया गया है:

function Remove-MergedBranches
{
  git branch --merged |
    ForEach-Object { $_.Trim() } |
    Where-Object {$_ -NotMatch "^\*"} |
    Where-Object {-not ( $_ -Like "*master" )} |
    ForEach-Object { git branch -d $_ }
}

Comments

जिज्ञासा के लिए, इसे छोटा किया जा सकता है git branch --merged | ?{-not ($_ -like "*master")} | %{git branch -d $_.trim()}

— इयान बेलार्ड

@IainBallard ज़रूर, मैं उपनामों का इस्तेमाल कर सकता था। जब आप पठनीयता को अधिकतम करना चाहते हैं तो इसकी अनुशंसा नहीं की जाती है। github.com/darkoperator/PSStyleGuide/blob/master/English.md

— Klas Mellbourn

ज़रूर। मुझे आपका उत्तर बहुत मददगार लगा :-) हालांकि कभी-कभी ब्लॉक में जो चल रहा होता है, उसमें लंबे-चौड़े पॉवरशेल सिंटैक्स मिलते हैं। लेकिन मुख्य रूप से, मैं आगे कुछ डाल रहा था जिसे आप कॉपी / पेस्ट या टाइप कर सकते हैं। एक बार फिर धन्यवाद।

— इयान बलार्ड

यहां विंडोज cmd शेल के लिए एक-लाइनर है जो मास्टर और आपकी वर्तमान शाखा को संरक्षित करता है: for /f "usebackq" %B in (``git branch --merged^|findstr /v /c:"* " /c:"master"``) do @git branch -d %B(आह, डबल-बैकक्वाट्स को सिंगल के साथ बदलें, मुझे यकीन नहीं है कि शाब्दिक रूप से बैककौट्स को कैसे प्रारूपित किया जाए)

— yoyo

Answer 7

मैंने अब सालों तक एडम के जवाब का इस्तेमाल किया है। उस ने कहा, कि कुछ मामले हैं जहां यह व्यवहार नहीं कर रहा था जैसा कि मुझे उम्मीद थी:

1. जिन शाखाओं में "मास्टर" शब्द शामिल था, उन्हें केवल मास्टर शाखा के बजाय "नॉटमास्टर" या "मास्टरफुल" अनदेखा किया गया था
2. शाखाओं जिसमें "देव" शब्द शामिल था, केवल देव शाखा के बजाय "देव-परीक्षण" को अनदेखा किया गया था
3. उन शाखाओं को हटाना जो वर्तमान शाखा के HEAD से पहुंच रहे हैं (जो जरूरी नहीं कि मास्टर हों)
4. अलग राज्य में, हर शाखा को वर्तमान प्रतिबद्ध से हटाने योग्य

रेगेक्स में केवल एक बदलाव के साथ, 1 और 2 पते के लिए सीधे थे। 3 इस बात पर निर्भर करता है कि आप क्या चाहते हैं (यानी केवल उन शाखाओं को हटा दें जिन्हें मास्टर में या आपकी वर्तमान शाखा में विलय नहीं किया गया है)। 4 में विनाशकारी होने की संभावना है (हालांकि इसके साथ पुनर्प्राप्त करने योग्य git reflog), यदि आप अनजाने में अलग किए गए HEAD राज्य में चले गए।

अंत में, मैं चाहता था कि यह सब एक-लाइनर में हो, जिसे अलग (बश | रूबी | पायथन) स्क्रिप्ट की आवश्यकता नहीं थी।

टी एल; डॉ

एक वैकल्पिक उपनाम स्वीकार करता है कि एक "उपनाम" झाडू बनाएँ -f:

git config --global alias.sweep '!git branch --merged $([[ $1 != "-f" ]] \
&& git rev-parse master) | egrep -v "(^\*|^\s*(master|develop)$)" \
| xargs git branch -d'

और इसके साथ आह्वान करें:

git sweep

या:

git sweep -f

लंबा, विस्तृत जवाब

मेरे लिए कुछ शाखाओं के साथ एक उदाहरण git रेपो बनाना आसान था और सही व्यवहार का परीक्षण करने के लिए करता है:

एक सिंगल कमिट के साथ एक नया git रेपो बनाएं

mkdir sweep-test && cd sweep-test && git init
echo "hello" > hello
git add . && git commit -am "initial commit"

कुछ नई शाखाएँ बनाएँ

git branch foo && git branch bar && git branch develop && git branch notmaster && git branch masterful
git branch --list

  bar
  develop
  foo
* master
  masterful
  notmaster

वांछित व्यवहार: मास्टर, विकास या वर्तमान : को छोड़कर सभी विलय की गई शाखाओं का चयन करें

मूल रेगेक्स "मास्टरफुल" और "नॉटमास्टर" शाखाओं को याद करता है:

git checkout foo
git branch --merged | egrep -v "(^\*|master|dev)"

  bar

अपडेटेड रेगेक्स के साथ (जो अब "देव" के बजाय "विकसित" को बाहर करता है):

git branch --merged | egrep -v "(^\*|^\s*(master|develop)$)"

bar
masterful
notmaster

ब्रांच फू में स्विच करें, एक नया कमिट करें, फिर एक नया ब्रांच चेकआउट करें, फू के आधार पर, फोबार,

echo "foo" > foo
git add . && git commit -am "foo"
git checkout -b foobar
echo "foobar" > foobar
git add . && git commit -am "foobar"

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

git branch --merged | egrep -v "(^\*|^\s*(master|develop)$)"

  bar
  foo
  masterful
  notmaster

हालाँकि, यदि मैं मास्टर पर एक ही कमांड चलाता हूं, तो शाखा "फू" शामिल नहीं है:

git checkout master && git branch --merged | egrep -v "(^\*|^\s*(master|develop)$)"

  bar
  masterful
  notmaster

और यह केवल इसलिए है क्योंकि git branch --mergedवर्तमान शाखा के प्रमुख के लिए चूक अन्यथा निर्दिष्ट नहीं है। कम से कम मेरे वर्कफ़्लो के लिए, मैं स्थानीय शाखाओं को हटाना नहीं चाहता, जब तक कि उन्हें मास्टर में विलय नहीं किया गया है, इसलिए मैं निम्नलिखित संस्करण को पसंद करता हूं:

git checkout foobar
git branch --merged $(git rev-parse master) | egrep -v "(^\*|^\s*(master|develop)$)"

  bar
  masterful
  notmaster

अलग राज्य

git branch --mergedअलग-थलग पड़ने के डिफ़ॉल्ट व्यवहार पर निर्भर राज्य में और भी अधिक महत्वपूर्ण परिणाम हैं:

git checkout foobar
git checkout HEAD~0
git branch --merged | egrep -v "(^\*|^\s*(master|develop)$)"

  bar
  foo
  foobar
  masterful
  notmaster

इससे मैं केवल "फू" के साथ "फोब्बर" पर लगी शाखा को हटा देता था, जो निश्चित रूप से वांछित परिणाम नहीं है। हमारे संशोधित आदेश के साथ, हालांकि:

git branch --merged $(git rev-parse master) | egrep -v "(^\*|^\s*(master|develop)$)"

  bar
  masterful
  notmaster

वास्तविक डिलीट सहित एक लाइन

git branch --merged $(git rev-parse master) | egrep -v "(^\*|^\s*(master|develop)$)" | xargs git branch -d

सभी एक उर्फ ​​"स्वीप" में लिपटे:

git config --global alias.sweep '!git branch --merged $([[ $1 != "-f" ]] \
&& git rev-parse master) | egrep -v "(^\*|^\s*(master|develop)$)" \
| xargs git branch -d'

उपनाम एक वैकल्पिक -fध्वज को स्वीकार करता है । डिफ़ॉल्ट व्यवहार केवल उन शाखाओं को हटाने के लिए है जिन्हें मास्टर में विलय कर दिया गया है, लेकिन -fध्वज उन शाखाओं को हटा देगा जिन्हें वर्तमान शाखा में विलय कर दिया गया है।

git sweep

Deleted branch bar (was 9a56952).
Deleted branch masterful (was 9a56952).
Deleted branch notmaster (was 9a56952).

git sweep -f

Deleted branch foo (was 2cea1ab).

Comments

आपको एक फ़ंक्शन बनाने की आवश्यकता क्यों है? git configपरमाणु नहीं है ?

— VasiliNovikov

वैकल्पिक '-f' तर्क से निपटने के लिए (अगर मैं आपके सवाल का सही ढंग से समझ)

— eddies

लेकिन यह कैसे मदद करता है? मेरा मतलब है अभिव्यक्ति की शुरुआत !f(){ git branch ...,। यह एक फ़ंक्शन घोषणा है, है ना? सीधे शुरुआत क्यों नहीं की git branch ...?

— VasiliNovikov

आप बिल्कुल सही कह रहे है। मेरे हिसाब से जवाब दिया। सूचक के लिए धन्यवाद!

— eddies

निम्नलिखित गैर-बल-मोड के समान नहीं होगा? git checkout master && git branch -d `git branch --merged` && git checkout - सिवाय इसके कि यह नष्ट developहो जाएगा, लेकिन एक सरल तरीका हो सकता है।

— गुइडो बुमैन

Answer 8

Git Sweep इसका बहुत अच्छा काम करता है।

Comments

अभी, इस परियोजना का रखरखाव नहीं किया गया है। देखें github.com/arc90/git-sweep/pull/43

— शाम

Answer 9

Git संस्करण 2.5.0 का उपयोग करना:

git branch -d `git branch --merged`

Comments

यह masterशाखा btw को हटा सकता है !

— वेजरी

सच। मैं केवल इसका उपयोग करता हूं जब मुझे यकीन है कि मैं चालू हूं master।

— प्रात: d

git branch -d $(git branch --merged | grep -v master)

— एलेक्स मर्ग

यह खतरनाक है यदि आपके पास प्रवाह है, तो कल्पना करें कि आपके पास मास्टर <- चरण <- देव है। फिर भी सबसे आसान समाधान imo

— जोसेफ ब्रिग्स

Answer 10

आप कमिटेड को themermer विकल्प में जोड़ सकते हैं। इस तरह से आप केवल उन शाखाओं को हटाने के लिए सुनिश्चित कर सकते हैं जो मूल / मास्टर में विलय हो गई हैं

निम्नलिखित आदेश आपके मूल से विलय की गई शाखाओं को हटा देगा।

git branch -r --merged origin/master | grep -v "^.*master" | sed s:origin/:: |xargs -n 1 git push origin --delete 

आप परीक्षण कर सकते हैं कि कौन सी शाखाओं को हटा दिया जाएगा, जो कि गीट पुश ओरिजनल की जगह लेगा - इको के साथ

git branch -r --merged origin/master | grep -v "^.*master" | sed s:origin/:: |xargs -n 1 echo

Comments

मुझे टेस्ट ऑप्शन पसंद है

— iwein

Answer 11

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

#!/usr/bin/env ruby

current_branch = `git symbolic-ref --short HEAD`.chomp
if current_branch != "master"
  if $?.exitstatus == 0
    puts "WARNING: You are on branch #{current_branch}, NOT master."
  else
    puts "WARNING: You are not on a branch"
  end
  puts
end

puts "Fetching merged branches..."
remote_branches= `git branch -r --merged`.
  split("\n").
  map(&:strip).
  reject {|b| b =~ /\/(#{current_branch}|master)/}

local_branches= `git branch --merged`.
  gsub(/^\* /, '').
  split("\n").
  map(&:strip).
  reject {|b| b =~ /(#{current_branch}|master)/}

if remote_branches.empty? && local_branches.empty?
  puts "No existing branches have been merged into #{current_branch}."
else
  puts "This will remove the following branches:"
  puts remote_branches.join("\n")
  puts local_branches.join("\n")
  puts "Proceed?"
  if gets =~ /^y/i
    remote_branches.each do |b|
      remote, branch = b.split(/\//)
      `git push #{remote} :#{branch}`
    end

    # Remove local branches
    `git branch -d #{local_branches.join(' ')}`
  else
    puts "No branches removed."
  end
end

Comments

मन अगर मैं एक छोटे से सहायक सहायक पुस्तकालय के लिए इस tidbit चोरी? github.com/yupiq/git-branch-util

— logan

इसके लिए जाओ, मैं इसे यहाँ नहीं रखता अगर मैं किसी तरह से कोड का पुन: उपयोग करने वाले लोगों के बारे में परवाह करता

— mmrobins

@mmrobins आपके पास लाइन के \/लिए अस्वीकार बयान की शुरुआत में एक अतिरिक्त है remote_branches। क्या यह एक टाइपो है या यह एक उद्देश्य पूरा करता है?

— जावद

@ हमोबिन्स, ओह माइंड माइंड मैं b.split(/\//)अब लाइन नहीं देखता

— जावद

यदि आप मूल रूप से यह करना चाहते हैं, लेकिन माणिक के बजाय वेनिला बैश के माध्यम से: stackoverflow.com/a/37999948/430128

— रमन

Answer 12

PowerShell कंसोल में मर्ज की गई शाखाओं को हटाने के लिए कैसे करें

git branch --merged | %{git branch -d $_.Trim()}

यदि आप मास्टर या किसी अन्य शाखा नामों को बाहर करना चाहते हैं , तो आप इस तरह से PowerShell Select-String के साथ पाइप कर सकते हैं और परिणाम को पास कर सकते हैं git branch -d:

git branch -d $(git branch --merged | Select-String -NotMatch "master" | %{$_.ToString().Trim()})

Comments

उच्चतर उत्तर फ़िल्टरिंग मास्टर या अन्य शाखाओं का सुझाव दे रहे हैं। उन लोगों के लिए जो इसे शालीनता से देख रहे हैं: git Branch --merged | findstr / v "मास्टर" | % {git शाखा -d $ _। ट्रिम ()}

— tredzko

@tredzko अच्छी बात है। FTR का उच्चतर उत्तर है stackoverflow.com/questions/6127328/… - आप अपनी टिप्पणी को उस लिंक से जोड़ सकते हैं और फिर मैं इसे हटा

— दूंगा

यह हटाने की भी कोशिश करता है * master:)

— enसेन

Answer 13

कुबून का उत्तर उन शाखाओं को हटाने से चूक गया जिनके पास शाखा नाम में मास्टर शब्द है। उनके जवाब पर निम्नलिखित सुधार होता है:

git branch -r --merged | grep -v "origin/master$" | sed 's/\s*origin\///' | xargs -n 1 git push --delete origin

बेशक, यह "मास्टर" शाखा को हटाता नहीं है :)

Answer 14

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

यदि आपको यह जानने की आवश्यकता है कि क्या किसी शाखा को मास्टर में विलय कर दिया गया है, तो निम्न आदेश कोई आउटपुट नहीं देगा यदि myTopicBranch को विलय कर दिया गया है (यानी आप इसे हटा सकते हैं)

$ git rev-list master | grep $(git rev-parse myTopicBranch)

आप Git शाखा कमांड का उपयोग कर सकते हैं और Bash में सभी शाखाओं को पार्स कर सकते हैं और forसभी शाखाओं पर लूप कर सकते हैं। इस लूप में आप ऊपर दिए गए कमांड से जांचते हैं कि आप ब्रांच को डिलीट कर सकते हैं या नहीं।

Answer 15

git branch --merged | grep -Ev '^(. master|\*)' | xargs -n 1 git branch -dवर्तमान चेक आउट शाखा और / या को छोड़कर सभी स्थानीय शाखाओं को हटा देगा master।

इन आदेशों को समझने की तलाश करने वालों के लिए एक उपयोगी लेख यहां दिया गया है: Git Clean: डिलीट आलरेडी मर्ज ब्रांचेज, स्टीवन हरमन द्वारा ।

Answer 16

नोट : मैं पिछले उत्तरों से खुश नहीं हूं, (सभी प्रणालियों पर काम नहीं कर रहा हूं, रिमोट पर काम नहीं कर रहा हूं, - Themerged शाखा को निर्दिष्ट नहीं कर रहा हूं, बिल्कुल फ़िल्टर नहीं कर रहा हूं)। तो, मैं अपना जवाब जोड़ता हूं।

दो मुख्य मामले हैं:

स्थानीय

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

git branch --format "%(refname:short)" --merged master | grep -E -v '^master$|^feature/develop$' | xargs -n 1 git branch -d

नोट :

• git branch output --format ".." व्हाट्सएप को स्ट्रिप करने और सटीक grep मिलान की अनुमति है
• grep -Eके बजाय प्रयोग किया जाता है egrep , इसलिए यह बिना egrep (यानी: विंडोज़ के लिए गिट) के बिना सिस्टम में भी काम करता है।
• grep -E -v '^master$|^feature/develop$' स्थानीय शाखाओं को निर्दिष्ट करना है जिन्हें मैं हटाना नहीं चाहता
• xargs -n 1 git branch -d: स्थानीय शाखाओं को हटाने का कार्य करें (यह दूरस्थ लोगों के लिए काम नहीं करेगा)
• यदि आप वर्तमान में चेक-आउट की गई शाखा को हटाने का प्रयास करते हैं तो निश्चित रूप से आपको एक त्रुटि मिलती है। इसलिए, मैं पहले से ही मास्टर में जाने का सुझाव देता हूं।

रिमोट

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

git branch -r --format "%(refname:short)" --merged origin/master | grep -E -v '^*HEAD$|^*/master$|^*release' | cut -d/ -f2- | xargs -n 1 git push --delete origin

नोट :

• रिमोट के लिए, हम -rविकल्प का उपयोग करते हैं और पूर्ण शाखा नाम प्रदान करते हैं :origin/master
• grep -E -v '^*HEAD$|^*/master$|^*release' उन सुदूर शाखाओं का मिलान करना है जिन्हें हम हटाना नहीं चाहते हैं।
• cut -d/ -f2- : अनावश्यक 'मूल /' उपसर्ग को हटा दें जो अन्यथा द्वारा मुद्रित है git branch कमांड ।
• xargs -n 1 git push --delete origin : दूरस्थ शाखाओं को हटाने का कार्य करें।

Answer 17

आप Windows पर हैं, तो आप के साथ Windows PowerShell या Powershell 7 उपयोग कर सकते हैं बाहर GridView शाखाओं का एक अच्छा सूची है और माउस जो एक आप हटाना चाहते हैं के साथ चयन करने के लिए:

git branch --format "%(refname:short)" --merged  | Out-GridView -PassThru | % { git branch -d $_ }

OK Powershell पर क्लिक करने के बाद git branch -dकमांड और डिलीट करने के लिए इस ब्रांच के नाम पास करेंगे

Answer 18

आप git-del-br टूल का उपयोग कर सकते हैं ।

git-del-br -a

आप इसका pipउपयोग करके स्थापित कर सकते हैं

pip install git-del-br

पुनश्च: मैं उपकरण का लेखक हूं। किसी भी सुझाव / प्रतिक्रिया का स्वागत है।

Comments

@ stackoverflow.com/users/100297/martijn-pieters : यह उत्तर हटा दिया गया और अस्वीकृत क्यों कर दिया गया?

— tusharmakkar08

आपका जवाब और उपकरण काम नहीं करता है। मैं इस पर कुछ घंटे बिताता हूं। कुछ भी तो नहीं।

— SpoiledTechie.com

@ SpoiledTechie.com: क्या आप मुझे बता सकते हैं कि आप वास्तव में किस समस्या का सामना कर रहे हैं? मैं इसे नियमित रूप से उपयोग कर रहा हूं।

— tusharmakkar08

यदि आप इसे ऑफ़लाइन लेना चाहते हैं तो मैं एक स्क्रीनशॉट साझा कर सकता हूं? उस Google मेल पर खराब की गई चीज़। :)

— SpoiledTechie.com

Answer 19

यदि आप उन सभी स्थानीय शाखाओं को हटाना चाहते हैं जो पहले से मौजूद शाखा में विलीन हो चुकी हैं, तो मैं ऐसा करने के लिए एक सुरक्षित कमांड लेकर आया हूं, जो पहले के उत्तरों के आधार पर है:

git branch --merged | grep -v \* | grep -v '^\s*master$' | xargs -t -n 1 git branch -d

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

Answer 20

आदम के अद्यतन उत्तर का उपनाम संस्करण :

[alias]
    branch-cleanup = "!git branch --merged | egrep -v \"(^\\*|master|dev)\" | xargs git branch -d #"

इसके अलावा, जटिल उपनामों से बचने के आसान सुझावों के लिए इस उत्तर को देखें ।

Answer 21

मैं एक git-flow एस्के नामकरण योजना का उपयोग करता हूं, इसलिए यह मेरे लिए बहुत सुरक्षित रूप से काम करता है:

git branch --merged | grep -e "^\s\+\(fix\|feature\)/" | xargs git branch -d

यह मूल रूप से मर्ज किए गए कमिट्स की तलाश करता है जो fix/या तो स्ट्रिंग से शुरू होते हैं या feature/।

Answer 22

निम्नलिखित कमांड आज़माएं:

git branch -d $(git branch --merged | grep -vw $(git rev-parse --abbrev-ref HEAD))

का उपयोग करके इसे बाहर करने के लिए वर्तमान शाखा का नामgit rev-parse मिलेगा । यदि आपको त्रुटि मिली है, तो इसका मतलब है कि हटाने के लिए कोई स्थानीय शाखाएं नहीं हैं।

दूरस्थ शाखाओं के साथ भी ऐसा ही करें ( originअपने दूरस्थ नाम से बदलें ), कोशिश करें:

git push origin -vd $(git branch -r --merged | grep -vw $(git rev-parse --abbrev-ref HEAD) | cut -d/ -f2)

^{यदि आपके पास कई उपाय हैं, तो केवल फ़िल्टर करने grep origin |से पहले जोड़ें ।cutorigin}

यदि उपरोक्त आदेश विफल रहता है, तो पहले विलय की गई दूरस्थ-ट्रैकिंग शाखाओं को हटाने का प्रयास करें:

git branch -rd $(git branch -r --merged | grep -vw $(git rev-parse --abbrev-ref HEAD))

फिर git fetchरिमोट और फिर से पिछले git push -vdकमांड का उपयोग करें।

यदि आप अक्सर इसका उपयोग कर रहे हैं, तो अपनी ~/.gitconfigफ़ाइल में उपनाम जोड़ने पर विचार करें ।

यदि आपने गलती से कुछ शाखाओं को हटा दिया है, git reflogतो खोए हुए कमिट को खोजने के लिए उपयोग करें।

Answer 23

इन कुछ जवाबों के आधार पर मैंने इसे करने के लिए अपनी बैश स्क्रिप्ट बनाई !

यह उन शाखाओं को हटाने git branch --mergedऔर git branch -dहटाने के लिए उपयोग करता है जिन्हें विलय कर दिया गया है और हटाने से पहले आपको प्रत्येक शाखा के लिए संकेत देता है।

merged_branches(){
  local current_branch=$(git rev-parse --abbrev-ref HEAD)
  for branch in $(git branch --merged | cut -c3-)
    do
      echo "Branch $branch is already merged into $current_branch."
      echo "Would you like to delete it? [Y]es/[N]o "
      read REPLY
      if [[ $REPLY =~ ^[Yy] ]]; then
        git branch -d $branch
      fi
  done
}

Answer 24

नीचे क्वेरी मेरे लिए काम करती है

for branch in  `git branch -r --merged | grep -v '\*\|master\|develop'|awk 'NR > 0 {print$1}'|awk '{gsub(/origin\//, "")}1'`;do git push origin --delete $branch; done

और यह किसी भी शाखा को grep पाइप में फ़िल्टर करेगा।

Http क्लोन पर अच्छी तरह से काम करता है, लेकिन ssh कनेक्शन के लिए इतना अच्छा नहीं है।

Answer 25

2018.07 तक

इसे [alias]अपने अनुभाग में जोड़ें ~/.gitconfig:

sweep = !"f() { git branch --merged | egrep -v \"(^\\*|master|dev)\" || true | xargs git branch -d; }; f"

अब आप केवल git sweepउस क्लीनअप को करने के लिए कॉल कर सकते हैं ।

Comments

मेरे लिए, कॉल स्वीप स्वीप केवल उन शाखाओं को सूचीबद्ध करता है जिन्हें साफ किया जाना चाहिए, लेकिन यह उन्हें दूर नहीं करता है

— विक्टर मोराज़

Answer 26

Windows पर git bash इंस्टॉल किया हुआ egrep -v काम नहीं करेगा

git branch --merged | grep -E -v "(master|test|dev)" | xargs git branch -d

कहाँ grep -E -vके बराबर हैegrep -v

-dपहले से ही मर्ज की गई शाखाओं -Dको हटाने या अनमैरिड शाखाओं को हटाने के लिए उपयोग करें

Comments

egrep -v मेरे लिए काम करता है। मैं gitextensions इंस्टॉलर से gitbash का उपयोग कर रहा हूं, हालांकि

— जो फिलिप्स

Answer 27

मैं एक cmd में मर्ज किए गए स्थानीय और दूरस्थ शाखाओं को निकालने के लिए निम्न विधि का उपयोग कर रहा हूं ।

मेरी bashrcफाइल में निम्नलिखित है :

function rmb {
  current_branch=$(git branch --no-color 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/\1/')
  if [ "$current_branch" != "master" ]; then
    echo "WARNING: You are on branch $current_branch, NOT master."
  fi
  echo "Fetching merged branches..."
  git remote prune origin
  remote_branches=$(git branch -r --merged | grep -v '/master$' | grep -v "/$current_branch$")
  local_branches=$(git branch --merged | grep -v 'master$' | grep -v "$current_branch$")
  if [ -z "$remote_branches" ] && [ -z "$local_branches" ]; then
    echo "No existing branches have been merged into $current_branch."
  else
    echo "This will remove the following branches:"
    if [ -n "$remote_branches" ]; then
      echo "$remote_branches"
    fi
    if [ -n "$local_branches" ]; then
      echo "$local_branches"
    fi
    read -p "Continue? (y/n): " -n 1 choice
    echo
    if [ "$choice" == "y" ] || [ "$choice" == "Y" ]; then
      # Remove remote branches
      git push origin `git branch -r --merged | grep -v '/master$' | grep -v "/$current_branch$" | sed 's/origin\//:/g' | tr -d '\n'`
      # Remove local branches
      git branch -d `git branch --merged | grep -v 'master$' | grep -v "$current_branch$" | sed 's/origin\///g' | tr -d '\n'`
    else
      echo "No branches removed."
    fi
  fi
}

मूल स्रोत

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

Answer 28

एक स्क्रिप्ट लिखें जिसमें Git उन सभी शाखाओं की जाँच करता है जिन्हें मास्टर में विलय कर दिया गया है।

फिर करते हैं git checkout master।

अंत में, विलय की गई शाखाओं को हटा दें।

for k in $(git branch -ra --merged | egrep -v "(^\*|master)"); do
  branchnew=$(echo $k | sed -e "s/origin\///" | sed -e "s/remotes\///")
  echo branch-name: $branchnew
  git checkout $branchnew
done

git checkout master

for k in $(git branch -ra --merged | egrep -v "(^\*|master)"); do
  branchnew=$(echo $k | sed -e "s/origin\///" | sed -e "s/remotes\///")
  echo branch-name: $branchnew
  git push origin --delete $branchnew
done

Answer 29

स्वीकृत समाधान बहुत अच्छा है, लेकिन एक मुद्दा यह है कि यह स्थानीय शाखाओं को भी हटा देता है जो अभी तक रिमोट में विलय नहीं हुए थे।

अगर आप के आउटपुट को देखें तो आपको कुछ ऐसा दिखाई देगा

$ git branch --merged master -v
  api_doc                  3a05427 [gone] Start of describing the Java API
  bla                      52e080a Update wording.
  branch-1.0               32f1a72 [maven-release-plugin] prepare release 1.0.1
  initial_proposal         6e59fb0 [gone] Original proposal, converted to AsciiDoc.
  issue_248                be2ba3c Skip unit-for-type checking. This needs more work. (#254)
  master                   be2ba3c Skip unit-for-type checking. This needs more work. (#254)

शाखाएँ blaऔर issue_248स्थानीय शाखाएँ हैं जिन्हें चुपचाप हटा दिया जाएगा।

लेकिन आप शब्द भी देख सकते हैं [gone] , जो उन शाखाओं को इंगित करता है, जिन्हें किसी दूरस्थ (जो अब चला गया है) में धकेल दिया गया था और इस प्रकार निरूपित शाखाओं को हटाया जा सकता है।

मूल उत्तर को इस प्रकार बदला जा सकता है (छोटी लाइन की लंबाई के लिए मल्टीलाइन में विभाजित करें)

git branch --merged master -v | \
     grep  "\\[gone\\]" | \
     sed -e 's/^..//' -e 's/\S* .*//' | \
      xargs git branch -d

अभी तक विलय नहीं की गई शाखाओं की सुरक्षा करना। इसके अलावा, इसकी रक्षा के लिए मास्टर के लिए तैयारी की आवश्यकता नहीं है, क्योंकि इसके मूल में एक रिमोट है और यह दिखाई नहीं देता है।

Answer 30

मेरे लिए उन git branch --mergedशाखाओं को नहीं दिखाया गया है जिन्हें GitHub PR के माध्यम से विलय किया गया था। मुझे कारणों पर यकीन नहीं है, लेकिन मैं उन सभी स्थानीय शाखाओं को हटाने के लिए निम्न पंक्ति का उपयोग करता हूं जिनमें दूरस्थ ट्रैकिंग शाखा नहीं है :

diff <(git branch --format "%(refname:short)") <(git branch -r | grep -v HEAD | cut -d/ -f2-) | grep '<' | cut -c 3- | xargs git branch -D

स्पष्टीकरण:

• git branch --format "%(refname:short)" स्थानीय शाखाओं की एक सूची देता है
• git branch -r | grep -v HEAD | cut -d/ -f2- दूरस्थ शाखाओं की एक सूची देता है, फ़िल्टरिंग HEAD
• diff <(...) <(...) कोष्ठक के अंदर दो आदेशों के उत्पादन का एक अंतर देता है
• grep '<' पहली सूची में मौजूद शाखाएं फ़िल्टर करती हैं, लेकिन दूसरी में नहीं
• cut -c 3- 3 वर्ण से शुरू होने वाली लाइन देता है, इस प्रकार उपसर्ग को हटाता है <
• xargs git branch -Dgit branch -Dप्रत्येक शाखा के नाम के विरुद्ध कार्य करता है

वैकल्पिक रूप से, आप grep -v '<'इस तरह से बच सकते हैं :

diff --old-line-format="%L" --new-line-format="" --unchanged-line-format="" <(git branch --format "%(refname:short)") <(git branch -r | grep -v HEAD | cut -d/ -f2-) | xargs git branch -D