Hapus cabang pelacakan tidak lagi di remote

Apakah ada cara sederhana untuk menghapus semua cabang pelacakan yang setara jarak jauh tidak ada lagi?

Contoh:

Cabang (lokal dan jarak jauh)

• menguasai
• asal / master
• origin / bug-fix-a
• origin / bug-fix-b
• origin / bug-fix-c

Secara lokal, saya hanya memiliki cabang master. Sekarang saya perlu mengerjakan perbaikan bug , jadi saya memeriksanya, mengerjakannya, dan mendorong perubahan ke remote. Selanjutnya saya melakukan hal yang sama dengan bug-fix-b .

Cabang (lokal dan jarak jauh)

• menguasai
• bug-fix-a
• bug-fix-b
• asal / master
• origin / bug-fix-a
• origin / bug-fix-b
• origin / bug-fix-c

Sekarang saya memiliki master cabang lokal , bug-fix-a , bug-fix-b . Pemelihara cabang Master akan menggabungkan perubahan saya menjadi master dan menghapus semua cabang yang telah digabung.

Jadi kondisi saat ini sekarang:

Cabang (lokal dan jarak jauh)

• menguasai
• bug-fix-a
• bug-fix-b
• asal / master
• origin / bug-fix-c

Sekarang saya ingin memanggil beberapa perintah untuk menghapus cabang (dalam hal ini bug-fix-a , bug-fix-b ), yang tidak lagi terwakili dalam repositori jarak jauh.

Itu akan menjadi sesuatu seperti perintah yang ada git remote prune origin, tetapi lebih seperti git local prune origin.

git remote prune origin cabang pelacakan cabang tidak pada remote.

git branch --merged daftar cabang yang telah digabung ke cabang saat ini.

xargs git branch -d menghapus cabang yang terdaftar pada input standar.

Hati-hati menghapus cabang yang terdaftar oleh git branch --merged. Daftar tersebut dapat menyertakan masteratau cabang lain yang Anda inginkan untuk tidak dihapus.

Untuk memberi diri Anda kesempatan untuk mengedit daftar sebelum menghapus cabang, Anda dapat melakukan hal berikut dalam satu baris:

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

Setelah perintah

git fetch -p

menghapus referensi jarak jauh, saat Anda menjalankan

git branch -vv

itu akan menunjukkan 'hilang' sebagai status jarak jauh. Sebagai contoh,

$ 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

Jadi, Anda dapat menulis skrip sederhana untuk menghapus cabang lokal yang menjadi remote:

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

Perhatikan bahwa di atas menggunakan perintah "porselen" git branchuntuk mendapatkan status upstream.

Cara lain untuk mendapatkan status ini adalah dengan menggunakan perintah "plumbing" git for-each-refdengan variabel interpolasi %(upstream:track), yang akan [gone]seperti di atas.

Pendekatan ini agak lebih aman, karena tidak ada risiko pencocokan secara tidak sengaja pada bagian dari pesan komit.

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

Sebagian besar jawaban ini sebenarnya tidak menjawab pertanyaan awal. Saya melakukan banyak penggalian dan ini adalah solusi terbersih yang saya temukan. Ini adalah versi yang sedikit lebih menyeluruh dari jawaban itu:

1. Periksa cabang default Anda. Biasanyagit checkout master
2. Lari git fetch -p && git branch -vv | awk '/: gone]/{print $1}' | xargs git branch -d

Penjelasan:

Bekerja dengan memangkas cabang pelacakan Anda kemudian menghapus yang lokal yang menunjukkan mereka "hilang" git branch -vv.

Catatan:

Jika bahasa Anda diatur ke sesuatu selain bahasa Inggris Anda perlu mengubah goneke kata yang sesuai. Cabang yang bersifat lokal saja tidak akan disentuh. Cabang yang telah dihapus pada jarak jauh tetapi tidak digabung akan menampilkan pemberitahuan tetapi tidak dihapus di lokal. Jika Anda ingin menghapus mereka juga berubah -dke -D.

Saya biasanya tidak akan menjawab pertanyaan yang sudah memiliki 16 jawaban, tetapi semua jawaban lainnya salah, dan jawaban yang benar sangat sederhana. Pertanyaannya mengatakan, "Apakah ada cara sederhana untuk menghapus semua cabang pelacakan yang setara jarak jauh tidak ada lagi?"

Jika "sederhana" berarti menghapus semuanya sekaligus, tidak rapuh, tidak berbahaya, dan tanpa bergantung pada alat yang tidak dimiliki semua pembaca, maka jawaban yang tepat adalah: tidak.

Beberapa jawaban sederhana, tetapi mereka tidak melakukan apa yang diminta. Yang lain melakukan apa yang diminta, tetapi tidak sederhana: semua bergantung pada penguraian output Git melalui perintah manipulasi teks atau bahasa scripting, yang mungkin tidak ada pada setiap sistem. Selain itu, sebagian besar saran menggunakan perintah porselen, yang outputnya tidak dirancang untuk diuraikan oleh skrip ("porselen" mengacu pada perintah yang dimaksudkan untuk operasi manusia; skrip harus menggunakan perintah "plumbing" tingkat rendah).

Bacaan lebih lanjut:

• mengapa Anda tidak perlu mem-parsing git branchoutput dalam skrip .
• pelacakan cabang dan perbedaan antara git remote prune, git prune,git fetch --prune

Jika Anda ingin melakukan ini dengan aman, untuk kasus penggunaan dalam pertanyaan (cabang pelacakan pengumpulan sampah yang telah dihapus di server tetapi masih ada sebagai cabang lokal) dan dengan perintah Git tingkat tinggi saja, Anda harus

• git fetch --prune(atau git fetch -p, yang merupakan alias, atau git prune remote originyang melakukan hal yang sama tanpa mengambil, dan mungkin bukan yang Anda inginkan sebagian besar waktu).
• Perhatikan semua cabang jarak jauh yang dilaporkan telah dihapus. Atau, untuk menemukannya nanti, git branch -v(cabang pelacakan yatim mana pun akan ditandai "[hilang]").
• git branch -d [branch_name] pada setiap cabang pelacakan yatim

(yang mana beberapa jawaban lain usulkan).

Jika Anda ingin membuat skrip solusi, maka for-each-refadalah titik awal Anda, seperti dalam jawaban Mark Longair di sini dan jawaban ini untuk pertanyaan lain , tapi saya tidak bisa melihat cara untuk mengeksploitasinya tanpa menulis loop skrip shell, atau menggunakan xargs atau sesuatu .

Penjelasan latar belakang

Untuk memahami apa yang terjadi, Anda perlu menghargai itu, dalam situasi pelacakan cabang, Anda tidak memiliki satu cabang, tetapi tiga. (Dan ingat bahwa "cabang" berarti hanya penunjuk ke komit.)

Diberikan cabang pelacakan feature/X, repositori jarak jauh (server) akan memiliki cabang ini dan menyebutnya feature/X. Repositori lokal Anda memiliki cabang remotes/origin/feature/Xyang artinya, "Ini adalah remote yang memberi tahu saya fitur / cabang X-nya, terakhir kali kami berbicara," dan akhirnya, repositori lokal memiliki cabang feature/Xyang menunjuk ke komit terbaru Anda, dan dikonfigurasikan ke "lacak" remotes/origin/feature/X, artinya Anda dapat menarik dan mendorong agar tetap selaras.

Pada titik tertentu, seseorang telah menghapus feature/Xdi remote. Sejak saat itu, Anda ditinggalkan dengan lokal Anda feature/X(yang mungkin Anda tidak mau lagi, karena bekerja pada fitur X mungkin selesai), dan Anda remotes/origin/feature/Xyang tentu saja tidak berguna karena satu-satunya tujuan adalah untuk mengingat keadaan cabang server .

Dan Git akan membiarkan Anda secara otomatis membersihkan yang mubazir remotes/origin/feature/X- itulah yang git fetch --pruneterjadi - tetapi untuk beberapa alasan, itu tidak memungkinkan Anda secara otomatis menghapus sendiri feature/X... meskipun Anda feature/Xmasih berisi informasi pelacakan yatim, sehingga ia memiliki informasi untuk mengidentifikasi bekas cabang pelacakan yang telah sepenuhnya digabung. (Lagi pula, itu dapat memberi Anda informasi yang memungkinkan Anda melakukan operasi sendiri.)

Saya menemukan jawabannya di sini: Bagaimana saya bisa menghapus semua cabang git yang telah digabung?

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

Pastikan kita tetap menguasai

Anda dapat memastikan bahwa master, atau cabang lain dalam hal ini, tidak bisa dihapus dengan menambahkan yang lain grepsetelah yang pertama. Dalam hal ini Anda akan pergi:

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

Jadi jika kita ingin tetap master, developdan stagingmisalnya, kita akan pergi:

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

Jadikan ini sebagai alias

Karena agak panjang, Anda mungkin ingin menambahkan alias ke .zshrcatau .bashrc. Tambang disebut gbpurge(untuk 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'

Kemudian muat ulang .bashrcatau .zshrc:

. ~/.bashrc

atau

. ~/.zshrc

Solusi Windows

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

Penjelasan

git checkout master beralih ke cabang master

git remote update origin --prune memangkas cabang-cabang terpencil

git branch -vvmendapat output verbose dari semua cabang ( referensi git )

Select-String -Pattern ": gone]" hanya mendapat catatan di mana mereka telah dihapus dari jarak jauh.

% { $_.toString().Trim().Split(" ")[0]} dapatkan nama cabang

% {git branch -d $_} menghapus cabang

Pencocokan pola untuk "hilang" di sebagian besar solusi lain agak menakutkan bagi saya. Agar lebih aman, ini menggunakan --formatbendera untuk mengeluarkan status pelacakan hulu masing-masing cabang .

Saya membutuhkan versi Windows-friendly, jadi ini menghapus semua cabang yang terdaftar sebagai "hilang" menggunakan Powershell:

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

Baris pertama mencantumkan nama cabang lokal yang cabang hulunya "hilang". Baris berikutnya menghapus baris kosong (yang merupakan output untuk cabang yang tidak "hilang"), maka nama cabang diteruskan ke perintah untuk menghapus cabang.

Hapus semua cabang yang telah digabungkan menjadi master, tetapi jangan mencoba untuk menghapus master itu sendiri:

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

atau tambahkan alias:

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

Penjelasan:

git checkout master checkout cabang utama

git pull origin master memastikan cabang lokal memiliki semua perubahan jarak jauh digabungkan

git fetch -p hapus referensi ke cabang jarak jauh yang telah dihapus

git branch -d $(git branch master --merged | grep master -v) hapus semua cabang yang telah digabungkan menjadi master, tetapi jangan mencoba untuk menghapus master itu sendiri

git fetch -p

Ini akan memangkas cabang apa pun yang tidak lagi ada di remote.

Namun-jawaban lain untuk tumpukan, menarik banyak dari jawaban Patrick (yang saya suka karena tampaknya menghilangkan ambiguitas tentang di mana gone]akan cocok digit branch output) tetapi menambahkan bengkok * nix.

Dalam bentuknya yang paling sederhana:

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

Saya sudah membungkus git-goneskrip ini di jalur saya:

#!/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 Opsi ini tampaknya cukup baru; Saya perlu memperbarui git dari 2.10.sesuatu ke 2.16.3 untuk mendapatkannya.

EDIT: tweak untuk memasukkan saran tentang refname:shortdari Benjamin W.

NB2 - Saya hanya diuji bash, maka hashbang, tapi mungkin portabel sh.

Mungkin bermanfaat untuk beberapa, satu baris sederhana untuk menghapus semua cabang lokal kecuali menguasai dan mengembangkan

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

Ini akan menghapus semua cabang lokal gabungan kecuali referensi master lokal dan yang saat ini sedang digunakan:

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

Dan ini akan menghapus semua cabang yang telah dihapus dari repositori jarak jauh yang dirujuk oleh " asal ", tetapi masih tersedia secara lokal di " remote / asal ".

git remote prune origin

Saya tidak berpikir ada perintah bawaan untuk melakukan ini, tetapi aman untuk melakukan hal berikut:

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

Saat Anda menggunakan -d, git akan menolak untuk menghapus cabang kecuali jika benar-benar digabungkan ke dalam HEADatau cabang pelacakan jarak jauh hulu. Jadi, Anda selalu dapat mengulangi keluaran git for-each-refdan mencoba menghapus setiap cabang. Masalah dengan pendekatan itu adalah saya menduga Anda mungkin tidak ingin bug-fix-ddihapus hanya karena origin/bug-fix-dberisi riwayatnya. Sebagai gantinya, Anda dapat membuat skrip sesuatu seperti berikut:

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

Peringatan: Saya belum menguji skrip ini - hanya gunakan dengan hati-hati ...

TL; DR:

Hapus SEMUA cabang lokal yang tidak pada jarak jauh

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

Hapus SEMUA cabang lokal yang tidak pada remote DAN yang sepenuhnya digabung DAN yang tidak digunakan seperti yang dikatakan dalam banyak jawaban sebelumnya.

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

Penjelasan

• git fetch -p akan memangkas semua cabang yang tidak lagi ada pada jarak jauh
• git branch -vv akan mencetak cabang lokal dan cabang yang dipangkas akan ditandai gone
• grep ': gone]' hanya memilih cabang yang hilang
• awk '{print $1}' filter output untuk hanya menampilkan nama cabang
• xargs git branch -D akan mengulang semua baris (cabang) dan memaksa menghapus cabang ini

Mengapa git branch -Ddan tidak git branch -dlain yang Anda miliki untuk cabang yang tidak sepenuhnya digabung.

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

Anda bisa melakukan ini:

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

Berdasarkan info di atas, ini bekerja untuk saya:

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

Ini menghapus semua cabang lokal dengan berada ': gone] 'di remote.

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

Perintah di atas dapat digunakan untuk mengambil cabang yang digabungkan dan dihapus dalam jarak jauh dan menghapus cabang lokal yang tidak lagi tersedia di jarak jauh

Tidak ada yang benar-benar cocok untuk saya. Saya menginginkan sesuatu yang akan membersihkan semua cabang lokal yang melacak cabang jarak jauh, pada origin, di mana cabang jarak jauh telah dihapus ( gone). Saya tidak ingin menghapus cabang lokal yang tidak pernah disetel untuk melacak cabang jarak jauh (yaitu: cabang dev lokal saya). Saya juga menginginkan satu baris sederhana yang hanya menggunakan git, atau alat CLI sederhana lainnya, daripada menulis skrip khusus. Saya akhirnya menggunakan sedikit grepdan awkuntuk membuat perintah sederhana ini.

Inilah yang akhirnya berakhir pada ~/.gitconfig:

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

Berikut adalah git config --global ...perintah untuk menambahkan ini dengan mudah 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'

CATATAN: Dalam perintah config, saya menggunakan -dopsi git branchdaripada -D, seperti yang saya lakukan pada konfigurasi aktual saya. Saya menggunakan -Dkarena saya tidak ingin mendengar Git mengeluh tentang ranting-ranting yang tidak terbakar. Anda mungkin menginginkan fungsi ini juga. Jika demikian, cukup gunakan -Dalih-alih -ddi akhir perintah konfigurasi itu.

Berdasarkan Tip Git: Menghapus Cabang Lokal Lama , yang terlihat mirip dengan solusi jason.rickman, saya menerapkan perintah khusus untuk tujuan ini yang disebut git menggunakan 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 menggabungkan pemangkasan dan daftar cabang "hilang":

$ 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

Kemudian Anda dapat menarik pelatuk menggunakan git gone -datau git gone -D.

Catatan

• Ekspresi reguler yang saya gunakan adalah di "$BRANCH/.*: gone]"mana $BRANCHbiasanya origin. Ini mungkin tidak akan berfungsi jika output Git Anda dilokalisasi ke bahasa Prancis dll.
• Sebastian Wiesner juga mengirim portalnya ke Rust untuk pengguna Windows. Yang itu juga disebut git hilang .

Menggambar berat dari sejumlah dari lainnya jawaban di sini, saya sudah berakhir dengan berikut (git 2.13 dan di atas saja, saya percaya), yang harus bekerja pada setiap UNIX-seperti shell:

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

Ini terutama menggunakan for-each-refalih-alih branch(seperti branchperintah "porselen" yang dirancang untuk keluaran yang dapat dibaca manusia, bukan pemrosesan mesin) dan menggunakan --shellargumennya untuk mendapatkan keluaran yang keluar dengan benar (ini memungkinkan kita untuk tidak khawatir tentang karakter apa pun dalam nama ref).

Namun jawaban lain, karena tidak ada solusi yang sesuai dengan kebutuhan saya tentang keanggunan dan lintas platform:

Perintah untuk menghapus cabang lokal tidak pada jarak jauh:

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

Untuk mengintegrasikannya dengan gitconfig sehingga dapat dijalankan dengan git branch-prune :

Pesta

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'

(Perlu bantuan dalam menemukan perintah universal untuk PowerShell dan bash)

Mengapa jawaban ini adalah yang terbaik?

• Menawarkan solusi lengkap: menambahkan a git branch-prune perintah ke git Anda
• Berfungsi dengan baik dari Windows PowerShell
• Ide inti @ jason.rickman 's metode antipeluru menggunakangit for-each-ref
• Parsing dan filtering dilakukan --filtertanpa ketergantungan eksternal

Penjelasan:

• Menambahkan alias baru ke blog Anda ~\.gitconfig . Setelah menjalankan ini, Anda cukup melakukannyagit branch-prune
• Di dalam alias ini:
  • Mengambil cabang dengan --prune bendera, yang "memangkas cabang pelacakan jarak jauh tidak lagi di jarak jauh"
  • Kegunaan git for-each-refdan --filter, untuk mendapatkan daftar cabang yang [gone]ada (tidak ada remote)
  • Loop melalui daftar ini dan menghapus cabang dengan aman

Saya datang dengan skrip bash ini. Selalu menjaga cabang 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
}

Saya menggunakan metode singkat untuk melakukan trik, saya sarankan Anda untuk melakukan hal yang sama karena dapat menghemat beberapa jam & memberi Anda lebih banyak visibilitas

Cukup tambahkan cuplikan berikut ke .bashrc Anda (.bashprofile di macos).

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

1. Ambil semua remote
2. Dapatkan hanya cabang gabungan dari git
3. Hapus dari daftar ini cabang "dilindungi / penting"
4. Buang sisanya (mis., Cabang yang bersih dan digabung)

Anda harus mengedit grep regex agar sesuai dengan kebutuhan Anda (di sini, itu mencegah master, preprod dan dmz dari penghapusan)

Ini bekerja untuk saya:

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

Saya tidak yakin untuk berapa lama, tapi saya menggunakan git-up sekarang, yang menangani itu.

Saya lakukan git updan itu mulai melacak cabang baru dan menghapus yang lama.

Hanya untuk membuatnya jelas, itu bukan perintah git out-of-box - https://github.com/aanand/git-up

BTW itu juga menyembunyikan pohon kotor dan membuat rebases masih dengan adil git up.

Semoga bermanfaat bagi seseorang

Inilah solusi yang saya gunakan untuk cangkang ikan. Diuji pada Mac OS X 10.11.5, fish 2.3.0dan 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

Beberapa catatan:

Pastikan untuk mengatur yang benar base_branch. Dalam hal ini saya gunakan developsebagai cabang dasar, tetapi bisa jadi apa saja.

Bagian ini sangat penting: grep -v "\(master\|$base_branch\|\*\)". Ini memastikan bahwa Anda tidak menghapus master atau cabang dasar Anda.

Saya menggunakan git branch -d <branch>sebagai tindakan pencegahan ekstra, agar tidak menghapus cabang apa pun yang belum sepenuhnya digabung dengan HEAD hulu atau saat ini.

Cara mudah untuk menguji adalah menggantinya git branch -d $fdengan echo "will delete $f".

Saya kira saya juga harus menambahkan: GUNAKAN RISIKO ANDA SENDIRI!

Saya telah menulis skrip Python menggunakan GitPython untuk menghapus cabang lokal yang tidak ada pada remote.

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

Semoga ada yang berguna, silakan tambahkan komentar jika saya melewatkan sesuatu.

Jika Anda menggunakan zshshell dengan Oh My Zshinstal maka cara termudah untuk melakukannya dengan aman adalah dengan menggunakan autocomplete bawaan.

Pertama-tama tentukan cabang mana yang ingin Anda hapus dengan:

~ git branch --merged

  branch1
  branch2
  branch3
* master

ini akan menampilkan daftar cabang yang sudah digabung

Setelah Anda tahu beberapa yang ingin Anda hapus lalu ketik:

~ git branch -d 

Yang harus Anda lakukan adalah menekan [tab] dan itu akan menampilkan daftar cabang lokal. Gunakan tab-complete atau tekan saja [tab] lagi dan Anda dapat memutarnya untuk memilih cabang dengan [enter].

Tab Pilih cabang berulang-ulang sampai Anda memiliki daftar cabang yang ingin Anda hapus:

~ git branch -d branch1 branch2 branch3

Sekarang cukup tekan enter untuk menghapus koleksi cabang Anda.

Jika Anda tidak menggunakan zsh di terminal Anda ... Dapatkan di sini.

Saya suka menggunakan pipa karena membuat perintah lebih mudah dibaca.

Ini solusi saya jika Anda ingin menghapus semua cabang kecuali master.

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

Untuk menghapus cabang lain yang cocok dengan kriteria Anda, modifikasi blok pertama dan kedua.

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

Inilah jawaban sederhana yang bekerja untuk saya menggunakan klien git:

Hapus repositori sama sekali dari mesin Anda kemudian periksa lagi.

Jangan main-main dengan skrip yang berisiko.