Voglio ottenere un elenco di tutti i rami in un repository Git con i rami "più freschi" nella parte superiore, in cui il ramo "più fresco" è quello che è stato impegnato più di recente (ed è, quindi, più probabile che sia uno Voglio prestare attenzione a).

Esiste un modo in cui posso usare Git per (a) ordinare l'elenco dei rami in base all'ultimo commit o (b) ottenere un elenco di rami insieme alla data dell'ultimo commit di ognuno, in una sorta di formato leggibile automaticamente?

Nel peggiore dei casi, potrei sempre correre git branchper ottenere un elenco di tutti i rami, analizzarne l'output e quindi, git log -n 1 branchname --format=format:%ciper ognuno, ottenere la data di commit di ciascun ramo. Ma questo verrà eseguito su una finestra di Windows, dove l'avvio di un nuovo processo è relativamente costoso, quindi l'avvio dell'eseguibile Git una volta per ramo potrebbe rallentare se ci sono molti rami. C'è un modo per fare tutto questo con un solo comando?

Usa l' --sort=-committerdateopzione digit for-each-ref ;

Disponibile anche da Git 2.7.0 pergit branch :

Uso di base:

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

Risultato:

Uso avanzato:

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

Risultato:

Elenco dei nomi delle filiali Git, ordinati per commit più recente ...

Espandendo la risposta di Jakub e il suggerimento di Joe , i seguenti rimuoveranno "refs / heads /" in modo che l'output visualizzi solo i nomi dei rami:

Comando:

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

Risultato:

Ecco il codice ottimale, che combina le altre due risposte:

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

Ecco un semplice comando che elenca tutti i rami con gli ultimi commit:

git branch -v

Per ordinare in base al commit più recente, utilizzare

git branch -v --sort=committerdate

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

Uso il seguente 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"

che produce:

Usa '|' separare.

Sono stato in grado di fare riferimento agli esempi precedenti per creare qualcosa che funzioni meglio per me.

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

Avevo anche bisogno di colori, tag e riferimenti remoti senza duplicati:

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

Poiché la quotazione può essere difficile, ecco l'alias di 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'"]++'"

Le altre risposte non sembrano consentire il passaggio -vv per ottenere un output dettagliato.

Quindi, ecco un one-liner che ordina git branch -vvper data di commit, preservando il colore ecc:

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

Se si desidera inoltre stampare la data di commit, è possibile utilizzare invece questa versione:

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-

Uscita campione:

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

È probabilmente più leggibile suddiviso in più righe:

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-

Ciò dovrebbe funzionare anche con altri argomenti git branch, ad esempio -vvrper elencare le filiali di tracciamento remoto o -vvaper elencare le filiali di tracciamento remoto e locali.

git 2.7 (Q4 2015) introdurrà l'ordinamento delle filiali usando direttamente git branch:
vedi commit aa3bc55 , commit aedcb7d , commit 1511b22 , commit f65f139 , ... (23 set 2015), commit aedcb7d , commit 1511b22 , commit ca41799 (24 set 2015) e commit f65f139 , ... (23 set 2015) di Karthik Nayak ( KarthikNayak) .
^{(Unita da Junio ​​C Hamano - gitster- in commit 7f11b48 , 15 ott 2015)}

In particolare, commetti aedcb7d :

branch.c: usa ' ref-filter' API

Fai ' branch.c' usa 'ref-filter API ' per iterare attraverso l'ordinamento dei riferimenti. Ciò rimuove la maggior parte del codice utilizzato in branch.c"sostituendolo con le chiamate al"ref-filter "libreria.

Si aggiunge l'opzione--sort=<key> :

Ordina in base alla chiave fornita.
Prefisso- per ordinare in ordine decrescente del valore.

È possibile utilizzare il --sort=<key> più volte opzione, nel qual caso l'ultima chiave diventa la chiave primaria.

Le chiavi supportate sono le stesse di quelle ingit for-each-ref .
L'ordinamento predefinito è l'ordinamento basato sul nome di riferimento completo (incluso refs/...prefisso). Questo elenca prima HEAD (se presente) staccato, quindi le filiali locali e infine le filiali di tracciamento remoto.

Qui:

git branch --sort=-committerdate 

Oppure (vedi sotto con Git 2.19)

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

Vedi anche commit 9e46833 (30 ott 2015) di Karthik Nayak ( KarthikNayak) .
Aiutato da: Junio ​​C Hamano ( gitster) .
^{(Unito da Junio ​​C Hamano - gitster- in commit 415095f , 03 nov 2015)}

Quando si ordina secondo i valori numerici (ad es. --sort=objectsize) Non esiste un confronto di fallback quando entrambi i ref mantengono lo stesso valore. Ciò può causare risultati imprevisti (cioè l'ordine di elencare i ref con valori uguali non può essere predeterminato) come sottolineato da Johannes Sixt ( $ gmane / 280117 ).

Quindi, il ritorno al confronto alfabetico basato sul refname ogni volta che l'altro criterio è uguale .

$ git branch --sort=objectsize

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

Con Git 2.19, l'ordinamento può essere impostato per impostazione predefinita.
git branchsupporta una configurazione branch.sort, come git tag, che aveva già una configurazione tag.sort.
Vedi commit 560ae1c (16 ago 2018) di Samuel Maftoul (``) .
^{(Unito da Junio ​​C Hamano - gitster- in commit d89db6f , 27 ago 2018)}

branch.sort:

Questa variabile controlla l'ordinamento dei rami quando viene visualizzato da git-branch.
Senza l' --sort=<value>opzione " " fornita, il valore di questa variabile verrà utilizzato come predefinito.

Per elencare i rami remoti, utilizzare git branch -r --sort=objectsize. Il-r flag fa sì che elenca i rami remoti invece dei rami locali.

Con Git 2.27 (Q2 2020), le varianti " git branch" e altre " for-each-ref" hanno accettato più --sort=<key>opzioni nel crescente ordine di precedenza, ma hanno avuto alcune rotture "--ignore-case gestione " e nel legame con il nome di riferimento, che sono stati corretti.

Vedi commit 7c5045f , commit 76f9e56 (03 maggio 2020) di Jeff King ( peff) .
^{(Unita da Junio ​​C Hamano - gitster- in commit 6de1630 , 08 maggio 2020)}

ref-filter: applica l'ordinamento refname di fallback solo dopo tutti gli ordinamenti dell'utente

^{Firmato-fuori-da: Jeff King}

Commit 9e468334b4 (" ref-filter: fallback sul confronto alfabetico", 30-10-2015, Git v2.7.0-rc0 - unione elencata nel batch # 10 ) ha insegnato l'ordinamento di ref-filter al fallback per confrontare i nomi di ref.
Ma lo ha fatto al livello sbagliato, sovrascrivendo il risultato del confronto per un singolo "--sort chiave " da parte dell'utente, piuttosto che dopo che tutte le chiavi di ordinamento sono state esaurite.

Funzionava correttamente per una " --sort" opzione, ma non per più.
Rompiamo i legami nella prima chiave con il refname e non valutiamo mai la seconda chiave.

Per rendere le cose ancora più interessanti, abbiamo applicato questo fallback solo a volte!
Per un campo come " taggeremail" che richiede un confronto di stringhe, restituiremmo veramente il risultato strcmp(), anche se fosse 0.
Ma per " value" campi numerici come " taggerdate", abbiamo applicato il fallback. Ed è per questo che il nostro test multi-sort ha mancato questo: usa taggeremailcome confronto principale.

Quindi iniziamo aggiungendo un test molto più rigoroso. Avremo una serie di commit che esprimono ogni combinazione di due email tagger, date e nomi di nomi. Quindi possiamo confermare che il nostro ordinamento viene applicato con la precedenza corretta e colpiremo entrambi i comparatori di stringhe e valori.

Ciò mostra il bug e la correzione è semplice: compare_refs()dopo tutto, spostare il fallback sulla funzione esternaref_sorting tasti sono stati esauriti.

Nota che nella funzione esterna non abbiamo un "ignore_case"flag, poiché fa parte di ogni singolo ref_sortingelemento. È discutibile cosa dovrebbe fare un simile fallback, dal momento che non abbiamo usato le chiavi dell'utente per abbinare.
Ma fino ad ora abbiamo cercato di rispettare quella bandiera, quindi la cosa meno invasiva è cercare di continuare a farlo.
Poiché tutti i chiamanti nel codice corrente impostano il flag per tutti i tasti o per nessuno, possiamo semplicemente estrarre il flag dal primo tasto. In un mondo ipotetico in cui l'utente può davvero capovolgere la distinzione tra maiuscole e minuscole dei tasti separatamente, potremmo voler estendere il codice per distinguere quel caso da una coperta " --ignore-case".

Mi piace usare una data relativa e abbreviare il nome della filiale in questo modo:

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

Che ti dà un output:

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

Consiglio di creare un file Bash per aggiungere tutti i tuoi alias preferiti e quindi condividere lo script con il tuo team. Ecco un esempio per aggiungere solo questo:

#!/bin/sh

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

Quindi puoi semplicemente farlo per ottenere un elenco di filiali locali ben formattato e ordinato:

git branches

Aggiornamento: fallo se vuoi colorare:

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

A partire da Git 2.19 puoi semplicemente:

git branch --sort=-committerdate

Puoi anche:

git config branch.sort -committerdate

Pertanto, ogni volta che si elencano i rami nel repository corrente, questo verrà elencato in base alla data di inizio.

Se ogni volta che elenchi i rami, li vuoi ordinati per comitterdate:

git config --global branch.sort -committerdate

Disclaimer: sono l'autore di questa funzionalità in Git e l'ho implementata quando ho visto questa domanda.

Aggiunge un po 'di colore (poiché pretty-formatnon è disponibile)

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

Ho avuto lo stesso problema, quindi ho scritto una gemma di Ruby chiamata Twig . Elenca i rami in ordine cronologico (prima i più recenti) e può anche permetterti di impostare un'età massima in modo da non elencare tutti i rami (se ne hai molti). Per esempio:

$ 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

Inoltre, consente di memorizzare proprietà personalizzate per ciascun ramo, ad es. ID ticket, stato, todos e filtrare l'elenco dei rami in base a tali proprietà. Maggiori informazioni: http://rondevera.github.io/twig/

Mi è venuto in mente il seguente comando (per Git 2.13 e versioni successive):

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

Se non lo columnhai, puoi sostituire l'ultima riga con

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

L'output è simile

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

Ho scritto un post sul blog su come funzionano i vari pezzi.

Cordiali saluti, se desideri ottenere un elenco di filiali recentemente estratte (anziché impegnate di recente) puoi utilizzare il reflog di Git:

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

Vedi anche: Come posso ottenere un elenco di filiali Git che ho verificato di recente?

Ecco un piccolo script che uso per passare da rami recenti:

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

Utilizzando questi due alias:

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

Basta chiamarlo in un repository Git e ti mostrerà gli ultimi N rami (10 di default) e un numero a parte ciascuno. Inserisci il numero del ramo e verifica:

Normalmente consideriamo le filiali remote di recente. Quindi prova questo

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

Ecco un altro script che fa quello che fanno tutti gli altri script. In effetti, fornisce una funzione per la tua shell.

Il suo contributo è che estrae alcuni colori dalla configurazione di Git (o utilizza i valori predefiniti).

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

Questo si basa sulla versione di saeedgnu , ma con l'attuale ramo mostrato con una stella e a colori, e mostrando solo tutto ciò che non è descritto come "mesi" o "anni" fa:

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

Il mio miglior risultato come sceneggiatura:

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

Per chiunque sia interessato a ottenere solo i primi 5 nomi delle filiali ordinati in base alla data del committer.

La risposta della riga di comando accettata oscilla, ma se vuoi qualcosa di più bello, come una GUI, e la tua origine === "github".

È possibile fare clic su "Branches" nel repository. O colpisci direttamente l'URL: https://github.com/ORGANIZATION_NAME/REPO_NAME/branches

Ecco la variante che stavo cercando:

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

Quello tail -r inverte l'elenco in modo che l'ultimo commiterdatesia l'ultimo.

Inoltro l'output della risposta accettata in dialog, per darmi un elenco interattivo:

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

Salva con nome (per esempio) ~/bin/git_recent_branches.she chmod +xdi esso. Quindi git config --global alias.rb '!git_recent_branches.sh'per darmi un nuovo git rbcomando.

So che ci sono già molte risposte, ma ecco i miei due centesimi per un semplice alias (mi piace avere il mio ramo più recente in fondo):

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

Questo ti darà una bella panoramica dei tuoi ultimi 15 rami, a colori, con il tuo ramo attuale evidenziato (e ha un asterisco).

Si è verificato un problema durante la gestione di virgolette singole su Mac in bash_profile durante il tentativo di impostare un alias. Questa risposta ha aiutato a risolverlo " Come sfuggire alle virgolette singole all'interno di stringhe tra virgolette singole

Soluzione di lavoro:

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 Non ho potuto commentare a causa della mia reputazione

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))' questo è quello di cui hai bisogno

Git v2.19 introduce l' branch.sortopzione di configurazione (vedi branch.sort ).

Quindi git branchordinerà per data committer (desc) per impostazione predefinita con

# gitconfig
[branch]
    sort = -committerdate     # desc

script:

$ git config --global branch.sort -committerdate

Aggiornare:

Così,

$ git branch
* dev
  master
  _

e

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