Lista nazw gałęzi git, uporządkowanych przez najnowszy commit ...

rozszerzając odpowiedź Jakuba i wskazówkę Joego, poniżej usuniemy " refs / heads/", więc wyjście wyświetli tylko nazwy gałęzi:

Polecenie:

git for-each-ref --count=30 --sort=-committerdate refs/heads/ --format='%(refname:short)'

Wynik:

Oto optymalny kod, który łączy dwie pozostałe odpowiedzi:

git for-each-ref --sort=-committerdate refs/heads/ --format='%(committerdate:short) %(authorname) %(refname:short)'

Oto proste polecenie, które wyświetla listę wszystkich gałęzi z najnowszymi commitami:

git branch -v

Aby zamówić najnowszy commit, użyj

git branch -v --sort=committerdate

Źródło: http://git-scm.com/book/en/Git-Branching-Branch-Management

Używam następującego aliasu:

recent = "!r(){git for-each-ref --sort=-committerdate refs/heads --format='%(HEAD)%(color:yellow)%(refname:short)|%(color:bold green)%(committerdate:relative)|%(color:blue)%(subject)|%(color:magenta)%(authorname)%(color:reset)'|column -ts'|'}; r"

Który wytwarza:

Edit: use | / ' to separate, thanks to @ Björn Lindqvist

Update: Dodano * przed bieżącą gałęzią, dzięki @elhadi
Edit: Naprawiono przypadek, w którym bieżąca gałąź była podłańcuchem innej gałęzi

Edit: użyj prostszej składni dla bieżącej gałęzi, dzięki @ Joshua Skrzypek

Potrzebowałem również kolorów, znaczników i zdalnych odniesień bez duplikatów:

for ref in $(git for-each-ref --sort=-committerdate --format="%(refname)" refs/heads/ refs/remotes ); do git log -n1 $ref --pretty=format:"%Cgreen%cr%Creset %C(yellow)%d%Creset %C(bold blue)<%an>%Creset%n" | cat ; done | awk '! a[$0]++'

Ponieważ cytowanie może być trudne, tutaj alias dla Basha:

alias glist='for ref in $(git for-each-ref --sort=-committerdate --format="%(refname)" refs/heads/ refs/remotes ); do git log -n1 $ref --pretty=format:"%Cgreen%cr%Creset %C(yellow)%d%Creset %C(bold blue)<%an>%Creset%n" | cat ; done | awk '"'! a["'$0'"]++'"

Inne odpowiedzi nie pozwalają przekazać -vv, Aby uzyskać szczegółowy wynik.

Oto jednolinijkowy, który sortuje git branch -vv według daty zatwierdzenia, zachowując kolor itp.:

git branch -vv --color=always | while read; do echo -e $(git log -1 --format=%ct $(echo "_$REPLY" | awk '{print $2}' | perl -pe 's/\e\[?.*?[\@-~]//g') 2> /dev/null || git log -1 --format=%ct)"\t$REPLY"; done | sort -r | cut -f 2

Jeśli dodatkowo chcesz wydrukować datę zatwierdzenia, możesz użyć tej wersji:

git branch -vv --color=always | while read; do echo -e $(git log -1 --format=%ci $(echo "_$REPLY" | awk '{print $2}' | perl -pe 's/\e\[?.*?[\@-~]//g') 2> /dev/null || git log -1 --format=%ci)" $REPLY"; done | sort -r | cut -d ' ' -f -1,4-

Przykładowe wyjście:

2013-09-15   master                  da39a3e [origin/master: behind 7] Some patch
2013-09-11 * (detached from 3eba4b8) 3eba4b8 Some other patch
2013-09-09   my-feature              e5e6b4b [master: ahead 2, behind 25] WIP

Jest prawdopodobnie bardziej czytelny podzielony na wiele linii:

git branch -vv --color=always | while read; do
    # The underscore is because the active branch is preceded by a '*', and
    # for awk I need the columns to line up. The perl call is to strip out
    # ansi colors; if you don't pass --color=always above you can skip this
    local branch=$(echo "_$REPLY" | awk '{print $2}' | perl -pe 's/\e\[?.*?[\@-~]//g')
    # git log fails when you pass a detached head as a branch name.
    # Hide the error and get the date of the current head.
    local branch_modified=$(git log -1 --format=%ci "$branch" 2> /dev/null || git log -1 --format=%ci)
    echo -e "$branch_modified $REPLY"
# cut strips the time and timezone columns, leaving only the date
done | sort -r | cut -d ' ' -f -1,4-

Powinno to działać również z innymi argumentami git branch, np. -vvr do listy zdalnego śledzenia branches, or -vva to list both remote-tracking and local branches.

Udało mi się przywołać powyższe przykłady, aby stworzyć coś, co działa najlepiej dla mnie.

Git for-each-ref --sort= - committerdate refs / heads/ --format='%(authordate:short) %(color:red)%(objectname:short) %(color:yellow) % (refname: short)%(Color: reset) (%(color: green)%(committerdate: relative)%(color: reset)) '

Lubię używać daty względnej i skracać nazwę gałęzi w następujący sposób:

git for-each-ref --sort='-authordate:iso8601' --format=' %(authordate:relative)%09%(refname:short)' refs/heads

Co daje wynik:

21 minutes ago  nathan/a_recent_branch
6 hours ago     master
27 hours ago    nathan/some_other_branch
29 hours ago    branch_c
6 days ago      branch_d

Zalecam utworzenie pliku bash, aby dodać wszystkie ulubione aliasy, a następnie udostępnić skrypt swojemu zespołowi. Oto przykład, aby dodać tylko ten jeden:

#!/bin/sh

git config --global alias.branches "!echo ' ------------------------------------------------------------' && git for-each-ref --sort='-authordate:iso8601' --format=' %(authordate:relative)%09%(refname:short)' refs/heads && echo ' ------------------------------------------------------------'"

Następnie możesz to zrobić, aby uzyskać ładnie sformatowaną i posortowaną listę lokalnych gałęzi:

git branches

Update: Zrób to, jeśli chcesz kolorować:

#!/bin/sh
#
(echo ' ------------------------------------------------------------‌​' && git for-each-ref --sort='-authordate:iso8601' --format=' %(authordate:relative)%09%(refname:short)' refs/heads && echo ' ------------------------------------------------------------‌​') | grep --color -E "$(git rev-parse --abbrev-ref HEAD)$|$"

Git 2.7 (Q4 2015) wprowadzi sortowanie gałęzi używając bezpośrednio git branch:
Zobacz commit aa3bc55, commit aedcb7d, / align = "left" / 1511b22, commit f65f139,... (23 wrz 2015), commit aedcb7d, / align = "left" / 1511b22, commit ca41799 (24 Sep 2015), and commit f65f139, ... (23 wrz 2015) by Karthik Nayak (KarthikNayak).
^{(dodany przez Junio C Hamano -- gitster -- in commit 7f11b48 , 15 paź 2015)}

W szczególności commit aedcb7d :

branch.c: użyj "ref-filter " API

Make ' branch.c' use 'ref-filter' API do iteracji poprzez sortowanie refs. Usuwa to większość kodu używanego w 'branch.c', zastępując go z wywołaniami do biblioteki " ref-filter".

To dodaje opcję --sort=<key>:

Sortowanie na podstawie podanego klucza.
Prefiks - do sortowania w kolejności malejącej wartości.

Możesz użyć opcja --sort=<key> wiele razy, w tym przypadku ostatni klucz staje się kluczem głównym.

Obsługiwane są klucze takie same jak w git for-each-ref.
Kolejność sortowania jest domyślnie sortowana na podstawie pełnej nazwy ref (wraz z prefiksem refs/...). Wyświetla najpierw odłączoną głowicę (jeśli jest obecna), następnie lokalne gałęzie i wreszcie gałęzie zdalnego śledzenia.

Tutaj:

git branch --sort=-committerdate 

Zobacz także commit 9e46833 (30 paź 2015) by Karthik Nayak (KarthikNayak).
Help-by: Junio C Hamano (gitster).
^{(dodany przez Junio C Hamano -- gitster -- in commit 415095f, 03 Nov 2015)}

Podczas sortowania według wartości liczbowych (np. --sort=objectsize) Nie ma porównania awaryjnego, gdy oba ref mają tę samą wartość. Może to spowodować nieoczekiwane wyniki (tzn. kolejność wyświetlania refów o równych wartościach nie może być wstępnie określona), jak wskazał Johannes Sixt ($gmane/280117).

Stąd, powrót do porównania alfabetycznego na podstawie refname ilekroć inne kryterium jest równe .

$ git branch --sort=objectsize

*  (HEAD detached from fromtag)
      branch-two
      branch-one
      master

W Git 2.19, kolejność sortowania może być ustawiona domyślnie.
git branch obsługuje konfigurację branch.sort, Jak git tag, która miała już konfigurację tag.sort.
Zobacz commit 560ae1c (16 sierpnia 2018) by Samuel Maftoul (`).
^{(dodany przez Junio C Hamano -- gitster -- in commit d89db6f, 27 Aug 2018)}

branch.sort:

Ta zmienna kontroluje kolejność sortowania gałęzi wyświetlanych przez git-branch.
Bez podanej opcji "--sort=<value> " wartość tej zmiennej będzie używana jako wartość domyślna.

Dodaje trochę koloru (ponieważ pretty-format nie jest dostępna)

[alias]
    branchdate = for-each-ref --sort=-committerdate refs/heads/ --format="%(authordate:short)%09%(objectname:short)%09%1B[0;33m%(refname:short)%1B[m%09"

Miałem ten sam problem, więc napisałem rubinowy klejnot o nazwie Gałązka . Listuje gałęzie w porządku chronologicznym (najpierw Najnowsze), a także pozwala ustawić maksymalny wiek, aby nie wyświetlać wszystkich gałęzi (jeśli masz ich dużo). Na przykład:

$ twig

                              issue  status       todo            branch
                              -----  ------       ----            ------
2013-01-26 18:00:21 (7m ago)  486    In progress  Rebase          optimize-all-the-things
2013-01-26 16:49:21 (2h ago)  268    In progress  -               whitespace-all-the-things
2013-01-23 18:35:21 (3d ago)  159    Shipped      Test in prod  * refactor-all-the-things
2013-01-22 17:12:09 (4d ago)  -      -            -               development
2013-01-20 19:45:42 (6d ago)  -      -            -               master

Pozwala również przechowywać niestandardowe właściwości dla każdej gałęzi, np. identyfikator zgłoszenia, status, todos i filtrować listę gałęzi zgodnie z tymi właściwościami. Więcej informacji: http://rondevera.github.io/twig/

Wymyśliłem następujące polecenie (dla Git 2.13 i późniejszych):

git branch -r --sort=creatordate \
    --format "%(creatordate:relative);%(committername);%(refname:lstrip=-1)" \
    | grep -v ";HEAD$" \
    | column -s ";" -t

Jeśli nie masz column możesz zastąpić ostatnią linię

    | sed -e "s/;/\t/g"

Wyjście wygląda jak

6 years ago             Tom Preston-Werner  book
4 years, 4 months ago   Parker Moore        0.12.1-release
4 years ago             Matt Rogers         1.0-branch
3 years, 11 months ago  Matt Rogers         1.2_branch
3 years, 1 month ago    Parker Moore        v1-stable
12 months ago           Ben Balter          pages-as-documents
10 months ago           Jordon Bedwell      make-jekyll-parallel
6 months ago            Pat Hawks           to_integer
5 months ago            Parker Moore        3.4-stable-backport-5920
4 months ago            Parker Moore        yajl-ruby-2-4-patch
4 weeks ago             Parker Moore        3.4-stable
3 weeks ago             Parker Moore        rouge-1-and-2
19 hours ago            jekyllbot           master

Napisałem post na blogu o tym, jak działają różne utwory.

Dla twojej wiadomości, Jeśli chcesz uzyskać listę ostatnio sprawdzonych gałęzi (w przeciwieństwie do ostatnio zatwierdzonych) możesz użyć reflog Gita:

$ git reflog | egrep -io "moving from ([^[:space:]]+)" | awk '{ print $3 }' | head -n5
master
stable
master
some-cool-feature
feature/improve-everything

Zobacz także: Jak mogę uzyskać listę gałęzi git, które ostatnio sprawdziłem?

Oto kolejny skrypt, który robi to, co wszystkie inne skrypty. W rzeczywistości zapewnia funkcję dla powłoki.

Jego wkład polega na tym, że pobiera niektóre kolory z twojego Git config(lub używa domyślnych).

# Git Branch by Date
# Usage: gbd [ -r ]
gbd() {
    local reset_color=`tput sgr0`
    local subject_color=`tput setaf 4 ; tput bold`
    local author_color=`tput setaf 6`

    local target=refs/heads
    local branch_color=`git config --get-color color.branch.local white`

    if [ "$1" = -r ]
    then
        target=refs/remotes/origin
        branch_color=`git config --get-color color.branch.remote red`
    fi

    git for-each-ref --sort=committerdate $target --format="${branch_color}%(refname:short)${reset_color} ${subject_color}%(subject)${reset_color} ${author_color}- %(authorname) (%(committerdate:relative))${reset_color}"
}

Na podstawie wersji iliusa, ale z bieżącą gałęzią pokazaną z gwiazdą i kolorem, i pokazującą tylko wszystko, co nie jest opisane jako "miesiące " lub" lata " temu: {]}

current_branch="$(git symbolic-ref --short -q HEAD)"
git for-each-ref --sort=committerdate refs/heads \
  --format='%(refname:short)|%(committerdate:relative)' \
  | grep -v '\(year\|month\)s\? ago' \
  | while IFS='|' read branch date
    do
      start='  '
      end=''
      if [[ $branch = $current_branch ]]; then
        start='* \e[32m'
        end='\e[0m'
      fi
      printf "$start%-30s %s$end\\n" "$branch" "$date"
    done

Oto mały skrypt, którego używam do przełączania między ostatnimi gałęziami:

#!/bin/bash
# sudo bash

re='^[0-9]+$'

if [[ "$1" =~ $re ]]; then
    lines="$1"
else
    lines=10
fi
branchs="$(git recent | tail -n $lines | nl)"
branchs_nf="$(git recent-nf | tail -n $lines | nl)"
echo "$branchs"

# Prompt which server to connect to
max="$(echo "$branchs" | wc -l)"
index=
while [[ ! ( "$index" =~ ^[0-9]+$ && "$index" -gt 0 && "$index" -le "$max" ) ]]; do
    echo -n "Checkout to: " 
    read index
done

branch="$( echo "$branchs_nf" | sed -n "${index}p" | awk '{ print $NF }' )"
git co $branch
clear

Używanie tych dwóch aliasów

recent = for-each-ref --sort=committerdate refs/heads/ --format=' %(color:blue) %(authorname) %(color:yellow)%(refname:short)%(color:reset)'
recent-nf = for-each-ref --sort=committerdate refs/heads/ --format=' %(authorname) %(refname:short)'

Po prostu wywołaj to w Git repo, a wyświetli Ci Ostatnie N gałęzi (domyślnie 10) i liczbę obok każdej. Wprowadź numer oddziału i sprawdza się:

Od wersji git 2.19 możesz po prostu:

git config --global branch.sort -committerdate

Tak więc, ilekroć wylistujesz gałęzie, będą one sortowane według daty zatwierdzenia.

Disclaimer: jestem autorem tej funkcji w git, zaimplementowałem ją, gdy zobaczyłem to pytanie.

Mój najlepszy wynik jako scenariusz:

git for-each-ref --sort=-committerdate refs/heads/ --format='%(refname:short)|%(committerdate:iso)|%(authorname)' |
    sed 's/refs\/heads\///g' |
    grep -v BACKUP  | 
    while IFS='|' read branch date author
    do 
        printf '%-15s %-30s %s\n' "$branch" "$date" "$author"
    done

Oto odmiana, której szukałem:

git for-each-ref --sort=-committerdate --format='%(committerdate)%09%(refname:short)' refs/heads/ | tail -r

To tail -r odwraca listę tak, aby ostatnia commiterdate była ostatnia.

Spóźnienie na imprezę tutaj. Zaakceptowana odpowiedź CML rządzi, ale jeśli chcesz coś ładniejszego, jak GUI, a twoje pochodzenie = = = "github".

Możesz kliknąć "Branches" w repo. lub wpisz adres URL bezpośrednio: https://github.com/ORGANIZATION_NAME/REPO_NAME/branches

Przesyłam wyjście z zaakceptowanej odpowiedzi do dialog, aby dać mi interaktywną listę:

#!/bin/bash

TMP_FILE=/tmp/selected-git-branch

eval `resize`
dialog --title "Recent Git Branches" --menu "Choose a branch" $LINES $COLUMNS $(( $LINES - 8 )) $(git for-each-ref --sort=-committerdate refs/heads/ --format='%(refname:short) %(committerdate:short)') 2> $TMP_FILE

if [ $? -eq 0 ]
then
    git checkout $(< $TMP_FILE)
fi

rm -f $TMP_FILE

clear

Zapisz jako (np.) ~/bin/git_recent_branches.sh i chmod +x to. Następnie git config --global alias.rb '!git_recent_branches.sh' dać mi nową komendę git rb.

git for-each-ref --sort=committerdate refs/heads/ --format='%(HEAD) %(color:yellow)%(refname:short)%(color:reset) - %(color:red)%(objectname:short)%(color:reset) - %(contents:subject) - %(authorname) (%(color:green)%(committerdate:relative)%(color:reset))' this is that you need

Git v2. 19 wprowadza opcję konfiguracji branch.sort (Zobacz gałąź .sort ).

Więc git branch będzie sortować według daty zatwierdzenia (desc) domyślnie przez

# gitconfig
[branch]
    sort = -committerdate     # desc

Skrypt:

$ git config --global branch.sort -committerdate