Ich möchte eine Liste aller Zweige in einem Git-Repository mit den "frischesten" Zweigen oben erhalten, wobei der "frischeste" Zweig derjenige ist, für den zuletzt festgelegt wurde (und daher eher einer ist Ich möchte darauf achten).

Gibt es eine Möglichkeit, mit Git entweder (a) die Liste der Zweige nach dem letzten Festschreiben zu sortieren oder (b) eine Liste der Zweige zusammen mit dem Datum des letzten Festschreibens in einem maschinenlesbaren Format abzurufen?

Im schlimmsten Fall konnte ich immer git brancheine Liste aller Zweige abrufen, deren Ausgabe analysieren und dann git log -n 1 branchname --format=format:%cifür jeden das Festschreibungsdatum jedes Zweigs ermitteln. Dies läuft jedoch auf einer Windows-Box, auf der das Hochfahren eines neuen Prozesses relativ teuer ist. Daher kann das Starten der ausführbaren Git-Datei einmal pro Zweig langsam werden, wenn viele Zweige vorhanden sind. Gibt es eine Möglichkeit, dies alles mit einem einzigen Befehl zu tun?

Verwenden Sie die --sort=-committerdateOption git for-each-ref;

Auch verfügbar seit Git 2.7.0 für git branch:

Grundlegende Verwendung:

git for-each-ref --sort=-committerdate refs/heads/

# Or using git branch (since version 2.7.0)
git branch --sort=-committerdate  # DESC
git branch --sort=committerdate  # ASC

Ergebnis:

Erweiterte Verwendung:

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

Ergebnis:

Liste der Git-Filialnamen, sortiert nach dem letzten Commit…

Wenn Sie Jakubs Antwort und Joes Tipp erweitern , werden im Folgenden die "refs / Heads /" entfernt, sodass in der Ausgabe nur die Zweignamen angezeigt werden:

Befehl:

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

Ergebnis:

Hier ist der optimale Code, der die beiden anderen Antworten kombiniert:

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

Hier ist ein einfacher Befehl, der alle Zweige mit den neuesten Commits auflistet:

git branch -v

Verwenden Sie, um nach dem letzten Commit zu bestellen

git branch -v --sort=committerdate

Quelle: http://git-scm.com/book/en/Git-Branching-Branch-Management

Ich benutze den folgenden Alias:

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"

welches produziert:

Verwenden Sie '|' zu trennen.

Ich konnte auf die vorherigen Beispiele verweisen, um etwas zu erstellen, das für mich am besten funktioniert.

git for-each-ref --sort = -committerdate refs / Heads / --format = '% (Authordate: Short)% (Farbe: Rot)% (Objektname: Short)% (Farbe: Gelb)% (Refname: Short) )% (Farbe: Zurücksetzen) (% (Farbe: Grün)% (Committerdate: Relativ)% (Farbe: Zurücksetzen)) '

Ich brauchte auch Farben, Tags und Fernreferenzen ohne Duplikate:

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]++'

Da das Zitieren schwierig sein kann, ist hier der Alias ​​für Bash:

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'"]++'"

Die anderen Antworten scheinen es nicht zuzulassen -vv, dass eine ausführliche Ausgabe erfolgt.

Hier ist also ein Einzeiler, der nach Festschreibungsdatum sortiert git branch -vv, Farbe beibehält usw.:

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

Wenn Sie zusätzlich das Festschreibungsdatum drucken möchten, können Sie stattdessen diese Version verwenden:

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-

Beispielausgabe:

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

Es ist wahrscheinlich besser lesbar, aufgeteilt in mehrere Zeilen:

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-

Dies sollte auch mit anderen Argumenten funktionieren git branch, z. B. -vvrum Fernverfolgungszweige aufzulisten oder -vvaum sowohl Fernverfolgungszweige als auch lokale Zweige aufzulisten.

2.7 git (Q4 2015) einführen wird Zweig mit Sortierung direkt git branch:
Siehe begehen aa3bc55 , begehen aedcb7d , begehen 1511b22 , begehen f65f139 , ... (23. September 2015), verpflichten aedcb7d , begehen 1511b22 , begehen ca41799 (24. September 2015) und Commit f65f139 , ... (23. September 2015) von Karthik Nayak ( KarthikNayak) .
^{(Zusammengeführt von Junio ​​C Hamano - gitster- in Commit 7f11b48 , 15. Oktober 2015)}

Legen Sie insbesondere aedcb7d fest :

branch.c: Verwenden Sie ' ref-filter' APIs

Make ‚ branch.c‘ Nutzung ‚ ref-filter‘ APIs für das Iterieren durch Sortierung Refs. Dadurch wird der größte Teil des Codes entfernt, der beim branch.cErsetzen durch Aufrufe der ref-filterBibliothek verwendet wird.

Es fügt die Option hinzu--sort=<key> :

Sortieren Sie nach dem angegebenen Schlüssel.
Präfix -zum Sortieren in absteigender Reihenfolge des Werts.

Sie können die --sort=<key>Option mehrmals verwenden. In diesem Fall wird der letzte Schlüssel zum Primärschlüssel.

Die unterstützten Schlüssel sind die gleichen wie ingit for-each-ref .
Die Sortierreihenfolge erfolgt standardmäßig nach dem vollständigen Referenznamen (einschließlich refs/...Präfix). Hier werden zuerst der getrennte HEAD (falls vorhanden), dann die lokalen Zweige und schließlich die Fernverfolgungszweige aufgelistet.

Hier:

git branch --sort=-committerdate 

Oder (siehe unten mit Git 2.19)

# if you are sure to /always/ want to see branches ordered by commits:
git config --global branch.sort -committerdate
git branch

Siehe auch Commit 9e46833 (30. Oktober 2015) von Karthik Nayak ( KarthikNayak) .
Mit freundlichergitster Unterstützung von Junio ​​C Hamano ( ) .
^{(Zusammengeführt von Junio ​​C Hamano - gitster- in Commit 415095f , 3. November 2015)}

Beim Sortieren nach numerischen Werten (z. B. --sort=objectsize) gibt es keinen Fallback-Vergleich, wenn beide Refs den gleichen Wert haben. Dies kann zu unerwarteten Ergebnissen führen (dh die Reihenfolge der Auflistung von Refs mit gleichen Werten kann nicht vorbestimmt werden), wie von Johannes Sixt ( $ gmane / 280117 ) ausgeführt.

Daher wird auf den alphabetischen Vergleich basierend auf dem Referenznamen zurückgegriffen, wenn das andere Kriterium gleich ist .

$ git branch --sort=objectsize

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

Mit Git 2.19 kann die Sortierreihenfolge standardmäßig festgelegt werden.
git branchunterstützt eine Konfiguration branch.sortwie git tag, die bereits eine Konfiguration hatte tag.sort.
Siehe Commit 560ae1c (16. August 2018) von Samuel Maftoul (``) .
^{(Zusammengeführt von Junio ​​C Hamano - gitster- in Commit d89db6f , 27. August 2018)}

branch.sort:

Diese Variable steuert die Sortierreihenfolge der Zweige, wenn sie von angezeigt wird git-branch.
Ohne die --sort=<value>Option " " wird der Wert dieser Variablen als Standard verwendet.

Verwenden Sie zum Auflisten entfernter Zweige git branch -r --sort=objectsize. Das -rFlag bewirkt, dass entfernte Zweige anstelle lokaler Zweige aufgelistet werden.

Mit Git 2.27 (Q2 2020) akzeptierten " git branch" und andere " for-each-ref" Varianten mehrere --sort=<key>Optionen in aufsteigender Rangfolge, es gab jedoch einige --ignore-caseFehler bei der Handhabung und beim Brechen des Referenznamens, die behoben wurden.

Siehe Commit 7c5045f , Commit 76f9e56 (03. Mai 2020) von Jeff King ( peff) .
^{(Zusammengeführt von Junio ​​C Hamano - gitster- in Commit 6de1630 , 08. Mai 2020)}

ref-filter: Fallback-Refname-Sortierung erst nach allen Benutzersortierungen anwenden

^{Unterzeichnet von: Jeff King}

Commit 9e468334b4 (" ref-filter: Fallback beim alphabetischen Vergleich", 30.10.2015, Git v2.7.0-rc0 - Zusammenführung in Stapel 10 aufgeführt ) hat die Sortierung des Ref-Filters zum Fallback zum Vergleichen von Refnames gelehrt.
Aber es hat es auf der falschen Ebene gemacht und das Vergleichsergebnis für einen einzelnen " --sort" Schlüssel des Benutzers überschrieben , anstatt nachdem alle Sortierschlüssel erschöpft waren.

Dies funktionierte korrekt für eine einzelne " --sort" Option, jedoch nicht für mehrere.
Wir würden alle Verbindungen im ersten Schlüssel mit dem Referenznamen aufheben und den zweiten Schlüssel überhaupt nicht bewerten.

Um die Sache noch interessanter zu machen, haben wir diesen Fallback nur manchmal angewendet!
Für ein Feld wie " taggeremail", für das ein Zeichenfolgenvergleich erforderlich ist, würden wir das Ergebnis von wirklich zurückgeben strcmp(), selbst wenn es 0 wäre.
Für numerische " value" Felder wie " taggerdate" haben wir jedoch den Fallback angewendet. Und deshalb hat unser Mehrfachsortiertest dies übersehen: Er dient taggeremailals Hauptvergleich.

Beginnen wir also mit einem viel strengeren Test. Wir haben eine Reihe von Commits, die jede Kombination von zwei Tagger-E-Mails, Daten und Refnames ausdrücken. Dann können wir bestätigen, dass unsere Sortierung mit der richtigen Priorität angewendet wird, und wir werden sowohl den String- als auch den Wertekomparator treffen.

Das zeigt den Fehler, und die Behebung ist einfach: Verschieben Sie den Fallback auf die äußere compare_refs()Funktion, nachdem alle ref_sortingTasten erschöpft sind.

Beachten Sie, dass wir in der äußeren Funktion kein "ignore_case"Flag haben, da es Teil jedes einzelnen ref_sortingElements ist. Es ist fraglich, was ein solcher Fallback bewirken sollte, da wir die Schlüssel des Benutzers nicht für die Übereinstimmung verwendet haben.
Aber bis jetzt haben wir versucht, diese Flagge zu respektieren. Das am wenigsten invasive ist, zu versuchen, dies auch weiterhin zu tun.
Da alle Anrufer im aktuellen Code entweder das Flag für alle Schlüssel oder für keine setzen, können wir das Flag einfach von der ersten Taste ziehen. In einer hypothetischen Welt, in der der Benutzer die Groß- und Kleinschreibung von Schlüsseln wirklich separat umdrehen kann, möchten wir möglicherweise den Code erweitern, um diesen Fall von einer Decke " --ignore-case" zu unterscheiden.

Ich verwende gerne ein relatives Datum und kürze den Filialnamen folgendermaßen:

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

Welches gibt Ihnen Ausgabe:

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

Ich empfehle, eine Bash-Datei zu erstellen, um alle Ihre Lieblings-Aliase hinzuzufügen und das Skript dann an Ihr Team weiterzugeben. Hier ist ein Beispiel, um nur dieses hinzuzufügen:

#!/bin/sh

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

Dann können Sie dies einfach tun, um eine schön formatierte und sortierte lokale Zweigstellenliste zu erhalten:

git branches

Update: Tun Sie dies, wenn Sie färben möchten:

#!/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)$|$"

Ab Git 2.19 können Sie einfach:

git branch --sort=-committerdate

Du kannst auch:

git config branch.sort -committerdate

Wenn Sie also Zweige im aktuellen Repository auflisten, wird diese nach Committerdate sortiert aufgelistet.

Wenn Sie Zweige immer dann auflisten möchten, wenn Sie sie nach comitterdate sortieren möchten:

git config --global branch.sort -committerdate

Haftungsausschluss: Ich bin der Autor dieser Funktion in Git und habe sie implementiert, als ich diese Frage sah.

Fügt etwas Farbe hinzu (da pretty-formatnicht verfügbar)

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

Ich hatte das gleiche Problem, also schrieb ich einen Ruby-Edelstein namens Twig . Es listet Zweige in chronologischer Reihenfolge auf (neueste zuerst) und Sie können auch ein maximales Alter festlegen, damit Sie nicht alle Zweige auflisten (wenn Sie viele davon haben). Zum Beispiel:

$ 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

Außerdem können Sie benutzerdefinierte Eigenschaften für jeden Zweig speichern, z. B. Ticket-ID, Status, Aufgaben, und die Liste der Zweige nach diesen Eigenschaften filtern. Weitere Informationen: http://rondevera.github.io/twig/

Ich habe mir den folgenden Befehl ausgedacht (für Git 2.13 und höher):

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

Wenn Sie nicht haben column, können Sie die letzte Zeile durch ersetzen

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

Die Ausgabe sieht aus wie

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

Ich habe einen Blog-Beitrag darüber geschrieben, wie die verschiedenen Stücke funktionieren.

FYI, wenn Sie eine Liste der zuletzt bekommen möchte ausgecheckt Zweige (wie kürzlich begangen Gegensatz) können Sie Git reflog verwenden:

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

Siehe auch: Wie kann ich eine Liste der Git-Zweige erhalten, die ich kürzlich ausgecheckt habe?

Hier ist ein kleines Skript, mit dem ich zwischen den letzten Zweigen wechsle:

#!/bin/bash
# sudo bash

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

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

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

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

Verwenden dieser beiden Aliase:

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

Rufen Sie das einfach in einem Git-Repository auf, und es zeigt Ihnen die letzten N Zweige (standardmäßig 10) und jeweils eine Nummer beiseite. Geben Sie die Nummer des Zweigs ein und es wird ausgecheckt:

Normalerweise betrachten wir die entfernten Zweige in letzter Zeit. Also versuch das mal

git fetch
git for-each-ref --sort=-committerdate refs/remotes/origin

Hier ist ein weiteres Skript, das genau das tut, was alle anderen Skripte tun. Tatsächlich bietet es eine Funktion für Ihre Shell.

Sein Beitrag ist, dass es einige Farben aus Ihrer Git-Konfiguration zieht (oder Standardeinstellungen verwendet).

# 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}"
}

Dies basiert auf der Version von saeedgnu , wobei jedoch der aktuelle Zweig mit einem Stern und in Farbe angezeigt wird und nur alles angezeigt wird, was vor "Monaten" oder "Jahren" nicht beschrieben wurde:

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

Mein bestes Ergebnis als Drehbuch:

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

git branch --sort=-committerdate | head -5

Für alle, die nur die Top 5 Filialnamen nach Committer-Datum sortieren möchten.

Die akzeptierte Befehlszeilenantwort rockt, aber wenn Sie etwas Schöneres wie eine GUI und Ihren Ursprung wollen === "github".

Sie können im Repository auf "Zweige" klicken. Oder klicken Sie direkt auf die URL: https://github.com/ORGANIZATION_NAME/REPO_NAME/branches

Hier ist die Variante, nach der ich gesucht habe:

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

Das tail -rkehrt die Liste so die zuletzt commiterdateletzte.

Ich leite die Ausgabe der akzeptierten Antwort in weiter dialog, um mir eine interaktive Liste zu geben:

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

Speichern unter (zB) ~/bin/git_recent_branches.shund chmod +xes. Dann git config --global alias.rb '!git_recent_branches.sh', um mir einen neuen git rbBefehl zu geben .

Ich weiß, dass es bereits viele Antworten gibt, aber hier sind meine zwei Cent für einen einfachen Alias ​​(ich möchte meinen letzten Zweig unten haben):

[alias]
        br = !git branch --sort=committerdate --color=always | tail -n15
[color "branch"]
        current = yellow
        local = cyan
        remote = red

Dies gibt Ihnen einen schönen Überblick über Ihre letzten 15 Zweige in Farbe, wobei Ihr aktueller Zweig hervorgehoben ist (und ein Sternchen hat).

Beim Versuch, einen Alias ​​festzulegen, gab es einige Probleme beim Umgang mit einfachen Anführungszeichen auf dem Mac in bash_profile. Diese Antwort half, es zu lösen " So entziehen Sie einfache Anführungszeichen in Zeichenfolgen in einfachen Anführungszeichen

Arbeitslösung:

alias gb='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))'"'"''

PS Konnte wegen meines Rufes nicht kommentieren

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))' das ist was du brauchst

Git v2.19 führt die branch.sortKonfigurationsoption ein (siehe branch.sort ).

So git branchwird standardmäßig nach Committer-Datum (absteigend) mit sortiert

# gitconfig
[branch]
    sort = -committerdate     # desc

Skript:

$ git config --global branch.sort -committerdate

Aktualisieren:

Damit,

$ git branch
* dev
  master
  _

und

$ git branch -v
* dev    0afecf5 Merge branch 'oc' into dev
  master 652428a Merge branch 'dev'
  _      7159cf9 Merge branch 'bashrc' into dev