දුරස්ථව තවදුරටත් ලුහුබැඳීමේ ශාඛා ඉවත් කරන්න

දුරස්ථ සමානතාවයක් නොපවතින සියලුම ලුහුබැඳීම් ශාඛා මකා දැමීමට සරල ක්‍රමයක් තිබේද?

උදාහරණයක්:

ශාඛා (දේශීය හා දුරස්ථ)

• ස්වාමියා
• සම්භවය / ස්වාමියා
• සම්භවය / දෝෂ නිරාකරණය-අ
• සම්භවය / දෝෂ නිරාකරණය-ආ
• සම්භවය / දෝෂ නිරාකරණය-ඇ

දේශීය වශයෙන්, මා සතුව ඇත්තේ ප්‍රධාන ශාඛාවක් පමණි. දැන් මට දෝෂ නිරාකරණය සඳහා වැඩ කිරීමට අවශ්‍යයි , එබැවින් මම එය පරීක්ෂා කර, එය මත වැඩ කර දුරස්ථයට වෙනස්කම් තල්ලු කරමි. ඊළඟට මම දෝෂ නිවැරදි කිරීම-බී සමඟද එසේ කරමි .

ශාඛා (දේශීය හා දුරස්ථ)

• ස්වාමියා
• දෝෂ නිරාකරණය-අ
• bug-fix-b
• සම්භවය / ස්වාමියා
• සම්භවය / දෝෂ නිරාකරණය-අ
• සම්භවය / දෝෂ නිරාකරණය-ආ
• සම්භවය / දෝෂ නිරාකරණය-ඇ

දැන් මට දේශීය ශාඛා මාස්ටර් , දෝෂ නිවැරදි කිරීම , දෝෂ නිවැරදි කිරීම-බී ඇත. මාස්ටර් ශාඛා නඩත්තු කරන්නා මගේ වෙනස්කම් මාස්ටර් සමඟ ඒකාබද්ධ කර ඔහු දැනටමත් ඒකාබද්ධ කර ඇති සියලුම ශාඛා මකා දමනු ඇත.

එබැවින් වර්තමාන තත්වය දැන්:

ශාඛා (දේශීය හා දුරස්ථ)

• ස්වාමියා
• දෝෂ නිරාකරණය-අ
• bug-fix-b
• සම්භවය / ස්වාමියා
• සම්භවය / දෝෂ නිරාකරණය-ඇ

දැන් මම delete ශාඛා (මෙම අවස්ථාවේදී සමහර විධාන කතා කිරීමට කැමති දෝෂ සඳහා අපූරු එනම් , දෝෂ සඳහා අපූරු-ආ තවදුරටත් දුරස්ථ නිධිය තුල නියෝජනය කරන),.

එය පවත්නා විධානය වැනි දෙයක් වනු ඇත git remote prune origin, නමුත් ඊට වඩා වැඩි ය git local prune origin.

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

විධානයෙන් පසුව

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

මෙම පිළිතුරු බොහොමයක් ඇත්ත වශයෙන්ම මුල් ප්‍රශ්නයට පිළිතුරු සපයන්නේ නැත. මම කැණීම් පොකුරක් කළ අතර මෙය මා සොයාගත් පිරිසිදුම විසඳුමයි. මෙන්න එම පිළිතුරේ තරමක් ගැඹුරු අනුවාදයක්:

1. ඔබගේ සුපුරුදු ශාඛාව බලන්න. සාමාන්යයෙන්git checkout master
2. දුවන්න git fetch -p && git branch -vv | awk '/: gone]/{print $1}' | xargs git branch -d

පැහැදිලි කිරීම:

ඔබේ ලුහුබැඳීමේ ශාඛා කප්පාදු කිරීමෙන් පසුව ඒවා ක්‍රියාත්මක වී ඇති බව පෙන්වන දේශීය ඒවා මකා දැමීම මඟින් ක්‍රියා කරයි git branch -vv.

සටහන්:

ඔබේ භාෂාව ඉංග්‍රීසි හැර වෙනත් දෙයකට සකසා ඇත්නම් ඔබට goneසුදුසු වචනයට වෙනස් විය යුතුය. දේශීය පමණක් වන ශාඛා ස්පර්ශ නොවනු ඇත. දුරස්ථව මකාදැමූ නමුත් ඒකාබද්ධ නොකළ ශාඛා දැනුම්දීමක් පෙන්වන නමුත් දේශීයව මකා නොදමනු ඇත. ඔබට ඒවා මකා දැමීමට අවශ්‍ය නම් වෙනස් -dකරන්න -D.

දැනටමත් පිළිතුරු 16 ක් ඇති ප්‍රශ්නයකට මම සාමාන්‍යයෙන් පිළිතුරු නොදෙමි, නමුත් අනෙක් සියලුම පිළිතුරු වැරදියි, නිවැරදි පිළිතුර ඉතා සරල ය. ප්රශ්නය පවසන්නේ, "දුරස්ථ සමානතාවයක් නොපවතින සියලුම ලුහුබැඳීම් ශාඛා මකා දැමීමට සරල ක්රමයක් තිබේද?"

“සරල” යන්නෙන් අදහස් කරන්නේ ඒවා සියල්ලම එකවර මකා දැමීම, බිඳෙන සුළු වීම, භයානක නොවීම සහ සියලු පා readers කයන්ට නොලැබෙන මෙවලම් මත රඳා නොසිටීම නම්, නිවැරදි පිළිතුර: නැත.

සමහර පිළිතුරු සරල ය, නමුත් ඔවුන් ඉල්ලූ දේ නොකරයි. තවත් සමහරු ඉල්ලූ දේ කරති, නමුත් සරල නැත: සියල්ල රඳා පවතින්නේ පෙළ හැසිරවීමේ විධානයන් හෝ ස්ක්‍රිප්ටින් භාෂාවන් හරහා Git ප්‍රතිදානය විග්‍රහ කිරීම මත වන අතර ඒවා සෑම පද්ධතියකම නොතිබිය හැකිය. ඊට ඉහළින්, බොහෝ යෝජනා පෝසිලේන් විධාන භාවිතා කරයි, ඒවායේ ප්‍රතිදානය ස්ක්‍රිප්ට් මඟින් විග්‍රහ කිරීමට සැලසුම් කර නොමැත (“පෝසිලේන්” යනු මිනිස් ක්‍රියාකාරිත්වය සඳහා අදහස් කරන විධානයන් ය; ස්ක්‍රිප්ට් පහළ මට්ටමේ “ජලනල” විධානයන් භාවිතා කළ යුතුය).

තවදුරටත් කියවීම:

• ඇයි ඔබ විග්රහ කළ යුතු git branchතිර රචනය තුළ ප්රතිදානය .
• සොයා ශාඛා හා අතර ඇති වෙනස්කම් git remote prune, git prune,git fetch --prune

ඔබට මෙය ආරක්ෂිතව කිරීමට අවශ්‍ය නම්, ප්‍රශ්නයේ භාවිතා වන අවස්ථාව සඳහා (සේවාදායකයේ මකාදමා ඇති නමුත් තවමත් දේශීය ශාඛා ලෙස පවතින කසළ එකතු කිරීමේ ෙසොයා ගැනීෙම් ශාඛා) සහ ඉහළ මට්ටමේ Git විධාන සහිතව, ඔබට කළ යුතුව ඇත

• 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(ඔබට තවත් අවශ්‍ය නොවනු ඇත, X විශේෂාංගයේ වැඩ කටයුතු අනුමාන වශයෙන් අවසන් remotes/origin/feature/Xවී ඇති හෙයින් ), සහ ඔබේ එකම අරමුණ වූයේ සේවාදායක ශාඛාවේ තත්වය මතක තබා ගැනීමයි. .

හා Git ඔබ ස්වයංක්රීයව අතිරික්ත පිරිසිදු ඉඩ ඇත remotes/origin/feature/Xමොකක්ද බව - git fetch --pruneකරන්නේ - නමුත් යම් හේතුවක් නිසා, එය ඔබ ස්වයංක්රීයව ඔබගේ මකා ඉඩ දෙන්නේ නැහැ feature/Xඔබගේ වුවත් ... feature/Xතවමත් අනාථ හඹායෑම් තොරතුරු අඩංගු වේ, එය ද තොරතුරු ලැබී ඇතැයි ඒ නිසා සම්පුර්ණයෙන්ම ඒකාබද්ධ කර ඇති කලින් ලුහුබැඳීමේ ශාඛා හඳුනා ගැනීමට. (සියල්ලට පසු, එය ඔබට අතින්ම මෙහෙයුම කිරීමට ඉඩ සලසන තොරතුරු ලබා දිය හැකිය .)

මම මෙහි පිළිතුර සොයාගතිමි: ඒකාබද්ධ කර ඇති සියලුම git ශාඛා මකා දැමිය හැක්කේ කෙසේද?

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

වින්ඩෝස් විසඳුම

මයික්‍රොසොෆ්ට් වින්ඩෝස් පවර්ෂෙල් සඳහා:

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

පැහැදිලි කිරීම

git checkout master ප්‍රධාන ශාඛාවට මාරු වේ

git remote update origin --prune දුරස්ථ අතු කප්පාදු කරයි

git branch -vvසියලුම ශාඛා වල වාචික ප්‍රතිදානය ලබා ගනී ( git යොමු )

Select-String -Pattern ": gone]" ලැබෙන්නේ ඒවා දුරස්ථයෙන් ඉවත් කළ වාර්තා පමණි.

% { $_.toString().Trim().Split(" ")[0]} ශාඛාවේ නම ලබා ගන්න

% {git branch -d $_} ශාඛාව මකා දමයි

අනෙක් විසඳුම් බොහොමයක "ගොස්" සඳහා ගැලපෙන රටාව මට ටිකක් බය විය. ආරක්ෂිත වීමට, මෙය --formatඑක් එක් ශාඛාවේ උඩු යටිකුරු කිරීමේ තත්වය ඉවත් කිරීමට ධජය භාවිතා කරයි .

මට වින්ඩෝස් හිතකාමී අනුවාදයක් අවශ්‍ය විය, එබැවින් මෙය පවර්ෂෙල් භාවිතයෙන් "නැතිවී" ලෙස ලැයිස්තුගත කර ඇති සියලුම ශාඛා මකා දමයි:

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

පළමු පේළියේ ලැයිස්තුගත කර ඇත්තේ ඉහළ ශාඛාව "නැතිවී" ඇති දේශීය ශාඛා වල නමයි. ඊළඟ පේළිය හිස් රේඛා ඉවත් කරයි (ඒවා "නැති" ශාඛා සඳහා ප්‍රතිදානය වේ), පසුව ශාඛාවේ නම ශාඛාව මකා දැමීමේ විධානය වෙත යවනු ලැබේ.

ස්වාමියා සමඟ ඒකාබද්ධ කර ඇති සියලුම ශාඛා ඉවත් කරන්න, නමුත් ස්වාමියා ඉවත් කිරීමට උත්සාහ නොකරන්න:

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) මාස්ටර් සමඟ ඒකාබද්ධ කර ඇති සියලුම ශාඛා මකන්න, නමුත් මාස්ටර් ඉවත් කිරීමට උත්සාහ නොකරන්න

git fetch -p

මෙය දුරස්ථයේ තවදුරටත් නොපවතින ඕනෑම ශාඛාවක් කප්පාදු කරනු ඇත .

පැට්‍රික්ගේ පිළිතුරෙන් බොහෝ සෙයින් උකහා ගන්නා ගොඩට තවත් පිළිතුරක් ( නිමැවුමට 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විකල්පය තරමක් අලුත් බව පෙනේ; මට එය ලබා ගැනීම සඳහා 2.10 සිට යම් දෙයක් 2.16.3 දක්වා වැඩි කිරීමට අවශ්‍ය විය.

සංස්කරණය: ගැන යෝජනාවක් ඇතුළත් කිරීමට මනා අවධානය refname:shortසිට බෙන්ජමින් ඩබ්

NB2 - මම අත්හදා බැලුවේ පමණක් bash, ඒ නිසා හැෂ්බෑන්ග්, නමුත් බොහෝ විට අතේ ගෙන යා හැකිය sh.

මෙය දේශීය මාස්ටර් යොමු කිරීම සහ දැනට භාවිතා කරන එක හැර ඒකාබද්ධ කරන ලද සියලුම දේශීය ශාඛා මකා දමනු ඇත:

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

මෙය " සම්භවය " මගින් සඳහන් කර ඇති දුරස්ථ ගබඩාවෙන් දැනටමත් ඉවත් කර ඇති සියලුම ශාඛා මකා දමනු ඇත , නමුත් තවමත් දේශීයව " දුරස්ථ / සම්භවය " තුළ ඇත.

git remote prune origin

මාස්ටර් හැර අනෙකුත් සියලුම දේශීය ශාඛා ඉවත් කර සංවර්ධනය කිරීම සඳහා සරල එක් පේළියක් සමහරුන්ට ප්‍රයෝජනවත් විය හැකිය

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

මෙය සිදු කිරීම සඳහා ගොඩනංවන ලද විධානයක් ඇතැයි මම නොසිතමි, නමුත් පහත සඳහන් දේ කිරීම ආරක්ෂිත ය:

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

ඔබ භාවිතා කරන විට -d, ශාඛාව සම්පූර්ණයෙන්ම ඒකාබද්ධ වී HEADහෝ එහි උඩුමහලේ දුරස්ථ ලුහුබැඳීමේ ශාඛාවට මිස git මැකීම ප්‍රතික්ෂේප කරනු ඇත . එබැවින්, ඔබට සෑම විටම ප්‍රතිදානය ඉක්මවා ගොස් 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

අවවාදයයි: මම මෙම ස්ක්‍රිප්ට් පරීක්‍ෂා කර නැත - පරිස්සමින් පමණක් භාවිතා කරන්න ...

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

දුරස්ථව නොමැති සියලුම දේශීය ශාඛා ඉවත් කරන්න

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.

ඔබට මෙය කළ හැකිය:

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

තවත් පිළිතුරක් නම්, විසඳුම් කිසිවක් මගේ අවශ්‍යතාවයට අලංකාරය සහ හරස් වේදිකාව මත නොගැලපෙන බැවිනි:

දුරස්ථව නොවන දේශීය ශාඛා මකා දැමීමට අණ කරන්න:

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'

(පවර්ෂෙල් සහ බැෂ් සඳහා විශ්වීය විධානයක් සොයා ගැනීමට උදව් අවශ්‍ය වේ)

මෙම පිළිතුර හොඳම වන්නේ ඇයි?

• සම්පූර්ණ විසඳුමක් ලබා දෙයි: git branch-pruneඔබේ git වෙත විධානයක් එක් කරයි
• වින්ඩෝස් පවර්ෂෙල් වෙතින් හොඳින් ක්‍රියා කරයි
• හරය අදහසක් වේ @ jason.rickman ගේ වෙඩි නොවදින ක්රමය භාවිතාgit for-each-ref
• විග්‍රහ කිරීම සහ පෙරීම සිදු කරනුයේ --filterබාහිර පරායත්තයන් අවශ්‍ය නොවන බැවිනි

පැහැදිලි කිරීම:

• ඔබට නව අන්වර්ථයක් එක් කරයි ~\.gitconfig. මෙය ක්‍රියාත්මක කිරීමෙන් පසු ඔබට සරලව කළ හැකියgit branch-prune
• මෙම අන්වර්ථය ඇතුළත:
  • --pruneධජය සමඟ අතු ලබා ගනී , එය "දුරස්ථ ලුහුබැඳීමේ අතු තවදුරටත් දුරස්ථව කප්පාදු නොකරයි"
  • ශාඛා ලැයිස්තුවක් ලබා ගැනීම සඳහා භාවිතයන් git for-each-refසහ (දුරස්ථ නැත)--filter[gone]
  • මෙම ලැයිස්තුව හරහා ලූප සහ ශාඛාව ආරක්ෂිතව මකා දමයි

ඉහත තොරතුරු මත පදනම්ව, මෙය මට වැඩ කළේය:

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

එය ': gone] 'දුරස්ථව ඇති සියලුම දේශීය ශාඛා ඉවත් කරයි .

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

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

මේ කිසිවක් මට ඇත්තටම සුදුසු නැත. 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

මත පදනම් මකමින් පරණ පළාත් ශාඛා: Git ඉඟිය සමාන පෙනෙන, jason.rickman විසඳුම මේ සඳහා කැඳවා සඳහා අභිරුචි විධානය ක්රියාත්මක ගොස් GIT බෑෂ් භාවිතා:

$ 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 go යනුවෙන්ද හැඳින්වේ .

මෙහි ඇති වෙනත් පිළිතුරු ගණනාවකින් බොහෝ සෙයින් උපුටා ගත් මම පහත සඳහන් දෑ සමඟ අවසන් කර ඇත්තෙමි (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නිසි පලා ප්රතිදානය ලබා ගැනීමට තර්කය (මේ ref නාමයෙන් ඕනෑම චරිතයක් ගැන කරදර වෙන්න අපට ඉඩ).

මම මේ බෑෂ් පිටපත සමඟ ආවා. එය සෑම විටම අතු තබා 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
}

උපක්‍රමය කිරීමට මම කෙටි ක්‍රමයක් භාවිතා කරමි, පැය කිහිපයක් ඉතිරි කර ගැනීමට සහ ඔබට වැඩි දෘශ්‍යතාවයක් ලබා දිය හැකි ආකාරයටම එය කිරීමට මම ඔබට නිර්දේශ කරමි

ඔබගේ .bashrc (මැකෝස් මත .bashprofile) වෙත පහත දැක්වෙන ස්නිපටය එක් කරන්න.

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

1. සියලුම දුරස්ථ ස්ථාන ලබා ගන්න
2. Git වෙතින් ඒකාබද්ධ ශාඛා පමණක් ලබා ගන්න
3. මෙම ලැයිස්තුවෙන් "ආරක්ෂිත / වැදගත්" ශාඛා ඉවත් කරන්න
4. ඉතිරි කොටස ඉවත් කරන්න (උදා: පිරිසිදු හා ඒකාබද්ධ කළ අතු)

ඔබගේ අවශ්‍යතාවන්ට සරිලන සේ ඔබට grep regex සංස්කරණය කිරීමට සිදුවේ (මෙහි, එය මාස්ටර්, ප්‍රෙප්‍රොඩ් සහ ඩීඑම්එස් මකාදැමීම වළක්වයි)

මෙය මට ප්‍රයෝජනවත් විය:

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

මම පයිප්ප භාවිතා කිරීමට කැමතියි, මන්ද එය විධානය කියවීමට පහසු කරයි.

මාස්ටර් හැර අනෙකුත් සියලුම ශාඛා ඉවත් කිරීමට ඔබ කැමති නම් මෙය මගේ විසඳුමයි.

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

ඔබේ නිර්ණායකයන්ට ගැලපෙන වෙනත් ශාඛා මකා දැමීමට, පළමු හා දෙවන කොටස වෙනස් කරන්න.

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

පවර්ෂෙල් මත පදනම් වූ විසඳුම (එබැවින් වින්ඩෝස්) මෙහි ක්‍රියාත්මක කිරීම් බොහොමයකට වඩා පැහැදිලි බව මට පෙනේ.

# prune deleted remoted branches
git fetch -p

# get all branches and their corresponding remote status
# deleted remotes will be marked [gone]
git branch -v |
  #find ones marked [gone], capture branchName
  select-string -Pattern '^  (?<branchName>\S+)\s+\w+ \[gone\]' | 
  foreach-object{ 
     #delete the captured branchname.
     git branch -D $_.Matches[0].Groups['branchName']
  }

කොපමණ කාලයක් දැයි මට විශ්වාස නැත, නමුත් මම දැන් git-up භාවිතා කරමි, එය ඒ ගැන සැලකිලිමත් වේ.

මම කරන git upඅතර එය නව ශාඛා ලුහුබැඳීමට පටන් ගෙන පැරණි ඒවා මකා දමයි.

එය පැහැදිලි කිරීම සඳහා, එය පිටතින් ඇති git විධානයක් නොවේ - https://github.com/aanand/git-up

බීටීඩබ්ලිව් එය අපිරිසිදු ගසක් තැන්පත් කර ඇති අතර එය සාධාරණ ලෙස ප්‍රතික්ෂේප git upකරයි.

එය යමෙකුට ප්‍රයෝජනවත් වේ යැයි සිතමි

මෙන්න මාළු කවචය සඳහා මම භාවිතා කරන විසඳුමක්. පරීක්ෂා කර 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>උඩුමහලේ හෝ වර්තමාන හෙඩ් සමඟ සම්පුර්ණයෙන්ම ඒකාබද්ධ නොවූ කිසිදු ශාඛාවක් මකා නොදැමීම සඳහා මම අතිරේක පූර්වාරක්ෂාවක් ලෙස භාවිතා කරමි .

ටෙස්ට් සඳහා පහසු ක්රමයක් ප්රතිස්ථාපනය කිරීමයි git branch -d $fසමග echo "will delete $f".

මමත් එකතු කළ යුතු යැයි සිතමි: ඔබේම අවදානම භාවිතා කරන්න!

දුරස්ථව නොපවතින දේශීය ශාඛා මකා දැමීමට මම 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()

යමෙකු එය ප්‍රයෝජනවත් යැයි සිතයි, කරුණාකර මට කිසිවක් මග හැරුනේ නම් අදහස් එකතු කරන්න.

ඔබ ස්ථාපනය කර ඇති zshෂෙල් භාවිතා Oh My Zshකරන්නේ නම් මෙය ආරක්ෂිතව කිරීමට පහසුම ක්‍රමය වන්නේ ස්වයංක්‍රීයව සම්පුර්ණ කරන ලද ඒවා භාවිතා කිරීමයි.

ඔබට මැකීමට අවශ්‍ය ශාඛා මොනවාදැයි පළමුව තීරණය කරන්න:

~ git branch --merged

  branch1
  branch2
  branch3
* master

මෙය දැනටමත් ඒකාබද්ධ කළ ශාඛා ලැයිස්තුවක් ඔබට පෙන්වනු ඇත

ඔබට මැකීමට අවශ්‍ය කිහිපයක් දැනගත් පසු ටයිප් කරන්න:

~ git branch -d 

ඔබ කළ යුත්තේ [ටැබ්] යතුර ඔබන්න, එය ඔබට දේශීය ශාඛා ලැයිස්තුවක් පෙන්වනු ඇත. ටැබ් සම්පුර්ණ කරන්න හෝ නැවත [ටැබ්] ඔබන්න, එවිට ඔබට [ඇතුල් කරන්න] සමඟ ශාඛාවක් තෝරා ගැනීමට ඒවා හරහා ගමන් කළ හැකිය.

ටැබ් ඔබ මැකීමට කැමති ශාඛා ලැයිස්තුවක් ලැබෙන තුරු නැවත නැවතත් අතු තෝරන්න:

~ git branch -d branch1 branch2 branch3

දැන් ඔබේ ශාඛා එකතුව මකා දැමීමට enter ඔබන්න.

ඔබ ඔබේ පර්යන්තයේ zsh භාවිතා නොකරන්නේ නම් ... එය මෙතැනින් ලබා ගන්න.