Je veux obtenir une liste de toutes les branches dans un référentiel Git avec les branches "les plus fraîches" en haut, où la branche "la plus fraîche" est celle qui a été validée le plus récemment (et est donc plus susceptible de l'être) Je veux faire attention).

Existe-t-il un moyen d'utiliser Git pour (a) trier la liste des branches par dernier commit, ou (b) obtenir une liste des branches avec la date de dernier commit de chacun, dans une sorte de format lisible par machine?

Dans le pire des cas, je pouvais toujours courir git branchpour obtenir une liste de toutes les branches, analyser sa sortie, puis git log -n 1 branchname --format=format:%cipour chacune, obtenir la date de validation de chaque branche. Mais cela fonctionnera sur une boîte Windows, où la rotation d'un nouveau processus est relativement coûteuse, donc le lancement de l'exécutable Git une fois par branche pourrait devenir lent s'il y a beaucoup de branches. Existe-t-il un moyen de faire tout cela avec une seule commande?

Utilisez l' --sort=-committerdateoption de git for-each-ref;

Également disponible depuis Git 2.7.0 pour git branch:

Utilisation de 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

Résultat:

Utilisation avancée:

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

Résultat:

Liste des noms de branche Git, classés par commit le plus récent…

En développant la réponse de Jakub et le conseil de Joe , ce qui suit supprimera les "refs / heads /" afin que la sortie affiche uniquement les noms des branches:

Commander:

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

Résultat:

Voici le code optimal, qui combine les deux autres réponses:

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

Voici une commande simple qui répertorie toutes les branches avec les dernières validations:

git branch -v

Pour commander par commit le plus récent, utilisez

git branch -v --sort=committerdate

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

J'utilise l'alias suivant:

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"

qui produit:

Utilisez '|' séparer.

J'ai pu faire référence aux exemples précédents pour créer quelque chose qui me convient le mieux.

git for-each-ref --sort = -committerdate refs / heads / --format = '% (authordate: short)% (couleur: rouge)% (nom d'objet: short)% (couleur: jaune)% (refname: short )% (couleur: reset) (% (couleur: vert)% (committerdate: relative)% (couleur: reset)) ''

J'avais également besoin de couleurs, d'étiquettes et de références à distance sans doublons:

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

Parce que la citation peut être difficile, voici l'alias de 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'"]++'"

Les autres réponses ne semblent pas permettre de passer -vvpour obtenir une sortie détaillée.

Voici donc une ligne qui trie git branch -vvpar date de validation, en préservant la couleur, etc.:

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

Si vous souhaitez également imprimer la date de validation, vous pouvez utiliser cette version à la place:

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-

Exemple de sortie:

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

C'est probablement plus divisible en plusieurs lignes:

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-

Cela devrait également fonctionner avec d'autres arguments git branch, par exemple -vvrpour répertorier les branches de suivi à distance, ou -vvapour répertorier les branches de suivi à distance et locales.

git 2.7 (Q4 2015) introduira le tri des branches en utilisant directement git branch:
voir commit aa3bc55 , commit aedcb7d , commit 1511b22 , commit f65f139 , ... (23 sept. 2015), commit aedcb7d , commit 1511b22 , commit ca41799 (24 sept. 2015), et commit f65f139 , ... (23 sept. 2015) par Karthik Nayak ( KarthikNayak) .
^{(Fusionné par Junio ​​C Hamano - gitster- dans commit 7f11b48 , 15 oct.2015 )}

En particulier, validez aedcb7d :

branch.c: utiliser ' ref-filter' API

Make « branch.c» utilisation « ref-filter» API pour Itère refs tri. Cela supprime la plupart du code utilisé pour le branch.cremplacer par des appels à la ref-filterbibliothèque ' '.

Il ajoute l'option--sort=<key> :

Trier en fonction de la clé donnée.
Préfixe -pour trier dans l'ordre décroissant de la valeur.

Vous pouvez utiliser l' --sort=<key>option plusieurs fois, auquel cas la dernière clé devient la clé primaire.

Les clés prises en charge sont les mêmes que celles degit for-each-ref .
L'ordre de tri par défaut est un tri basé sur le nom de référence complet (y compris le refs/...préfixe). Cela répertorie d'abord HEAD détaché (si présent), puis les branches locales et enfin les branches de suivi à distance.

Ici:

git branch --sort=-committerdate 

Ou (voir ci-dessous avec Git 2.19)

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

Voir aussi commit 9e46833 (30 octobre 2015) par Karthik Nayak ( KarthikNayak) .
Aidé par: Junio ​​C Hamano ( gitster) .
^{(Fusionné par Junio ​​C Hamano - gitster- en commit 415095f , 03 nov.2015 )}

Lors du tri selon des valeurs numériques (par exemple --sort=objectsize), il n'y a pas de comparaison de repli lorsque les deux références contiennent la même valeur. Cela peut entraîner des résultats inattendus (c'est-à-dire que l'ordre de listage des références avec des valeurs égales ne peut pas être prédéterminé) comme l'a souligné Johannes Sixt ( $ gmane / 280117 ).

Par conséquent, retour à la comparaison alphabétique basée sur le nom de référence chaque fois que l'autre critère est égal .

$ git branch --sort=objectsize

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

Avec Git 2.19, l'ordre de tri peut être défini par défaut.
git branchprend en charge une configuration branch.sort, comme git tag, qui avait déjà une configuration tag.sort.
Voir commit 560ae1c (16 août 2018) de Samuel Maftoul (``) .
^{(Fusionné par Junio ​​C Hamano - gitster- dans commit d89db6f , 27 août 2018)}

branch.sort:

Cette variable contrôle l'ordre de tri des branches lorsqu'elle est affichée par git-branch.
Sans l' --sort=<value>option " " fournie, la valeur de cette variable sera utilisée par défaut.

Pour répertorier les branches distantes, utilisez git branch -r --sort=objectsize. L' -rindicateur lui fait lister les branches distantes au lieu des branches locales.

Avec Git 2.27 (Q2 2020), les variantes " git branch" et autres " for-each-ref" acceptaient plusieurs --sort=<key>options dans l'ordre croissant de priorité, mais il y avait quelques bris autour de la " --ignore-case" gestion et bris d'égalité avec le refname, qui ont été corrigés.

Voir commit 7c5045f , commit 76f9e56 (03 mai 2020) par Jeff King ( peff) .
^{(Fusionné par Junio ​​C Hamano - gitster- en commit 6de1630 , 08 mai 2020)}

ref-filter: appliquer le tri du nom de référence de secours uniquement après tous les tris utilisateur

^{Signé par: Jeff King}

La validation 9e468334b4 (" ref-filter: repli sur la comparaison alphabétique", 2015-10-30, Git v2.7.0-rc0 - fusion répertoriée dans le lot n ° 10 ) a enseigné au tri du filtre-ref de se replier sur la comparaison des noms.
Mais il l'a fait au mauvais niveau, remplaçant le résultat de la comparaison pour une seule --sortclé " " de l'utilisateur, plutôt qu'après avoir épuisé toutes les clés de tri.

Cela fonctionnait correctement pour une seule --sortoption " ", mais pas pour plusieurs.
Nous rompions tout lien dans la première clé avec le nom de référence et n'évaluions jamais la deuxième clé.

Pour rendre les choses encore plus intéressantes, nous n'avons appliqué cette solution de rechange que parfois!
Pour un champ comme " taggeremail" qui nécessite une comparaison de chaînes, nous retournerions vraiment le résultat de strcmp(), même s'il était 0.
Mais pour les " value" champs numériques comme " taggerdate", nous avons appliqué le repli. Et c'est pourquoi notre test de tri multiple a raté cela: il utilise taggeremailcomme comparaison principale.

Commençons donc par ajouter un test beaucoup plus rigoureux. Nous aurons un ensemble de validations exprimant chaque combinaison de deux e-mails de tagueur, dates et refnames. Ensuite, nous pouvons confirmer que notre tri est appliqué avec la priorité correcte, et nous afficherons à la fois la chaîne et les comparateurs de valeurs.

Cela montre le bogue, et le correctif est simple: déplacer le repli sur la compare_refs()fonction externe , après que toutes les ref_sortingclés ont été épuisées.

Notez que dans la fonction externe, nous n'avons pas d' "ignore_case"indicateur, car il fait partie de chaque ref_sortingélément individuel . On peut se demander ce que devrait faire une telle solution de rechange, car nous n'avons pas utilisé les clés de l'utilisateur pour les faire correspondre.
Mais jusqu'à présent, nous avons essayé de respecter ce drapeau, donc la chose la moins invasive est d'essayer de continuer à le faire.
Étant donné que tous les appelants du code actuel définissent le drapeau pour toutes les clés ou pour aucune, nous pouvons simplement retirer le drapeau de la première clé. Dans un monde hypothétique où l'utilisateur peut vraiment inverser la sensibilité à la casse des clés séparément, nous pouvons vouloir étendre le code pour distinguer ce cas d'une couverture " --ignore-case".

J'aime utiliser une date relative et raccourcir le nom de la branche comme ceci:

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

Ce qui vous donne une sortie:

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

Je recommande de créer un fichier Bash pour ajouter tous vos alias préférés, puis de partager le script avec votre équipe. Voici un exemple pour ajouter juste celui-ci:

#!/bin/sh

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

Ensuite, vous pouvez simplement le faire pour obtenir une liste de branches locales bien formatée et triée:

git branches

Mise à jour: faites ceci si vous voulez colorier:

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

Depuis Git 2.19, vous pouvez simplement:

git branch --sort=-committerdate

Vous pouvez également:

git config branch.sort -committerdate

Ainsi, chaque fois que vous répertoriez des branches dans le référentiel actuel, elles seront répertoriées triées par date de validation.

Si chaque fois que vous listez des branches, vous voulez qu'elles soient triées par date de publication:

git config --global branch.sort -committerdate

Avertissement: je suis l'auteur de cette fonctionnalité dans Git, et je l'ai implémentée lorsque j'ai vu cette question.

Ajoute de la couleur (car pretty-formatn'est pas disponible)

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

J'ai eu le même problème, alors j'ai écrit un bijou Ruby appelé Twig . Il répertorie les branches par ordre chronologique (le plus récent en premier) et peut également vous permettre de définir un âge maximum afin de ne pas répertorier toutes les branches (si vous en avez beaucoup). Par exemple:

$ 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

Il vous permet également de stocker des propriétés personnalisées pour chaque branche, par exemple, l'ID de ticket, l'état, les tâches et de filtrer la liste des branches en fonction de ces propriétés. Plus d'informations: http://rondevera.github.io/twig/

Je suis venu avec la commande suivante (pour Git 2.13 et versions ultérieures):

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

Si vous n'en avez pas, columnvous pouvez remplacer la dernière ligne par

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

La sortie ressemble à

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

J'ai écrit un article de blog sur le fonctionnement des différentes pièces.

Pour votre information, si vous souhaitez obtenir une liste des récemment vérifiés des branches (par opposition récemment engagés) vous pouvez utiliser reflog de Git:

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

Voir aussi: Comment obtenir une liste des branches Git que j'ai récemment extraites?

Voici un petit script que j'utilise pour basculer entre les branches récentes:

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

En utilisant ces deux 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)'

Appelez simplement cela dans un référentiel Git, et il vous montrera les N dernières branches (10 par défaut) et un nombre de côté chacune. Entrez le numéro de la branche, et il vérifie:

Normalement, nous considérons les branches éloignées récemment. Alors essayez ceci

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

Voici un autre script qui fait ce que font tous les autres scripts. En fait, il fournit une fonction pour votre shell.

Sa contribution est qu'il tire certaines couleurs de votre configuration Git (ou utilise des valeurs par défaut).

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

Ceci est basé sur la version de saeedgnu , mais avec la branche actuelle représentée avec une étoile et en couleur, et ne montrant que tout ce qui n'est pas décrit comme "mois" ou "années":

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

Mon meilleur résultat en tant que script:

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

Pour tous ceux qui souhaitent obtenir uniquement les 5 premiers noms de branche triés en fonction de la date de validation.

La réponse en ligne de commande acceptée est géniale, mais si vous voulez quelque chose de plus joli, comme une interface graphique, et votre origine === "github".

Vous pouvez cliquer sur "Branches" dans le référentiel. Ou appuyez directement sur l'URL: https://github.com/ORGANIZATION_NAME/REPO_NAME/branches

Voici la variation que je cherchais:

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

Cela tail -rrenverse la liste de sorte que le plus récent commiterdateest le dernier.

Je dirige la sortie de la réponse acceptée vers dialog, pour me donner une liste interactive:

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

Enregistrer sous (par exemple) ~/bin/git_recent_branches.shet chmod +xle. Ensuite, git config --global alias.rb '!git_recent_branches.sh'pour me donner une nouvelle git rbcommande.

Je sais qu'il y a déjà beaucoup de réponses, mais voici mes deux cents pour un alias simple (j'aime avoir ma branche la plus récente en bas):

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

Cela vous donnera un bel aperçu de vos 15 dernières branches, en couleur, avec votre branche actuelle en surbrillance (et elle a un astérisque).

J'ai eu du mal à gérer les guillemets simples sur Mac dans bash_profile lors de la tentative de définition d'un alias. Cette réponse a aidé à le résoudre " Comment échapper aux guillemets simples dans des chaînes entre guillemets simples

Solution de travail:

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 Impossible de commenter à cause de ma réputation

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))' c'est ce dont tu as besoin

Git v2.19 introduit l' branch.sortoption config (voir branch.sort ).

Donc git branch, triera par date de validation (desc) par défaut avec

# gitconfig
[branch]
    sort = -committerdate     # desc

scénario:

$ git config --global branch.sort -committerdate

Mise à jour:

Donc,

$ git branch
* dev
  master
  _

et

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