git - मैं सभी गिट शाखाओं को कैसे हटा सकता हूं जिन्हें विलय कर दिया गया है?




github version-control (20)

PowerShell कंसोल में विलय वाली शाखाओं को कैसे हटाएं

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

विंडोज के लिए गिटहब देखें

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


अद्यतन करें:

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

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

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

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

आप विलय वाली स्थानीय शाखा को हटा सकते हैं:

git branch -d branchname

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

git branch -D branchname

गिट उपयोग के पुराने संस्करणों में रिमोट से इसे हटाने के लिए:

git push origin :branchname

गिट उपयोग के हाल के संस्करणों में:

git push --delete origin branchname

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

git remote prune origin

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

git branch -dr branchname

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


आप git-del-br tool उपयोग कर सकते हैं।

git-del-br -a

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

pip install git-del-br

पीएस: मैं उपकरण का लेखक हूं। कोई सुझाव / फीडबैक स्वागत है।


आप 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

आप में से जो विंडोज़ पर हैं और पावरशेल स्क्रिप्ट पसंद करते हैं, यहां एक ऐसा है जो स्थानीय विलय वाली शाखाओं को हटा देता है:

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

इन उत्तरों में से कुछ के आधार पर मैंने अपनी खुद की बैश स्क्रिप्ट भी ऐसा करने के लिए बनाई!

यह git branch --merged का उपयोग करता है - 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
}

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

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

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


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

यदि आपको यह जानने की ज़रूरत है कि क्या शाखा को मास्टर में विलय कर दिया गया है, तो निम्न आदेश कम नहीं करेगा यदि मायटोपिक ब्रंच विलय कर दिया गया है (यानी आप इसे हटा सकते हैं)

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

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


निम्न आदेश आज़माएं:

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 | जोड़ें केवल origin फ़िल्टर करने के लिए cut से पहले।

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

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

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

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

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


मास्टर की तुलना में किसी भी अन्य शाखा से गलती से आदेश चलाने से बचने के लिए मैं निम्नलिखित बैश स्क्रिप्ट का उपयोग करता हूं। अन्यथा, git branch --merged | grep -v "\*" | xargs -n 1 git branch -d git branch --merged | grep -v "\*" | xargs -n 1 git branch -d git branch --merged | grep -v "\*" | xargs -n 1 git branch -d एक शाखा से जो मास्टर ऑफ विलय किया गया है, मास्टर शाखा को हटा सकता है।

#!/bin/bash

branch_name="$(git symbolic-ref HEAD 2>/dev/null)" ||
branch_name="(unnamed branch)"     # detached HEAD
branch_name=${branch_name##refs/heads/}

if [[ $branch_name == 'master' ]]; then
   read -r -p "Are you sure? [y/N] " response
   if [[ $response =~ ^([yY][eE][sS]|[yY])$ ]]; then
       git branch --merged | grep -v "\*" | xargs -n 1 git branch -d
   fi
else
   echo "Refusing to delete branches that are not merged into '$branch_name'. Checkout master first."
fi

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

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 क्लोन पर अच्छी तरह से काम करता है, लेकिन एसएसएच कनेक्शन के लिए इतना अच्छा नहीं है।


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

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

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

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

यह आदेश आपकी वर्तमान शाखा या आपकी मास्टर शाखा को प्रभावित नहीं करेगा। Xargs के झंडे का उपयोग करके यह आपको यह भी बताएगा कि यह क्या कर रहा है।


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

git branch --merged | xargs -I_br -- sh -c 'git branch -d _br; git push origin --delete _br'

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

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

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

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

गिट के हाल के संस्करणों में

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

सिर्फ एडम के जवाब को थोड़ा सा विस्तारित करना:

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

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

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


मेरा बैश स्क्रिप्ट योगदान mmrobin के उत्तर पर आधारित है।

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

#!/bin/bash

# exclude branches regex, configure as "(branch1|branch2|etc)$"
excludes_default="(master|next|ag/doc-updates)$"
excludes="__NOTHING__"
includes=
merged="--merged"
local=1
remote=1

while [ $# -gt 0 ]; do
  case "$1" in
  -i) shift; includes="$includes $1" ;;
  -e) shift; excludes="$1" ;;
  --no-local) local=0 ;;
  --no-remote) remote=0 ;;
  --all) merged= ;;
  *) echo "Unknown argument $1"; exit 1 ;;
  esac
  shift   # next option
done

if [ "$includes" == "" ]; then
  includes=".*"
else
  includes="($(echo $includes | sed -e 's/ /|/g'))"
fi

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 -e "Fetching branches...\n"

git remote update --prune
remote_branches=$(git branch -r $merged | grep -v "/$current_branch$" | grep -v -E "$excludes" | grep -v -E "$excludes_default" | grep -E "$includes")
local_branches=$(git branch $merged | grep -v "$current_branch$" | grep -v -E "$excludes" | grep -v -E "$excludes_default" | grep -E "$includes")
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 [ "$remote" == 1 -a -n "$remote_branches" ]; then
    echo "$remote_branches"
  fi
  if [ "$local" == 1 -a -n "$local_branches" ]; then
    echo "$local_branches"
  fi
  read -p "Continue? (y/n): " -n 1 choice
  echo
  if [ "$choice" == "y" ] || [ "$choice" == "Y" ]; then
    if [ "$remote" == 1 ]; then
      remotes=$(git remote)
      # Remove remote branches
      for remote in $remotes
      do
        branches=$(echo "$remote_branches" | grep "$remote/" | sed "s/$remote\/\(.*\)/:\1 /g" | tr -d '\n')
        git push $remote $branches
      done
    fi

    if [ "$local" == 1 ]; then
      # Remove local branches
      locals=$(echo "$local_branches" | sed 's/origin\///g' | tr -d '\n')
      if [ -z "$locals" ]; then
        echo "No branches removed."
      else
        git branch -d $(echo "$locals" | tr -d '\n')
      fi
    fi
  fi
fi

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

इन आदेशों को समझने वाले लोगों के लिए यहां एक उपयोगी लेख दिया गया है: गिट क्लीन: स्टीवन हरमन द्वारा पहले से ही मर्ज किए गए शाखाओं को हटाएं


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

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

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





feature-branch