මට බොහෝ Git ශාඛා ඇත. දැනටමත් ඒකාබද්ධ කර ඇති ශාඛා මකා දැමිය හැක්කේ කෙසේද? ඒවා එකින් එක මකා දැමීම වෙනුවට ඒවා මකා දැමීමට පහසු ක්‍රමයක් තිබේද?

යාවත්කාලීන කිරීම:

ඔබේ වැඩ ප්‍රවාහයට හැකි මුතුන් මිත්තෙකු සිටී නම් ඔබට ස්වාමියා සහ දේව් වැනි බැහැර කිරීමට වෙනත් ශාඛා එකතු කළ හැකිය. සාමාන්‍යයෙන් මම “ස්ප්‍රින්ට්-ස්ටාර්ට්” ටැගයකින් වෙන් වී මාස්ටර්, දේව් සහ ක්වා මුතුන් මිත්තන් නොවේ.

පළමුව, දුරස්ථව ඒකාබද්ධ කළ සියලුම ශාඛා ලැයිස්තුගත කරන්න.

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

ඔබ දුරස්ථයෙන් ශාඛාව මකා දැමූ පසු, දුරස්ථ ලුහුබැඳීමේ ශාඛා ඉවත් කිරීමට ඔබට කප්පාදු කළ හැකිය:

git remote prune origin

හෝ අනෙක් පිළිතුරෙන් දැක්වෙන පරිදි තනි දුරස්ථ ෙසොයා ගැනීෙම් ශාඛා කප්පාදු කරන්න:

git branch -dr branchname

මෙය උපකාරී වේ යැයි සිතමි.

දැනටමත් ඒකාබද්ධ කර ඇති දුරස්ථයේ ඇති සියලුම ශාඛා මකා දැමීමට:

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 විසින්; අදහස් දැක්වීමට නොගැලපෙන නමුත් දැනටමත් ප්‍රමාණවත් පිළිතුරු ඇත) : ඔබ ABC git branch -r --mergedශාඛාවේ සිටී නම් ශාඛාව නිශ්චිතව දක්වා නොමැති නිසා ABC ප්‍රති results ලවල දිස්වනු ඇත , එබැවින් ශාඛාව පැහැර හැරීම වත්මන් ශාඛාවට සහ ශාඛාවකට සෑම විටම තමාටම ඒකාබද්ධ වූ ලෙස සුදුසුකම් ලබයි (ශාඛාවක් සහ තමා අතර කිසිදු වෙනසක් නැති නිසා!).

එබැවින් එක්කෝ ශාඛාව සඳහන් කරන්න:

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

හෝ පළමු පිටවීමේ මාස්ටර්:

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

ආදම්ගේ පිළිතුර ටිකක් දිගු කරමින්:

ධාවනය කිරීමෙන් මෙය ඔබගේ Git වින්‍යාසයට එක් කරන්න git config -e --global

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

එවිට ඔබට සරලව සිදුකරන සියලුම දේශීය ඒකාබද්ධ ශාඛා මකා දැමිය හැකිය git cleanup.

මාස්ටර් හැර ඒකාබද්ධ කරන ලද සියලුම ශාඛා මකා දැමීමටද මෙය ක්‍රියා කරයි.

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

ඔබට එම විධානයන්ගෙන් master& developශාඛා බැහැර කිරීමට අවශ්‍ය වනු ඇත .

දේශීය git පැහැදිලි:

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

දුරස්ථ git පැහැදිලි:

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 $_ }
}

මම දැන් අවුරුදු ගණනාවක් තිස්සේ ආදම්ගේ පිළිතුර භාවිතා කර ඇත්තෙමි. එයින් කියැවුණේ, මා බලාපොරොත්තු වූ පරිදි හැසිරෙන්නේ නැති අවස්ථා කිහිපයක් ඇති බවයි:

1. “මාස්ටර්” යන වචනය අඩංගු ශාඛා නොසලකා හරින ලදි, උදා: “නොට්මාස්ටර්” හෝ “මාස්ටර්”, ප්‍රධාන ශාඛාවට පමණක්
2. "dev" යන වචනය අඩංගු ශාඛා නොසලකා හරින ලදි, උදා: dev ශාඛාවට වඩා "dev-test"
3. වත්මන් ශාඛාවේ හෙඩ් වෙතින් ළඟා විය හැකි ශාඛා මකා දැමීම (එනම්, අනිවාර්යයෙන්ම ප්‍රධාන නොවේ)
4. වෙන් කළ HEAD තත්වයේ දී, වර්තමාන බැඳීමෙන් ළඟා විය හැකි සෑම ශාඛාවක්ම මකා දැමීම

1 සහ 2 ආමන්ත්‍රණය කිරීමට සරල විය, රීජෙක්ස් හි වෙනසක් පමණි. 3 රඳා පවතින්නේ ඔබට අවශ්‍ය දේවල සන්දර්භය මත ය (එනම්, ප්‍රධාන හා ඔබේ වර්තමාන ශාඛාවට එරෙහිව ඒකාබද්ධ නොකළ ශාඛා පමණක් මකා දමන්න). 4 git reflogඔබ නොදැනුවත්වම මෙය වෙන් කළ හෙඩ් තත්වයට ගෙන ගියහොත් විනාශකාරී විය හැකිය (ආපසු අයකර ගත හැකි වුවද ).

අවසාන වශයෙන්, මට අවශ්‍ය වූයේ මේ සියල්ල වෙනම (බාෂ් | රූබි | පයිතන්) ස්ක්‍රිප්ට් අවශ්‍ය නොවන එක් ලයිනර් එකක තිබීමයි.

ටීඑල්; ඩී.ආර්

විකල්ප -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 repo එකක් නිර්මාණය කිරීම මට පහසු වූ අතර නිවැරදි හැසිරීම පරීක්ෂා කිරීමට කැපවිය:

තනි කැපවීමකින් නව git repo එකක් සාදන්න

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

යාවත්කාලීන කරන ලද රීජෙක්ස් සමඟ (දැන් එය "dev" වෙනුවට "සංවර්ධනය" බැහැර කරයි):

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

bar
masterful
notmaster

ශාඛා foo වෙත මාරුවන්න, නව කැපවීමක් කරන්න, ඉන්පසු foo මත පදනම්ව නව ශාඛාවක්, foobar පරීක්ෂා කරන්න:

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

මගේ වර්තමාන ශාඛාව foobar වන අතර, මට මැකීමට අවශ්‍ය ශාඛා ලැයිස්තුගත කිරීම සඳහා ඉහත විධානය නැවත ක්‍රියාත්මක කරන්නේ නම්, එය "foo" ශාඛාව මාස්ටර් සමඟ ඒකාබද්ධ කර නොතිබුණද ඇතුළත් වේ:

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

  bar
  foo
  masterful
  notmaster

කෙසේ වෙතත්, මම එකම විධානය මාස්ටර් මත ධාවනය කරන්නේ නම්, "foo" ශාඛාව ඇතුළත් නොවේ:

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

වෙන්වූ HEAD තත්වය

හි පෙරනිමි හැසිරීම මත රඳා සිටීම, git branch --mergedවෙන් වූ HEAD තත්වයේ ඊටත් වඩා වැදගත් ප්‍රතිවිපාක ඇත:

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

  bar
  foo
  foobar
  masterful
  notmaster

මෙය මා දැන් සිටි ශාඛාව වන "ෆූබාර්" සහ "ෆූ" සමඟ මකා දැමෙනු ඇත, එය නිසැකවම අපේක්ෂිත ප්‍රති come ලය නොවේ. කෙසේ වෙතත්, අපගේ සංශෝධිත විධානය සමඟ:

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).

Git Sweep මේ සඳහා විශාල වැඩ කොටසක් කරයි.

Git අනුවාදය 2.5.0 භාවිතා කිරීම:

git branch -d `git branch --merged`

--Mmerged විකල්පයට ඔබට බැඳීම එකතු කළ හැකිය. මේ ආකාරයෙන් ඔබට සහතික විය හැක්කේ මූලාරම්භය / ස්වාමියා සමඟ ඒකාබද්ධ වී ඇති අතු ඉවත් කිරීමට පමණි

පහත දැක්වෙන විධානය මඟින් ඔබේ සම්භවයක් ඇති ඒකාබද්ධ ශාඛා ඉවත් කරනු ඇත.

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

Git push සම්භවය වෙනුවට ප්‍රතිස්ථාපනය කරන ලද අතු ඉවත් කරන්නේ කුමන අතුදැයි ඔබට පරීක්ෂා කළ හැකිය

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

දැනටමත් ඒකාබද්ධ වී ඇති මගේ දේශීය හා දුරස්ථ ශාඛා මකා දැමීමට මම පහත සඳහන් රූබි ස්ක්‍රිප්ට් භාවිතා කරමි. මම එය කරන්නේ දුරස්ථ දුරස්ථ ගබඩාවක් සඳහා වන අතර එයින් එකක් පමණක් මකා දැමීමට අවශ්‍ය නම්, මම දුරස්ථ ලැයිස්තුවට තෝරාගත් ප්‍රකාශයක් එක් කර මට අවශ්‍ය දුරස්ථ ලබා ගැනීම පමණි.

#!/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 | %{git branch -d $_.Trim()}

ඔබට මාස්ටර් හෝ වෙනත් ශාඛා නම් බැහැර කිරීමට අවශ්‍ය නම්, ඔබට මේ ආකාරයට පවර්ෂෙල් තෝරන්න-ස්ට්‍රිං සමඟ නළා ප්‍රති result ලය ලබා දිය හැකිය git branch -d:

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

කුබූන්ගේ පිළිතුරට ශාඛා නාමයේ මාස්ටර් යන වචනය ඇති ශාඛා මකා දැමීම මග හැරුණි. ඔහුගේ පිළිතුර මත පහත සඳහන් කරුණු වැඩි දියුණු වේ:

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

ඇත්ත වශයෙන්ම, එය "මාස්ටර්" ශාඛාව මකා නොදමයි :)

මෙය ස්වයංක්‍රීයව ඔබ වෙනුවෙන් කරන විධානයක් Git හි නොමැත. නමුත් ඔබට අවශ්‍ය දේ ලබා දීමට Git විධාන භාවිතා කරන ස්ක්‍රිප්ටයක් ලිවිය හැකිය. ඔබ භාවිතා කරන ශාඛා ආකෘතිය අනුව මෙය බොහෝ ආකාරවලින් කළ හැකිය.

ශාඛාවක් මාස්ටර් සමඟ ඒකාබද්ධ වී ඇත්දැයි දැන ගැනීමට අවශ්‍ය නම්, MyTopicBranch ඒකාබද්ධ කර ඇත්නම් පහත විධානය මඟින් ප්‍රතිදානයක් නොලැබේ (එනම් ඔබට එය මකා දැමිය හැකිය)

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

ඔබට Git ශාඛා විධානය භාවිතා කර Bash හි ඇති සියලුම ශාඛා විග්‍රහ කර සියලු ශාඛා වලට forවඩා ලූපයක් කළ හැකිය. මෙම ලූපය තුළ ඔබට ශාඛාව මකා දැමිය හැකිද නැද්ද යන්න ඉහත විධානයෙන් පරීක්ෂා කරන්න.

ඔබ වින්ඩෝස් හි සිටී නම් ඔබට වින්ඩෝස් පවර්ෂෙල් හෝ පවර්ෂෙල් 7 භාවිතා කළ හැකිය අවුට්-ග්‍රිඩ්වීව් සමඟ හොඳ ශාඛා ලැයිස්තුවක් ඇති අතර ඔබට මකා දැමීමට අවශ්‍ය මූසිකය සමඟ තෝරන්න:

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

හරි ක්ලික් කිරීමෙන් පසු පවර්ෂෙල් විසින් මෙම ශාඛා නම් git branch -dවිධාන හා මකා දැමෙනු ඇත

git branch --merged | grep -Ev '^(. master|\*)' | xargs -n 1 git branch -d දැනට පරීක්ෂා කර ඇති ශාඛාව සහ / හෝ හැර අනෙකුත් සියලුම දේශීය ශාඛා මකා දමනු ඇත master .

මෙම විධානයන් අවබෝධ කර ගැනීමට බලාපොරොත්තු වන අයට මෙන්න ප්‍රයෝජනවත් ලිපියක්: Git Clean: දැනටමත් ඒකාබද්ධ කළ ශාඛා මකන්න, ස්ටීවන් හර්මන් විසිනි.

සටහන : පෙර පිළිතුරු ගැන මම සතුටු නොවෙමි, (සියලුම පද්ධතිවල වැඩ නොකිරීම, දුරස්ථව වැඩ නොකිරීම, - ගිලී ගිය ශාඛාව නියම නොකිරීම, හරියටම පෙරීම නොකිරීම). ඉතින්, මම මගේම පිළිතුරක් එක් කරමි.

ප්‍රධාන අවස්ථා දෙකක් තිබේ:

දේශීය

ඔබට අවශ්ය දේශීය ශාඛා මකා ඇති බව මේ වන විටත් තවත් ශාඛා කිරීමට ඒකාබද්ධ . මකාදැමීමේදී, මාස්ටර්, සංවර්ධනය වැනි වැදගත් ශාඛා කිහිපයක් තබා ගැනීමට ඔබට අවශ්‍යය.

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 , එබැවින් එය උදාසීන නොවන පද්ධති වලද ක්‍රියා කරයි (එනම්: කවුළු සඳහා git).
• grep -E -v '^master$|^feature/develop$' මට මැකීමට අවශ්‍ය නැති දේශීය ශාඛා නියම කිරීමයි
• xargs -n 1 git branch -d: දේශීය ශාඛා මකාදැමීම සිදු කරන්න (එය දුරස්ථ ඒවා සඳහා ක්‍රියා නොකරනු ඇත)
• දැනට පරීක්ෂා කර ඇති ශාඛාව මකා දැමීමට උත්සාහ කළහොත් ඇත්ත වශයෙන්ම ඔබට දෝෂයක් ඇතිවේ. එබැවින්, මාස්ටර් වෙත මාරු වීමට පෙර යෝජනා කරමි.

දුරස්ථ

ඔබට අවශ්ය දුරස්ථ ශාඛා මකා ඇති බව මේ වන විටත් තවත් දුරස්ථ ශාඛාව ඒකාබද්ධ . මකාදැමීමේදී, ඔබට HEAD, master, release වැනි වැදගත් ශාඛා කිහිපයක් තබා ගැනීමට අවශ්‍යය.

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 : දුරස්ථ ශාඛා මකාදැමීම සිදු කරන්න.

ඔබට git-del-br මෙවලම භාවිතා කළ හැකිය .

git-del-br -a

pipභාවිතයෙන් ඔබට එය ස්ථාපනය කළ හැකිය

pip install git-del-br

PS: මම මෙවලමෙහි කර්තෘ. ඕනෑම යෝජනා / ප්‍රතිපෝෂණ සාදරයෙන් පිළිගනිමු.

ඔබ දැනට සිටින ශාඛාවට දැනටමත් ඒකාබද්ධ වී ඇති සියලුම දේශීය ශාඛා මකා දැමීමට ඔබ කැමති නම්, කලින් පිළිතුරු මත පදනම්ව, එසේ කිරීමට මම ආරක්ෂිත විධානයක් ඉදිරිපත් කර ඇත්තෙමි.

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

මෙම විධානය ඔබගේ වර්තමාන ශාඛාවට හෝ ප්‍රධාන ශාඛාවට බලපාන්නේ නැත. -Tar ධජය xargs භාවිතා කරමින් එය කිරීමට පෙර එය කරන්නේ කුමක්ද යන්නත් එය ඔබට කියනු ඇත.

ආදම්ගේ යාවත්කාලීන පිළිතුරේ අන්වර්ථ අනුවාදය :

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

එසේම, සංකීර්ණ අන්වර්ථ නාමයන්ගෙන් ගැලවීම පිළිබඳ පහසු උපදෙස් සඳහා මෙම පිළිතුර බලන්න .

මම git-flow esque නම් කිරීමේ ක්‍රමයක් භාවිතා කරමි, එබැවින් මෙය මට ඉතා ආරක්ෂිතව ක්‍රියා කරයි:

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

එය මූලික වශයෙන් සොයන්නේ නූල් fix/හෝ සමඟ ආරම්භ වන ඒකාබද්ධ කොමිස් ය feature/.

පහත විධානය උත්සාහ කරන්න:

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කර ඇත්නම්, නැතිවූ කොමිස් සොයා ගැනීමට භාවිතා කරන්න.

මෙම සමහර පිළිතුරු මත පදනම්ව මම එය කිරීමට මගේම බාෂ් පිටපතක් සාදන ලදී !

එය ඒකාබද්ධ කර ඇති ශාඛා භාවිතා කිරීම 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
}

පහත විමසුම මට වැඩ කරයි

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

මෙය ග්‍රෙප් පයිප්පයේ ඇති ඕනෑම ශාඛාවක් පෙරහන් කරයි.

Http ක්ලෝන හරහා හොඳින් ක්‍රියා කරයි, නමුත් ssh සම්බන්ධතාවය සඳහා එතරම් හොඳ නැත.

2018.07 වන විට

[alias]ඔබගේ කොටස වෙත මෙය එක් කරන්න ~/.gitconfig:

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

දැන් ඔබට git sweepඅවශ්‍ය පිරිසිදු කිරීම සිදු කිරීමට ඇමතිය හැකිය .

වින්ඩෝස් වල git bash ස්ථාපනය කර ඇති egrep -v ක්‍රියා නොකරනු ඇත

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

එහිදී grep -E -vසමාන වේegrep -v

-dදැනටමත් ඒකාබද්ධ කරන ලද අතු -Dඉවත් කිරීමට හෝ නොකැඩූ අතු ඉවත් කිරීමට භාවිතා කරන්න

එක් සෙන්ටිමීටරයකින් ඒකාබද්ධ කළ දේශීය හා දුරස්ථ ශාඛා ඉවත් කිරීමට මම පහත ක්‍රමය භාවිතා කර ඇත්තෙමි .

මගේ 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
}

මුල් ප්‍රභවය

මෙය ප්‍රධාන ශාඛාව මකා නොදමනු ඇත, නමුත් ඒකාබද්ධ කළ දේශීය හා දුරස්ථ ශාඛා ඉවත් කරයි . ඔබ මෙය ඔබගේ rc ගොනුවේ ඇති පසු, ධාවනය කරන්න rmb, ඔබට ඒකාබද්ධ කරන ලද ශාඛා ලැයිස්තුවක් පෙන්වනු ලබන අතර ඒවා පිරිසිදු කර ක්‍රියාව පිළිබඳ තහවුරු කිරීමක් ඉල්ලා සිටිනු ඇත. තහවුරු කිරීම ඉල්ලා නොසිටීම සඳහා ඔබට කේතය වෙනස් කළ හැකිය, නමුත් එය තබා ගැනීම හොඳය.

මාස්ටර් සමඟ ඒකාබද්ධ කර ඇති සියලුම ශාඛා 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

පිළිගත් විසඳුම ඉතා හොඳයි, නමුත් එක් ගැටළුවක් ඇත, එය දුරස්ථයකට ඒකාබද්ධ නොවූ දේශීය ශාඛා ද මකා දමයි.

ඔබ ප්‍රතිදානය දෙස බැලුවහොත් ඔබේ වැනි දෙයක් පෙනෙනු ඇත

$ 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

තවමත් ඒකාබද්ධ නොවූ අතු ආරක්ෂා කිරීමට. මෙය දුරස්ථ සම්භවයක් ඇති නිසාත්, නැති වී ඇති බවක් නොපෙන්වන නිසාත්, එය ආරක්ෂා කිරීම සඳහා ස්වාමියාට ඇඹරීම අවශ්‍ය නොවේ.

මට git branch --mergedGitHub 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