रिमोट पर अब ट्रैकिंग शाखाएं निकालें

Question

क्या उन सभी ट्रैकिंग शाखाओं को हटाने का एक सरल तरीका है जिनके दूरस्थ समकक्ष अब मौजूद नहीं हैं?

उदाहरण:

शाखाएँ (स्थानीय और दूरस्थ)

• गुरुजी
• मूल / मास्टर
• मूल / बग ठीक-एक
• मूल / बग ठीक-बी
• मूल / बग ठीक-सी

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

शाखाएँ (स्थानीय और दूरस्थ)

• गुरुजी
• बग फिक्स-एक
• बग ठीक-बी
• मूल / मास्टर
• मूल / बग ठीक-एक
• मूल / बग ठीक-बी
• मूल / बग ठीक-सी

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

तो वर्तमान स्थिति अब है:

शाखाएँ (स्थानीय और दूरस्थ)

• गुरुजी
• बग फिक्स-एक
• बग ठीक-बी
• मूल / मास्टर
• मूल / बग ठीक-सी

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

यह मौजूदा कमांड की तरह कुछ होगा git remote prune origin, लेकिन अधिक पसंद है git local prune origin।

Answer 1

git remote prune origin रिमोट पर नहीं शाखाओं पर नज़र रखने वाली धुन।

git branch --merged उन शाखाओं को सूचीबद्ध करता है जिन्हें वर्तमान शाखा में मिला दिया गया है।

xargs git branch -d मानक इनपुट पर सूचीबद्ध शाखाओं को हटाता है।

द्वारा सूचीबद्ध शाखाओं को हटाने से सावधान रहें git branch --merged। सूची में वे masterअन्य शाखाएँ शामिल हो सकती हैं जिन्हें आप हटाना नहीं चाहते।

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

git branch --merged >/tmp/merged-branches && \
  vi /tmp/merged-branches && xargs git branch -d </tmp/merged-branches

Comments

मर्ज की गई शाखाओं की पहली पंक्ति * masterमेरे सिस्टम पर है। निम्नलिखित कमांड ने मेरे लिए काम किया:git branch -d $(git branch --merged |tail -n +2)

— ट्रेंडफिसचर

अगर मैं developतब git branch --mergedशामिल हूँ master! आप शायद (निश्चित रूप से!) को हटाना नहीं चाहते हैं। इसके अलावा मुझे लगता है कि ऐसा होना चाहिए git branch -dजहां लोअरकेस का -dअर्थ "सुरक्षित डिलीट" है जैसे कि विलीन होने पर ही हटाएं।

— thom_nic

ऐसा लगता है कि वहाँ एक बेहतर समाधान प्रदान किया गया है ।

— सेर्गेई ब्रूनोव

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

— dlsso

मास्टर को बाहर करने के लिए बस grep का उपयोग करें:git branch --merged | grep -v "master" >/tmp/merged-branches && vi /tmp/merged-branches && xargs git branch -d </tmp/merged-branches

— वंशावली

Answer 2

आज्ञा के बाद

git fetch -p

दूरस्थ संदर्भ निकालता है, जब आप चलाते हैं

git branch -vv

यह दूरस्थ स्थिति के रूप में 'गया' दिखाएगा। उदाहरण के लिए,

$ git branch -vv
  master                 b900de9 [origin/master: behind 4] Fixed bug
  release/v3.8           fdd2f4e [origin/release/v3.8: behind 2] Fixed bug
  release/v3.9           0d680d0 [origin/release/v3.9: behind 2] Updated comments
  bug/1234               57379e4 [origin/bug/1234: gone] Fixed bug

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

git fetch -p && for branch in $(git branch -vv | grep ': gone]' | awk '{print $1}'); do git branch -D $branch; done

ध्यान दें कि ऊपर git branchकी ओर स्थिति प्राप्त करने के लिए उपरोक्त "पोर्सिलेन" कमांड का उपयोग करता है ।

इस स्थिति को प्राप्त करने का एक और तरीका है git for-each-ref, प्रक्षेप चर के साथ "प्लंबिंग" कमांड का उपयोग करना%(upstream:track) , जो [gone]ऊपर जैसा होगा ।

यह दृष्टिकोण कुछ हद तक सुरक्षित है, क्योंकि प्रतिबद्ध संदेश के हिस्से पर गलती से मेल खाने का कोई जोखिम नहीं है।

git fetch -p && for branch in $(git for-each-ref --format '%(refname) %(upstream:track)' refs/heads | awk '$2 == "[gone]" {sub("refs/heads/", "", $1); print $1}'); do git branch -D $branch; done

Comments

@KzysztofWende - सोलारिस और कुछ बीएसडी पर नहीं और कुछ OS X :)

— jww

ऐसा लगता है कि यह अंतिम प्रतिबद्ध संदेश में "चली गई" किसी भी शाखा को भी हटा देगा।

— dlsso

@dlsso यदि अंतिम प्रतिबद्ध संदेश में स्ट्रिंग है: "गया]" तो हाँ इसे भी हटा दिया जाएगा। आप कमिटेड मैसेज को अलग करने के लिए एक अतिरिक्त awk / gawk करके सादगी की कीमत पर इसे और मजबूत बना सकते हैं। git branch -vv | gawk '{print $1,$4}' | grep 'gone]' | gawk '{print $1}'

— jason.rickman

मेरी पिछली टिप्पणी (प्रश्न) के उत्तर में, वर्तमान शाखा में पहले क्षेत्र के रूप में * है। अगर ऐसा होता है कि यह "चली गई" शाखाओं की सूची में भी है, तो $ 1 को सौंपा जाएगा * और इसे फ़ाइल नाम और फ़ाइल नामों के साथ स्पेक आउट के साथ एक फाइलस्पेस के रूप में समझा जाएगा। मैंने grep एक्सप्रेशन को खत्म कर दिया था और सभी फ़िल्टरिंग को जागृत कर दिया था awk '/: gone]/{if ($1!="*") print $1}'। यह अब उम्मीद के मुताबिक काम करता है।

— रबेन

@ahmedbhs के बाद से कमांड एकल उद्धरण का उपयोग करता है 'आपको पूरे आदेश को घेरने के लिए "दोहरे उद्धरण का उपयोग करने की आवश्यकता है"। इसके अलावा, गिट अलायस जो शेल कमांड हैं (जैसे कि एक) की आवश्यकता है! शुरुआत में। यह मेरे लिए काम करता है:test = "!git fetch -p && for branch in `git branch -vv | grep ': gone]' | awk '{print $1}'`; do git branch -D $branch; done"

— jason.rickman

Answer 3

इनमें से अधिकांश उत्तर वास्तव में मूल प्रश्न का उत्तर नहीं देते हैं। मैंने खुदाई का एक गुच्छा किया और यह मुझे मिला सबसे साफ समाधान था। यहाँ उस उत्तर का थोड़ा और गहन संस्करण है:

1. अपनी डिफ़ॉल्ट शाखा देखें। आमतौर परgit checkout master
2. Daud git fetch -p && git branch -vv | awk '/: gone]/{print $1}' | xargs git branch -d

स्पष्टीकरण:

अपनी ट्रैकिंग शाखाओं की छंटनी करके काम करता है फिर स्थानीय लोगों को हटा देता है जो दिखाते हैं कि वे "चले गए" हैं git branch -vv।

टिप्पणियाँ:

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

Comments

फ्रेंच ओएस के लिए असमानता से बदलना होगा

— मोहम्मद ईएल हैबीब

अंग्रेजी को लागू करने के लिए git शाखा से पहले LANG = en_US जोड़ना चाहिए: git fetch --prune && LANG = en_US git branch -vv | awk '/: चला गया] / {प्रिंट $ 1}' | xargs git ब्रांच -d

— मोहम्मद ईएल HABIB

मैं git checkout master && ...कमांड की शुरुआत में जोड़ना चाहता हूँ ।

— इरावॉयो

यह खतरनाक है जब आप उस शाखा पर होते हैं जिसे हटाया जाना चाहिए - उस स्थिति में पहला स्तंभ '*' है, जिसे बाद में xggs में भेज दिया जाता है। इसे सुधारने के लिए, आउटपुट को पास करने से पहले स्ट्रिप '*' अक्षर को जोड़ें: sed -e 's / ^ * //'

— meeee

सावधान! एक किनारे का मामला है जो आपके सभी स्थानीय शाखाओं को हटाने का परिणाम देगा: यदि आप वर्तमान में एक शाखा पर हैं जो रिमोट पर हटा दिया गया था तो git branch -vvएक तारांकन के साथ शुरू होगा जो निष्पादन में अंतिम परिणाम होगा git branch -d *। यहाँ एक पैच संस्करण है जो तारांकन के साथ लाइनों को अनदेखा करेगा:git branch -vv | grep ': gone]'| grep -v "\*" | awk '{ print $1; }' | xargs -r git branch -d

— kcm

Answer 4

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

यदि "सरल" का अर्थ है उन सभी को एक बार में हटाना, न कि नाजुक, खतरनाक नहीं है, और उन उपकरणों पर निर्भरता के बिना, जो सभी पाठकों के पास नहीं होंगे, तो सही उत्तर है: नहीं।

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

आगे की पढाई:

• आपको git branchस्क्रिप्ट में आउटपुट पार्स क्यों नहीं करना चाहिए ।
• ट्रैकिंग शाखाओं और के बीच मतभेद git remote prune, git prune,git fetch --prune

---

यदि आप इसे सुरक्षित रूप से करना चाहते हैं, तो प्रश्न में उपयोग के मामले के लिए (कचरा इकट्ठा करने वाली ट्रैकिंग शाखाएं जो सर्वर पर हटा दी गई हैं, लेकिन अभी भी स्थानीय शाखाओं के रूप में मौजूद हैं) और केवल उच्च-स्तरीय गिट कमांड के साथ, आपके पास है

• git fetch --prune(या git fetch -p, जो कि एक उपनाम है, या git prune remote originजो बिना बात के काम करता है, और शायद वह नहीं है जो आप ज्यादातर समय चाहते हैं)।
• किसी भी दूरस्थ शाखाओं को नोट करें जिन्हें हटा दिया गया है। या, बाद में उन्हें खोजने के लिए, git branch -v(किसी भी अनाथ ट्रैकिंग शाखा को "[गया]") चिह्नित किया जाएगा।
• git branch -d [branch_name] प्रत्येक अनाथ ट्रैकिंग शाखा पर

(जो कि कुछ अन्य उत्तरों का प्रस्ताव है)।

यदि आप किसी समाधान को स्क्रिप्ट करना चाहते हैं, तो for-each-refआपका शुरुआती बिंदु है, जैसा कि यहां मार्क लोंगेयर के उत्तर में है और यह एक अन्य प्रश्न का उत्तर है , लेकिन मुझे शेल स्क्रिप्ट लूप लिखने, या xargs या कुछ का उपयोग किए बिना इसका फायदा उठाने का कोई तरीका नहीं दिख रहा है ।

---

पृष्ठभूमि की व्याख्या

यह समझने के लिए कि क्या हो रहा है, आपको इसकी सराहना करने की आवश्यकता है, ट्रैकिंग शाखाओं की स्थिति में, आपके पास एक शाखा नहीं है, लेकिन तीन हैं। (और याद रखें कि "शाखा" का मतलब केवल एक संकेतक के लिए प्रतिबद्ध है।)

ट्रैकिंग शाखा को देखते हुए feature/X, दूरस्थ रिपॉजिटरी (सर्वर) में यह शाखा होगी और इसे कॉल करें feature/X। आपकी स्थानीय रिपॉजिटरी की एक शाखा remotes/origin/feature/Xहै, जिसका अर्थ है, "यह वही है जो रिमोट ने मुझे इसकी विशेषता बताई है / एक्स शाखा थी, पिछली बार जब हमने बात की थी," और अंत में, स्थानीय रिपॉजिटरी की एक शाखा है feature/Xजो आपकी नवीनतम प्रतिबद्ध की ओर इशारा करती है, और इसे कॉन्फ़िगर किया गया है "ट्रैक" remotes/origin/feature/X, जिसका अर्थ है कि आप उन्हें संरेखित रखने के लिए खींच सकते हैं और धक्का दे सकते हैं।

किसी बिंदु पर, किसी ने feature/Xरिमोट पर हटा दिया है । उस क्षण से, आपको अपने स्थानीय के साथ छोड़ दिया जाता है feature/X(जिसे आप शायद अधिक नहीं चाहते हैं, क्योंकि सुविधा एक्स पर काम संभवतया समाप्त हो गया है), और आपका remotes/origin/feature/Xजो निश्चित रूप से बेकार है क्योंकि इसका एकमात्र उद्देश्य सर्वर की शाखा की स्थिति को याद रखना था। ।

और Git आपको स्वचालित रूप से निरर्थक को साफ करने देगा remotes/origin/feature/X- जो कि git fetch --pruneकरता है - लेकिन किसी कारण से, यह आपको स्वचालित रूप से अपना स्वयं को हटाने नहीं देता है feature/X... भले ही आपके feature/Xअभी भी अनाथ ट्रैकिंग जानकारी हो, इसलिए इसकी जानकारी है पूर्व ट्रैकिंग शाखाओं की पहचान करना जो पूरी तरह से विलय कर दी गई हैं। (आखिरकार, यह आपको वह जानकारी दे सकता है जो आपको ऑपरेशन को स्वयं करने की अनुमति देता है।)

Comments

यह ज्यादा सुरक्षित जवाब है। इसके अलावा, यह काम करेगा यदि आप चयनित उत्तर के विपरीत "स्क्वैश और मर्ज" वर्कफ़्लो का उपयोग करते हैं।

— जेक लेविट

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

— वू

@Voo जवाब का बिंदु है: आपको यह बताने के लिए नहीं कि यह कैसे करना है (यह सिर्फ एक बोनस है) लेकिन आपको बता दें कि इसका उत्तर यह है कि इसे करने का कोई आसान, सरल तरीका नहीं है। यह प्रश्न का सही उत्तर है क्योंकि इसे तैयार किया गया था।

— एंड्रयू स्पेंसर

"यदि आप इसे सुरक्षित रूप से करना चाहते हैं, तो प्रश्न में उपयोग के मामले के लिए .." - जो पहले पैराग्राफ के अधिकांश दावों की उपेक्षा करता है। "[गिट] आपको वह जानकारी दे सकता है जो आपको ऑपरेशन को स्वयं करने की अनुमति देता है" - हम प्रोग्रामर हैं, इसलिए एक सूची के रूप में जानकारी दी गई है (जो दिखाया गया है) कार्य अभी भी सरल है (जैसे। xargs)। कई git aliasमामलों को सरल बनाने के लिए भी है।

— user2864740

@ user2864740 कुछ पाठक इस बात पर विचार कर सकते हैं कि एक छोटा सा बैश स्क्रिप्ट लिखना "सरल" की परिभाषा के भीतर आता है, और यह एक पूरी तरह से रक्षात्मक स्थिति है, लेकिन मैंने दूसरे पैराग्राफ में "सरल" की अपनी व्याख्या दी और शेष उत्तर सुसंगत है। इसके साथ। और मेरी स्वीकारोक्तिपूर्ण प्रतिबंधात्मक व्याख्या के बचाव में, सभी Git उपयोगकर्ताओं के पास xargsया बैश नहीं है, और वे शायद यहां माइक्रो-कोडिंग चुनौती की तलाश में नहीं हैं, इसलिए एक त्वरित उत्तर के रूप में वे अपने वास्तविक लक्ष्य से खुद को विचलित किए बिना सुरक्षित रूप से आवेदन कर सकते हैं। ।

— एंड्रयू स्पेंसर

Answer 5

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

git branch --merged | grep -v "\*" | xargs -n 1 git branch -d

सुनिश्चित करें कि हम मास्टर रहते हैं

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

git branch --merged | grep -v "\*" | grep -v "YOUR_BRANCH_TO_KEEP" | xargs -n 1 git branch -d

इसलिए अगर हम रखना चाहते थे master, developऔर stagingउदाहरण के लिए, हम जाएंगे:

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

इसे एक उपनाम बनाएं

चूंकि यह थोड़ा लंबा है, आप अपने .zshrcया किसी अन्य को जोड़ना चाह सकते हैं .bashrc। मेरा कहा जाता है gbpurge(के लिए git branches purge):

alias gbpurge='git branch --merged | grep -v "\*" | grep -v "master" | grep -v "develop" | grep -v "staging" | xargs -n 1 git branch -d'

फिर अपने .bashrcया फिर से लोड करें .zshrc:

. ~/.bashrc

या

. ~/.zshrc

Comments

उपयोगी है, लेकिन "रिमोट पर नहीं शाखाओं को हटा दें" के समान नहीं है

— dlsso

Greate जवाब @karlingen, मेरे पास मेरे सभी देव परिवेशों में स्थायी रूप से gbpurge के रूप में है

— पीटर डोलन

Answer 6

विंडोज समाधान

Microsoft Windows पॉवर्सशेल के लिए:

git checkout master; git remote update origin --prune; git branch -vv | Select-String -Pattern ": gone]" | % { $_.toString().Trim().Split(" ")[0]} | % {git branch -d $_}

explaination

git checkout master मास्टर शाखा में स्विच

git remote update origin --prune सुदूर शाखाओं को prunes

git branch -vvसभी शाखाओं का एक वर्बोज़ आउटपुट प्राप्त होता है ( गिट संदर्भ )

Select-String -Pattern ": gone]" केवल उन अभिलेखों को प्राप्त करता है जहां उन्हें रिमोट से हटा दिया गया है।

% { $_.toString().Trim().Split(" ")[0]} शाखा का नाम प्राप्त करें

% {git branch -d $_} शाखा को हटा देता है

Comments

इसके लिए धन्यवाद, हालांकि मुझे शाखा नाम से पहले दो रिक्त स्थान निकालने के लिए एक के .Trim()बाद एक जोड़ना था .toString()।

— मैथ्यू

इस कमांड के लिए धन्यवाद। मैं बदलना पड़ा git branch -dकरने के लिए git branch -Dकिसी और मैं त्रुटि शाखा पूरी तरह से विलय नहीं किया जाता हो।

— मार्की

@markieo आप शायद पहले से ही इस पता है, लेकिन किसी और के लिए - git branch -Dहै विनाशकारी और स्थानीय काम है कि आप अभी तक पुश नहीं किया है को नष्ट करेगा। -dहमेशा सुरक्षित रहता है, बस सावधानी बरतें -D।

— नैट बारबेटिनी

Answer 7

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

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

git branch --list --format "%(if:equals=[gone])%(upstream:track)%(then)%(refname:short)%(end)" | 
    ? { $_ -ne "" } | 
    % { git branch -D $_ }

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

Comments

--formatविकल्प काफी नई प्रतीत हो रहा है; मुझे इसे प्राप्त करने के लिए git को 2.10.something से 2.16.3 पर अपग्रेड करने की आवश्यकता थी। यह Linux-ish सिस्टम के लिए मेरा संशोधन है:git branch --list --format "%(if:equals=[gone])%(upstream:track)%(then)%(refname)%(end)" | sed 's,^refs/heads/,,' | grep . | xargs git branch -D

— bxm

यह अब तक का सबसे अच्छा समाधान है। एक सुझाव का उपयोग करना है refname:short। फिर आप % { $_ -replace '^refs/heads/', '' }

— ioudas

यह विंडोज़ के लिए एक महान समाधान है। मैं इसे इस तरह उपयोग कर रहा हूं क्योंकि यह अधिक पठनीय है। git branch --list --format "%(if:equals=[gone])%(upstream:track)%(then)%(refname:short)%(end)" | where { $_ -ne "" } | foreach { git branch -d $_ }इसके -dबजाय उपयोग करने के लिए शायद एक अच्छा विचार है -D। फोर्स डिलीट उन शाखाओं के लिए जरूरी नहीं होनी चाहिए जो अब रिमोट पर नहीं हैं।

— रुबानोव

Answer 8

उन सभी शाखाओं को निकालें जिन्हें गुरु में मिला दिया गया है, लेकिन स्वयं को निकालने का प्रयास न करें:

git checkout master && git pull origin master && git fetch -p && git branch -d $(git branch --merged | grep master -v)

या एक उपनाम जोड़ें:

alias gitcleanlocal="git checkout master && git pull origin master && git fetch -p && git branch -d $(git branch --merged | grep master -v)"

स्पष्टीकरण:

git checkout master चेकआउट मास्टर शाखा

git pull origin master सुनिश्चित करें कि स्थानीय शाखा में सभी दूरस्थ परिवर्तन मर्ज किए गए हैं

git fetch -p हटाए गए दूरस्थ शाखाओं के संदर्भ निकालें

git branch -d $(git branch master --merged | grep master -v) उन सभी शाखाओं को हटा दें जिन्हें गुरु में मिला दिया गया है, लेकिन स्वयं को निकालने का प्रयास न करें

Comments

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

— ज़ीफिरिन

बस स्पष्ट करने के लिए, Zefiryn -D विकल्प का उपयोग करने की बात कर रहा है जो वन-लाइनर का हिस्सा नहीं है।

— CS01

या निचले हिस्से का उपयोग करें, git branch -dजिसे धक्का न देने वाली शाखाओं के बारे में चेतावनी जारी करनी चाहिए।

— acme

Answer 9

git fetch -p

यह होगा काटना किसी भी शाखाओं कि अब कोई रिमोट पर मौजूद हैं।

Comments

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

— उस नौसैनिक

क्या? यह मेरे लिए स्थानीय शाखाओं को हटा देता है।

— एलेक्स हॉल

@AlexHall दूरस्थ रिपॉजिटरी की एक शाखा है X; आप git checkout X; अब आपकी रिपॉजिटरी में एक स्थानीय (स्थानीय) ट्रैकिंग शाखा Xऔर एक दूरस्थ शाखा है origin/X; दूरस्थ रिपॉजिटरी हटाता है X; आप git fetch-p; अपने स्थानीय भंडार में, न केवल origin/Xलेकिन यह भी Xहटा दिया गया है। क्या आप यही कह रहे हैं?

— एंड्रयू स्पेंसर

Answer 10

ढेर के लिए एक और जवाब, पैट्रिक के जवाब से भारी ड्राइंग (जो मुझे पसंद है क्योंकि यह किसी अस्पष्टता के साथ दूर करने के बारे gone]में लगता है कि git branchआउटपुट में कहां मेल खाएगा ) लेकिन एक * निक्स बेंट जोड़कर।

अपने सरलतम रूप में:

git branch --list --format \
  "%(if:equals=[gone])%(upstream:track)%(then)%(refname:short)%(end)" \
  | xargs git branch -D

मैंने इसे git-goneअपने पथ पर एक स्क्रिप्ट में लपेटा है:

#!/usr/bin/env bash

action() {
  ${DELETE} && xargs git branch -D || cat
}

get_gone() {
  git branch --list --format \
    "%(if:equals=[gone])%(upstream:track)%(then)%(refname:short)%(end)"
}

main() {
  DELETE=false
  while [ $# -gt 0 ] ; do
    case "${1}" in
      (-[dD] | --delete) DELETE=true ;;
    esac
    shift
  done
  get_gone | action
}

main "${@}"

एनबी - --formatविकल्प काफी नया प्रतीत होता है; मुझे इसे प्राप्त करने के लिए git को 2.10.something से 2.16.3 पर अपग्रेड करने की आवश्यकता थी।

संपादित करें: के बारे में सुझाव शामिल करने के लिए बदलाव refname:shortसे बेंजामिन डब्ल्यू

NB2 - मैंने केवल bashहैशबंग में परीक्षण किया है , लेकिन शायद पोर्टेबल है sh।

Comments

क्या आप पहली पंक्ति में sedउपयोग करके भाग को छोड़ नहीं सकते हैं %(refname:short)?

— बेंजामिन डब्ल्यू

मेरे लिए काम करने लगता है, और मेरे पास अब एक साफ गीट उर्फ ​​के रूप में है - यहां उन सभी का सबसे साफ समाधान!

— बेंजामिन डब्ल्यू

2.13 पेश किया --format। sedभाग को छोड़ने का दूसरा तरीका उपयोग करना है git update-ref -d। ध्यान दें कि यह शायद कुछ असुरक्षित है, का उपयोग git for-each-refकरना यहां सुरक्षित है (दिया गया है --shell)।

— gsnedders

शानदार उत्तर, और इसने मुझे अपने प्रश्नों का उत्तर देने में मदद की जब मैं स्वयं --formatऐसा करने के लिए लड़खड़ा रहा था । बस एक सवाल: क्यों #!bash? यहां सब कुछ shमुझे पोर्टेबल लगता है।

— टॉबी स्पाइट

यह सिर्फ मेरा सामान्य बॉयलरप्लेट है, और कहीं और परीक्षण नहीं किया था।

— bxm

Answer 11

मास्टर और विकास को छोड़कर सभी स्थानीय शाखाओं को खाली करने के लिए कुछ, सरल एक पंक्ति के लिए उपयोगी हो सकता है

git branch | grep -v "master" | grep -v "develop" | xargs git branch -D

Comments

बहुत बढ़िया जवाब! मुझे पसंद है कि कैसे 'git branch | grep -v "master" | grep -v "develop"कमांड के विलोपन भाग पर जोड़ने के लिए प्रतिबद्ध होने से पहले कोई भी आसानी से सामान के साथ खेल सकता है । Can

— फिनेनीचेल्प

लेकिन यह ऊपर दिए गए सवाल का जवाब नहीं देता है। इससे शाखाएँ नष्ट हो जाएंगी भले ही रिमोट अभी भी है।

— जिम

Answer 12

यह स्थानीय मास्टर संदर्भ और वर्तमान में उपयोग किए जा रहे को छोड़कर सभी विलीन स्थानीय शाखाओं को हटा देगा:

git branch --merged | grep -v "*" | grep -v "master" | xargs git branch -d

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

git remote prune origin

Comments

git branch -vv | grep 'gone]' | grep -v "\*" | awk '{print $1}' | xargs -r git branch -d स्पष्टीकरण: मैं स्थिति को दिखाने के लिए git branch --mergedद्वारा प्रतिस्थापित करना पसंद करता हूं git branch -vv(गया) क्योंकि पिछला git branch --mergedभी मास्टर दिखा सकता है

— jpmottin

Answer 13

मुझे नहीं लगता कि ऐसा करने के लिए कोई अंतर्निहित कमांड है, लेकिन यह निम्न करने के लिए सुरक्षित है:

git checkout master
git branch -d bug-fix-a

जब आप उपयोग करते हैं -d, तो git शाखा को हटाने से इंकार कर देगा जब तक कि यह पूरी तरह से HEADया इसके अपस्ट्रीम रिमोट-ट्रैकिंग शाखा में विलय न हो जाए । इसलिए, आप हमेशा के उत्पादन पर लूप कर सकते हैं git for-each-refऔर प्रत्येक शाखा को हटाने का प्रयास कर सकते हैं। उस दृष्टिकोण के साथ समस्या यह है कि मुझे संदेह है कि आप शायद bug-fix-dकेवल इसलिए नहीं हटाना चाहते क्योंकि origin/bug-fix-dइसमें अपना इतिहास समाहित है। इसके बजाय, आप निम्नलिखित की तरह एक स्क्रिप्ट बना सकते हैं:

#!/bin/sh

git checkout master &&
for r in $(git for-each-ref refs/heads --format='%(refname:short)')
do
  if [ x$(git merge-base master "$r") = x$(git rev-parse --verify "$r") ]
  then
    if [ "$r" != "master" ]
    then
      git branch -d "$r"
    fi
  fi
done

चेतावनी: मैंने इस स्क्रिप्ट का परीक्षण नहीं किया है - केवल देखभाल के साथ उपयोग करें ...

Comments

मैंने स्क्रिप्ट को संपादित करने के लिए स्वतंत्रता ली। अभी भी कोई गारंटी नहीं देगा, लेकिन, यह चलता है और अब काम करने लगता है।

— fwielstra

Answer 14

टी एल; डॉ:

सभी स्थानीय शाखाएँ निकालें जो दूरस्थ पर नहीं हैं

git fetch -p && git branch -vv | grep ': gone]' | awk '{print $1}' | xargs git branch -D

उन सभी स्थानीय शाखाओं को निकालें जो रिमोट पर नहीं हैं और जो पूरी तरह से मर्ज की गई हैं और जिनका उपयोग पहले कई उत्तरों में कहा गया है।

git fetch -p && git branch --merged | grep -v '*' | grep -v 'master' | xargs git branch -d

व्याख्या

• git fetch -p सभी शाखाओं को दूर-दूर तक मौजूद नहीं करेगा
• git branch -vv स्थानीय शाखाओं को प्रिंट करेगा और छंटनी की गई शाखा के साथ टैग किया जाएगा gone
• grep ': gone]' केवल उस शाखा का चयन करता है जो चले गए हैं
• awk '{print $1}' केवल शाखाओं के नाम को प्रदर्शित करने के लिए आउटपुट को फ़िल्टर करें
• xargs git branch -D सभी लाइनों (शाखाओं) पर लूप करेगा और बल को इस शाखा को हटा देगा

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

error: The branch 'xxx' is not fully merged.

Comments

क्या आप मास्टर के बजाय रिमोट कहना चाहते थे?

— टीनो

Answer 15

आप ऐसा कर सकते हैं:

git branch -vv | grep 'origin/.*: gone]' | awk '{print $1}' | xargs git branch -d

Answer 16

उपरोक्त जानकारी के आधार पर, इसने मेरे लिए काम किया:

git br -d `git br -vv | grep ': gone] ' | awk '{print $1}' | xargs`

यह सभी स्थानीय शाखाओं को हटा देता है ': gone] 'जो रिमोट पर हैं ।

Comments

ऐसा लगता है कि यह अंतिम प्रतिबद्ध संदेश में "चली गई" किसी भी शाखा को भी हटा देगा।

— dlsso

यह किसी भी शाखा को हटा देगा goneजो उसके नाम पर कहीं भी हो।

— bfontaine

"git branch -D git branch -vv | grep ': चला गया]' | awk '{print 1}' | xargs`" इसने मेरे लिए काम किया।

— मुथु गणपति नाथन

Answer 17

grep gone <(git branch -v) | cut -d ' ' -f 3 | xargs git branch -d

उपरोक्त कमांड का उपयोग उन शाखाओं को प्राप्त करने के लिए किया जा सकता है जो सुदूर में विलय और नष्ट हो जाती हैं और यह स्थानीय शाखा को हटा देती है जो अब दूरस्थ में उपलब्ध नहीं है

Comments

अब तक का सर्वश्रेष्ठ समाधान, हालांकि मैंने इसे सभी grep gone <(git branch -v) | cut -d ' ' -f 3 | xargs git branch -Dको हटाने के लिए बदल दिया है

— शोएब

खतरनाक है अगर आपकी किसी शाखा के नाम goneमें कहीं भी सबस्ट्रिंग शामिल है (जैसे usingonefunction)।

— टोबे स्पाइट

Answer 18

इनमें से कोई भी मेरे लिए वास्तव में सही नहीं था। मुझे कुछ ऐसा चाहिए था, जो एक दूरस्थ शाखा पर नज़र रखने वाली सभी स्थानीय शाखाओं को शुद्ध कर दे origin, जहाँ पर दूरस्थ शाखा को हटा दिया गया है ( gone)। मैं उन स्थानीय शाखाओं को हटाना नहीं चाहता था जो कभी भी एक दूरस्थ शाखा (यानी: मेरी स्थानीय देव शाखाओं) को ट्रैक करने के लिए सेट नहीं की गई थीं। इसके अलावा, मैं एक साधारण लाइनर चाहता था जो सिर्फ gitकस्टम स्क्रिप्ट लिखने के बजाय, या अन्य सरल सीएलआई टूल का उपयोग करता है । मैंने थोड़ा सा उपयोग करके grepऔर awkइस साधारण कमांड को बनाने के लिए समाप्त किया ।

यह अंततः है क्या मेरे में समाप्त हो गया ~/.gitconfig:

[alias]
  prune-branches = !git remote prune origin && git branch -vv | grep ': gone]' | awk '{print $1}' | xargs -r git branch -D

यहाँ इसे git config --global ...आसानी से जोड़ने के लिए एक आदेश दिया गया है git prune-branches:

git config --global alias.prune-branches '!git remote prune origin && git branch -vv | grep '"'"': gone]'"'"' | awk '"'"'{print $1}'"'"' | xargs -r git branch -d'

नोट: कॉन्फ़िगरेशन कमांड में, मैं -dविकल्प का उपयोग करने के git branchबजाय -D, जैसा कि मैं अपने वास्तविक कॉन्फ़िगरेशन में करता हूं। मैं उपयोग करता हूं -Dक्योंकि मैं नहीं सुनता चाहता हूं कि अनमैरिड शाखाओं के बारे में शिकायत करें। आप इस कार्यक्षमता को भी चाह सकते हैं। यदि हां, तो बस का उपयोग -Dकरने के बजाय -dकि config आदेश के अंत में।

Comments

मुझे गिट उर्फ ​​एप्रोच पसंद है। क्विक git branch -vvक्वेश्चन : क्यों और किसके लिए कर रहे हैं : gone]और नहीं कर git branch -vरहे हैं [gone]?

— लालबी

@ लालबी, अच्छा सवाल। मुझे याद नहीं है। मुझे संदेह है कि कुछ केवल एक के साथ नहीं दिखा रहा था v। यदि git branch -v | grep '[gone]'आपके लिए काम करता है, तो इसके लिए जाएं। यह थोड़ा साफ लगता है।

— कार्ल विल्बर

Answer 19

Git Tip के आधार पर : पुराने स्थानीय शाखाओं को हटाना , जो jason.rickman के समाधान के समान दिखता है, मैंने इस उद्देश्य के लिए एक कस्टम कमांड लागू किया है जिसे gash बैश का उपयोग करके चला गया है :

$ git gone
usage: git gone [-pndD] [<branch>=origin]
OPTIONS
  -p  prune remote branch
  -n  dry run: list the gone branches
  -d  delete the gone branches
  -D  delete the gone branches forcefully

EXAMPLES
git gone -pn    prune and dry run
git gone -d     delete the gone branches

git gone -pn "गई" शाखाओं को छंटाई और सूचीबद्ध करने के लिए जोड़ती है:

$ git gone -pn
  bport/fix-server-broadcast         b472d5d2b [origin/bport/fix-server-broadcast: gone] Bump modules
  fport/rangepos                     45c857d15 [origin/fport/rangepos: gone] Bump modules

तब आप ट्रिगर का उपयोग करके खींच सकते हैं git gone -dया git gone -D।

टिप्पणियाँ

• मेरे द्वारा उपयोग की जाने वाली नियमित अभिव्यक्ति वह "$BRANCH/.*: gone]"जगह है जहाँ $BRANCHसामान्य रूप से होगी origin। यह संभवत: तब काम नहीं करेगा जब आपका Git आउटपुट फ्रेंच आदि के लिए स्थानीय हो।
• सेबस्टियन विस्नर ने इसे विंडोज उपयोगकर्ताओं के लिए रस्ट में भी पोर्ट किया। यही कारण है कि एक भी कहा जाता है Git चला गया है ।

Comments

यह संभवतः स्वीकृत उत्तर होना चाहिए - के git goneलिए एक उपनाम की तरह दिखता है git branch -vv | grep 'origin/.*: gone]' | awk '{print $1}' | xargs git branch -d, जो ओपी के मुद्दे को हल करता है।

— एलेक्स

Answer 20

एक से भारी आकर्षित नंबर की अन्य जवाब यहाँ, मैं निम्नलिखित के साथ समाप्त हो गया है (Git 2.13 और इसके बाद के संस्करण केवल, मेरा मानना है) है, जो किसी भी पर काम करना चाहिए यूनिक्स-जैसा शेल:

git for-each-ref --shell --format='ref=%(if:equals=[gone])%(upstream:track)%(then)%(refname)%(end)' refs/heads | while read entry; do eval "$entry"; [ ! -z "$ref" ] && git update-ref -d "$ref" && echo "deleted $ref"; done

इसके for-each-refबजाय यह उल्लेखनीय रूप से उपयोग करता है branch(जैसा branchकि "पोर्सिलेन" कमांड मानव-पठनीय आउटपुट के लिए डिज़ाइन किया गया है, मशीन-प्रोसेसिंग नहीं) और --shellठीक से बच निकलने वाले आउटपुट प्राप्त करने के लिए अपने तर्क का उपयोग करता है (यह हमें रेफ नाम में किसी भी चरित्र के बारे में चिंता नहीं करने की अनुमति देता है)।

Comments

यह मेरे लिए काम करता है, लेकिन यह भी अच्छा होगा यदि आप समझा सकते हैं कि कमांड में अन्य चरण क्या कर रहे हैं। उदाहरण के लिए मुझे नहीं पता कि [ ! -z "$ref" ]इसका क्या मतलब है। मुझे लगता है कि एक मल्टी लाइनर ने पहले ही मदद कर दी होगी। लेकिन फिर भी आपके इनपुट के लिए धन्यवाद!

— केविनH

Answer 21

फिर भी एक और जवाब, क्योंकि कोई भी समाधान मेरी जरूरतों को लालित्य और क्रॉस-प्लेटफ़ॉर्मेंस पर सूट नहीं करता है:

रिमोट पर नहीं स्थानीय शाखाओं को हटाने का आदेश:

for b in $(git for-each-ref --format='%(if:equals=[gone])%(upstream:track)%(then)%(refname:short)%(end)' refs/heads); do git branch -d $b; done

इसे gitconfig के साथ एकीकृत करने के लिए इसे इसके साथ चलाया जा सकता है git branch-prune:

दे घुमा के

git config --global alias.branch-prune '!git fetch -p && for b in $(git for-each-ref --format='\''%(if:equals=[gone])%(upstream:track)%(then)%(refname:short)%(end)'\'' refs/heads); do git branch -d $b; done'

शक्ति कोशिका

git config --global alias.branch-prune '!git fetch -p && for b in $(git for-each-ref --format=''%(if:equals=[gone])%(upstream:track)%(then)%(refname:short)%(end)'' refs/heads); do git branch -d $b; done'

(PowerShell और bash के लिए एक सार्वभौमिक आदेश खोजने में सहायता की आवश्यकता है)

यह उत्तर सबसे अच्छा क्यों है?

• एक पूर्ण समाधान प्रदान करता है: git branch-pruneआपके git में एक कमांड जोड़ता है
• Windows PowerShell से ठीक काम करता है
• मूल विचार है @ jason.rickman की बुलेटप्रूफ विधि का उपयोग करgit for-each-ref
• पार्सिंग और फ़िल्टरिंग की आवश्यकता होती है, --filterइसलिए किसी बाहरी निर्भरता की आवश्यकता नहीं होती है

स्पष्टीकरण:

• आपके लिए एक नया उपनाम जोड़ता है ~\.gitconfig। इसे निष्पादित करने के बाद आप बस कर सकते हैंgit branch-prune
• इस उपनाम के अंदर:
  • के साथ शाखाएँ प्राप्त करता है --prune झंडा है, जो "आलूबुखारा नहीं रह गया है रिमोट ट्रैकिंग शाखाओं रिमोट पर"
  • शाखाओं की सूची प्राप्त करने के लिए उपयोग git for-each-refऔर --filter, [gone](कोई रिमोट नहीं)
  • इस सूची के माध्यम से लूप्स और शाखा को सुरक्षित रूप से हटाता है

Comments

अनंत को इस समाधान के awesomeness में सुधार के लिए @ jerry-wu , धन्यवाद ।

— हिमुरा

@ jer-wu और git config कमांड का आपका अंतिम संपादन PowerShell में काम नहीं करता है (

— Himura

Answer 22

मैं इस बैश स्क्रिप्ट के साथ आया हूं। यह हमेशा शाखाओं रखना develop, qa, master।

git-clear() {
  git pull -a > /dev/null

  local branches=$(git branch --merged | grep -v 'develop' | grep -v 'master' | grep -v 'qa' | sed 's/^\s*//')
  branches=(${branches//;/ })

  if [ -z $branches ]; then
    echo 'No branches to delete...'
    return;
  fi

  echo $branches

  echo 'Do you want to delete these merged branches? (y/n)'
  read yn
  case $yn in
      [^Yy]* ) return;;
  esac

  echo 'Deleting...'

  git remote prune origin
  echo $branches | xargs git branch -d
  git branch -vv
}

Answer 23

मैं ट्रिक करने के लिए एक छोटी विधि का उपयोग करता हूं, मैं आपको वही करने की सलाह देता हूं क्योंकि यह कुछ घंटे बचा सकता है और आपको अधिक दृश्यता दे सकता है

बस निम्नलिखित स्निपेट को अपने .bashrc (.bashprofile on macos) में जोड़ें।

git-cleaner() { git fetch --all --prune && git branch --merged | grep -v -E "\bmaster|preprod|dmz\b" | xargs -n 1 git branch -d ;};

1. सभी उपाय प्राप्त करें
2. गिट से केवल मर्ज की गई शाखाएँ प्राप्त करें
3. इस सूची से "संरक्षित / महत्वपूर्ण" शाखाओं को हटा दें
4. बाकी (जैसे, साफ और विलय की गई शाखाएं) निकालें

आपको अपनी आवश्यकताओं के अनुसार फिट होने के लिए grep regex को संपादित करना होगा (यहां, यह मास्टर, प्रीप्रोड और डीएमज़ को हटाने से रोकता है)

Comments

git fetch --all --pruneचाल चली। धन्यवाद!

— लीऑन - हान ली

Answer 24

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

git branch -r | awk '{print $1}' | egrep -v -f /dev/fd/0 <(git branch -vv | grep origin) | awk '{print $1}' | xargs git branch -d

Comments

ओह, मैं इस पर डबल पोस्ट किया ... बस यह देखा जब पदों की समीक्षा। लेकिन आप वास्तव में उस व्यक्ति को इंगित कर सकते हैं जिसने इस आदेश को आपके रूप में लेने के बजाय प्रदान किया है!

— द्विज

मुझे लगता है कि यह एक मंच से होशियार होने की कोशिश मत करो बस जवाब दो या इसे नजरअंदाज करो

— फरीद अलन्नरूटी

यहां तक ​​कि आप से भी ... वैसे भी ... यह आपके साथ चर्चा करने के लिए यहां नहीं आया था। जैसा आपने कहा .. मेरी टिप्पणी पर ध्यान दें या इसे अनदेखा करें;)

— द्विज '

Answer 25

मुझे यकीन नहीं है कि कब तक, लेकिन मैं अब git-up का उपयोग करता हूं, जो इसका ख्याल रखता है।

मैं करता हूं git upऔर यह नई शाखाओं को ट्रैक करना शुरू कर देता है और पुराने को हटा देता है।

बस इसे स्पष्ट करने के लिए, यह आउट-ऑफ-द-बॉक्स गिट कमांड नहीं है - https://github.com/aanand/git-up

BTW यह भी गंदे पेड़ को चुराता है और अभी भी बस के साथ विद्रोह करता है git up।

आशा है कि यह किसी के लिए उपयोगी होगा

Comments

यह उन स्थानीय शाखाओं को नहीं हटा रहा है जो सर्वर पर मौजूद नहीं हैं।

— एशले

Answer 26

यहां एक समाधान है जो मैं मछली के खोल के लिए उपयोग करता हूं। पर परीक्षण किया Mac OS X 10.11.5, fish 2.3.0और git 2.8.3।

function git_clean_branches
  set base_branch develop

  # work from our base branch
  git checkout $base_branch

  # remove local tracking branches where the remote branch is gone
  git fetch -p

  # find all local branches that have been merged into the base branch
  # and delete any without a corresponding remote branch
  set local
  for f in (git branch --merged $base_branch | grep -v "\(master\|$base_branch\|\*\)" | awk '/\s*\w*\s*/ {print $1}')
    set local $local $f
  end

  set remote
  for f in (git branch -r | xargs basename)
    set remote $remote $f
  end

  for f in $local
    echo $remote | grep --quiet "\s$f\s"
    if [ $status -gt 0 ]
      git branch -d $f
    end
  end
end

कुछ नोट:

सही सेट करने के लिए सुनिश्चित करें base_branch। इस मामले में मैं developआधार शाखा के रूप में उपयोग करता हूं , लेकिन यह कुछ भी हो सकता है।

यह हिस्सा बहुत महत्वपूर्ण है grep -v "\(master\|$base_branch\|\*\)":। यह सुनिश्चित करता है कि आप मास्टर या अपनी आधार शाखा को नहीं हटाते हैं।

मैं git branch -d <branch>एक अतिरिक्त सावधानी के रूप में उपयोग करता हूं , इसलिए किसी भी शाखा को हटाने के लिए नहीं जो पूरी तरह से अपस्ट्रीम या वर्तमान HEAD के साथ विलय नहीं किया गया है।

परीक्षण करने के लिए एक आसान तरीका के git branch -d $fसाथ बदलना है echo "will delete $f"।

मुझे लगता है मुझे भी जोड़ना चाहिए: अपने खुद के जोखिम पर उपयोग करें!

Answer 27

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

    import git
    import subprocess
    from git.exc import GitCommandError
    import os

    def delete_merged_branches():
        current_dir = input("Enter repository directory:")
        repo = git.Repo(current_dir)
        git_command = git.Git(current_dir)

        # fetch the remote with prune, this will delete the remote references in local.
        for remote in repo.remotes:
            remote.fetch(prune=True)

        local_branches = [branch.name for branch in repo.branches]
        deleted_branches = []

        # deleted_branches are the branches which are deleted on remote but exists on local.
        for branch in local_branches:
            try:
                remote_name = 'origin/'+ branch
                repo.git.checkout(remote_name)
            except GitCommandError:
            # if the remote reference is not present, it means the branch is deleted on remote.
                deleted_branches.append(branch)

        for branch in deleted_branches:
            print("Deleting branch:"+branch)
            git_command.execute(["git", "branch", "-D",branch])


        # clean up the work flow.
        repo.git.checkout('master')
        repo.git.pull()

    if __name__ == '__main__':
        delete_merged_branches()

आशा है कि किसी को यह उपयोगी लगता है, कृपया टिप्पणी जोड़ें अगर मैंने कुछ भी याद किया।

Answer 28

यदि आप स्थापित के zshसाथ शेल का उपयोग कर रहे हैं, Oh My Zshतो इसे सुरक्षित रूप से करने का सबसे आसान तरीका स्वतः निर्मित में उपयोग करना है।

पहले यह निर्धारित करें कि आप किन शाखाओं को हटाना चाहते हैं:

~ git branch --merged

  branch1
  branch2
  branch3
* master

यह आपको पहले से विलय की गई शाखाओं की एक सूची दिखाएगा

कुछ को जानने के बाद आप हटाना चाहते हैं:

~ git branch -d 

आपको बस इतना करना है कि हिट [टैब] है और यह आपको स्थानीय शाखाओं की सूची दिखाएगा। टैब-पूर्ण का उपयोग करें या बस [टैब] को फिर से हिट करें और आप [एंटर] के साथ एक शाखा का चयन करने के लिए उनके माध्यम से साइकिल चला सकते हैं।

टैब तब तक बार-बार शाखाओं का चयन करें जब तक आपके पास उन शाखाओं की सूची न हो, जिन्हें आप हटाना चाहते हैं:

~ git branch -d branch1 branch2 branch3

अब शाखाओं के अपने संग्रह को हटाने के लिए बस एंटर दबाएं।

यदि आप अपने टर्मिनल पर zsh का उपयोग नहीं कर रहे हैं ... इसे यहाँ प्राप्त करें।

Answer 29

मुझे पाइप का उपयोग करना पसंद है क्योंकि यह कमांड को पढ़ना आसान बनाता है।

यह मेरा समाधान है यदि आप मास्टर को छोड़कर सभी शाखाओं को निकालना चाहेंगे।

git branch | grep -v master | xargs -n 1 git branch -D

अन्य मानदंडों को हटाने के लिए जो आपके मानदंडों से मेल खाते हैं, पहले और दूसरे ब्लॉक को संशोधित करें।

git branch --merged | grep feature_name | xargs -n 1 git branch -D

Answer 30

यहाँ एक सरल जवाब है जो एक git क्लाइंट का उपयोग करके मेरे लिए काम करता है:

अपनी मशीन से रिपॉजिटरी को पूरी तरह से हटा दें और फिर से देखें।

जोखिम भरी लिपियों के आसपास कोई मूकदर्शक नहीं।

Comments

वर्तमान में मैं जिन शाखाओं में काम कर रहा हूँ, उनके बारे में: /

— मेलो Sv Septel

@ MailoSv Mailtel अगर वे आपके रिमोट पर हैं, तो आप उन्हें फिर से खींच सकते हैं (अपने रिमोट से अपने नवीनतम और प्रतिबद्ध करने के लिए याद रखें!)

— जुआन कार्लोस ओस्पिना गोंजालेज

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

— मेलो Sv Septel