Видаліть гілки відстеження більше не на віддаленому

Чи є простий спосіб видалити всі гілки відстеження, віддаленого еквівалента яких більше немає?

Приклад:

Відділення (місцеві та віддалені)

• майстер
• походження / майстер
• походження / помилка-виправлення
• походження / помилка-виправлення-b
• походження / помилка-виправлення-c

Місцево я маю лише головну галузь. Тепер мені потрібно працювати над bug-fix-a , тому я перевіряю це, працюю над ним і натискаю зміни на пульт. Далі я те ж саме роблю з bug-fix-b .

Відділення (місцеві та віддалені)

• майстер
• помилка-виправлення-а
• помилка-виправлення-б
• походження / майстер
• походження / помилка-виправлення
• походження / помилка-виправлення-b
• походження / помилка-виправлення-c

Тепер у мене є місцеві філії майстер , баг-фікс-а , баг-фікс-б . Підтримувач гілки Master об'єднає мої зміни в головний і видалить усі гілки, які він уже об'єднав.

Отже, теперішній стан зараз:

Відділення (місцеві та віддалені)

• майстер
• помилка-виправлення-а
• помилка-виправлення-б
• походження / майстер
• походження / помилка-виправлення-c

Тепер я хотів би викликати якусь команду для видалення гілок (у цьому випадку bug-fix-a , bug-fix-b ), які більше не представлені у віддаленому сховищі.

Це було б щось на зразок існуючої команди 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 відповідей, але всі інші відповіді неправильні, а правильна відповідь така проста. Питання говорить: "Чи існує простий спосіб видалити всі гілки відстеження, віддаленого еквівалента яких більше немає?"

Якщо "просте" означає видалити їх усі за один раз, не тендітні, не небезпечні та без опори на інструменти, які не всі читачі матимуть, то правильна відповідь: ні.

Деякі відповіді прості, але вони не роблять того, що було запропоновано. Інші роблять те, що було запропоновано, але це не просто: усі покладаються на аналіз 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що означає: "Це те, що віддалений сказав мені, що його особливість / 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

Рішення для Windows

Для Microsoft Windows Powershell:

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

Select-String -Pattern ": gone]" отримує лише записи, з яких вони були видалені з віддаленого.

% { $_.toString().Trim().Split(" ")[0]} отримати назву філії

% {git branch -d $_} видаляє гілку

Відповідність шаблону "відпала" у більшості інших рішень була для мене трохи страшною. Щоб бути більш безпечним, для цього використовується --formatпрапор, щоб витягнути стан відстеження кожної гілки .

Мені потрібна зручна для Windows версія, тому це видаляє всі гілки, які вказані як "пішли" за допомогою Powershell:

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

У першому рядку перелічено назву локальних гілок, гілка яких за течією "пішла". Наступний рядок видаляє порожні рядки (які виводяться для гілок, які не "пішли"), потім ім'я гілки передається команді для видалення гілки.

Видаліть усі гілки, які були об'єднані в master, але не намагайтеся видалити сам master:

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) видаліть усі гілки, які були об'єднані в головний, але не намагайтеся видалити сам master

git fetch -p

Це обріже будь-які гілки, яких більше немає на віддаленому.

Ще одна відповідь на купу, сильно виходячи з відповіді Патріка (що мені подобається, тому що, здається, усуває будь-яку неоднозначність щодо того, де gone]буде відповідати вgit branch результат), але додаючи зігнуту * nix.

У своєму найпростішому вигляді:

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 "${@}"

NB - The --format варіант здається досить новим; Мені потрібно було оновити git з 2.10.щось до 2.16.3, щоб отримати його.

EDIT: налаштовано, щоб включити пропозиції щодо refname:shortвід Benjamin W.

NB2 - Я протестував лише bash, отже, хешбанг, але, ймовірно, портативний sh.

Можливо, буде корисним деякий, простий один рядок, щоб очистити всі локальні гілки, окрім майстра та розвитку

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

Це видалить усі об'єднані локальні розгалуження, крім локальної основної посилання та тієї, що використовується зараз:

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

І це видалить усі гілки, які вже були вилучені з віддаленого сховища, на яке посилається " походження ", але все ще є локально доступними в " віддалених / вихідних ".

git remote prune origin

Я не думаю, що для цього є вбудована команда, але безпечно робити наступне:

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

Попередження: Я не перевіряв цей сценарій - використовуйте лише обережно ...

TL; DR:

Видаліть ВСІ локальні гілки, які не є віддаленими

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

На підставі інформації вище, це працювало для мене:

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або інші прості інструменти CLI, а не писати спеціальні сценарії. Я в кінцевому рахунку використовував трохи 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'

ПРИМІТКА. У команді config я використовую -dпараметр, git branchа не -Dяк у моїй фактичній конфігурації. Я використовую, -Dтому що я не хочу чути, як Git скаржиться на незанурені гілки. Можливо, ви хочете і цю функціональність. Якщо так, просто використовуйте -Dзамість -dцього кінця команду config.

На основі Git Tip: Видалення старих локальних гілок , схоже на рішення Jason.rickman, я реалізував для цієї мети спеціальну команду під назвою git gone за допомогою Bash:

$ 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 локалізований на французькій мові тощо.
• Себастьян Віснер також переніс його на Rust для користувачів Windows. Таку ще називають git gone .

Маючи на увазі велику кількість низки інших відповідей , я закінчив наступне (я вважаю, git 2.13 і вище лише), який повинен працювати на будь-якій оболонці, схожій на UNIX:

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аргумент, щоб отримати правильний вихід (це дозволяє нам не турбуватися про будь-який символ у назві посилання).

Ще одна відповідь, тому що жодне з рішень не відповідає моїм потребам щодо елегантності та крос-платформності:

Команда видалити локальні гілки не на віддаленому:

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'

PowerShell

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](без віддалених)
  • Прокручує цей список і безпечно видаляє гілку

Я придумав цей сценарій баш. Вона завжди тримати гілки 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 в 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. Отримайте лише злиті гілки від git
3. Видаліть із цього списку гілки "захищених / важливих"
4. Видаліть решту (наприклад, чисті та злиті гілки)

Вам доведеться відредагувати grege regex, щоб відповідати вашим потребам (тут це запобігає видаленню master, prepredd та dmz)

Це працювало для мене:

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-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>в якості додаткової обережності, щоб не видалити будь-яку гілку, яка не була повністю злита з поточною або поточною HEAD.

Простий спосіб перевірки - замінити git branch -d $fна echo "will delete $f".

Я припускаю, що я також повинен додати: ВИКОРИСТОВУЙТЕ ВАШ ВЛАСНИЙ РИЗИК!

Я написав сценарій Python за допомогою 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 

Все, що вам потрібно зробити, це натиснути [вкладку], і він покаже вам список місцевих гілок. Скористайтеся вкладкою або просто натисніть [вкладку] ще раз, і ви можете перейти через них, щоб вибрати гілку за допомогою [enter].

Вкладка Виберіть гілки знову і знову, поки у вас не з’явиться список гілок, які ви бажаєте видалити:

~ git branch -d branch1 branch2 branch3

Тепер просто натисніть клавішу Enter, щоб видалити колекцію гілок.

Якщо ви не використовуєте zsh на своєму терміналі ... Отримайте його тут.

Мені подобається використовувати труби, тому що це полегшує читання команди.

Це моє рішення, якщо ви хочете видалити всі гілки, крім головного.

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

Щоб видалити інші гілки, які відповідають вашим критеріям, змініть перший і другий блоки.

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

Ось простий відповідь, який працював на мене за допомогою клієнта git:

Видаліть сховище повністю зі свого комп'ютера, а потім перевірте ще раз.

Немає спілкування з ризикованими сценаріями.