Come determinare quando è stato creato un ramo Git?

C'è un modo per determinare quando è stato creato un ramo Git? Ho un ramo nel mio repository e non ricordo di averlo creato e ho pensato che forse vedere il timestamp della creazione mi avrebbe fatto correre la memoria.

Uso

git show - riassumi `git merge-base foo master`

Se preferisci vederlo nel contesto usando gitk, allora usa

gitk --all --select-commit = `git merge-base foo master`

(dove foo è il nome del ramo che stai cercando.)

Come sottolineato nei commenti e nella risposta di Jackub , fintanto che il tuo ramo è più giovane del numero di giorni impostato nell'impostazione di configurazione gc.reflogexpire(il valore predefinito è 90 giorni), puoi utilizzare il tuo reflog per scoprire quando un riferimento al ramo era creato per primo.

Nota che git reflogpuò prendere la maggior parte delle git logbandiere. Si noti inoltre che i HEAD@{0}selettori di stile sono effettivamente nozioni di tempo e, di fatto, vengono gestiti (in un modo hackerato) come stringhe di date. Ciò significa che puoi usare il flag --date=locale ottenere un output in questo modo:

$ git reflog --date = local
763008c HEAD @ {ven 20 ago 10:09:18 2010}: pull: avanzamento rapido
f6cec0a HEAD @ {mar 10 ago 09:37:55 2010}: pull: avanzamento rapido
e9e70bc HEAD @ {gio 4 feb 02:51:10 2010}: pull: avanzamento veloce
836f48c HEAD @ {Gio 21 Gen 14:08:14 2010}: checkout: passaggio da maestro a maestro
836f48c HEAD @ {Gio 21 Gen 14:08:10 2010}: pull: avanti veloce
24bc734 HEAD @ {mer 20 gen 12:05:45 2010}: checkout: in movimento da 74fca6a42863ffacaf7ba6f1936a9f228950f657 
74fca6a HEAD @ {mer 20 gen 11:55:43 2010}: checkout: passaggio dal master alla v2.6.31
24bc734 HEAD @ {mer 20 gen 11:44:42 2010}: pull: avanzamento veloce
964fe08 HEAD @ {lun 26 ott 15:29:29 2009}: checkout: in movimento da 4a6908a3a050aacc9c3a2f36b276b46c0629ad91 
4a6908a HEAD @ {lun 26 ott 14:52:12 2009}: checkout: passaggio dal master alla v2.6.28

Può anche essere utile a volte usare --date=relative:

$ git reflog --date = relative
763008c HEAD @ {4 settimane fa}: pull: avanzamento rapido
f6cec0a HEAD @ {6 settimane fa}: pull: avanzamento rapido
e9e70bc HEAD @ {8 mesi fa}: pull: avanzamento veloce
836f48c HEAD @ {8 mesi fa}: checkout: passaggio da master a master
836f48c HEAD @ {8 mesi fa}: pull: avanzamento veloce
24bc734 HEAD @ {8 mesi fa}: checkout: passaggio da 74fca6a42863ffacaf7ba6f1936a9f228950f657 al master
74fca6a HEAD @ {8 mesi fa}: checkout: passaggio da master a v2.6.31
24bc734 HEAD @ {8 mesi fa}: pull: avanzamento veloce
964fe08 HEAD @ {11 mesi fa}: checkout: passaggio da 4a6908a3a050aacc9c3a2f36b276b46c0629ad91 al master
4a6908a HEAD @ {11 mesi fa}: checkout: passaggio da master a v2.6.28

Un'ultima nota: il --allflag (che è in realtà un flag git-log compreso da git-reflog) mostrerà i reflog per tutti i ref conosciuti refs/(invece che semplicemente HEAD) che mostreranno chiaramente gli eventi di diramazione:

git reflog --date = local --all
860e4e4 refs / heads / master @ {dom 19 set 23:00:30 2010}: commit: secondo.
17695bc refs / heads / example_branch @ {lun 20 set 00:31:06 2010}: branch: Creato da HEAD

Pro Git § 3.1 Git Branching - What a Branch Is ha una buona spiegazione di cosa sia realmente un branch git

Un ramo in Git è semplicemente un puntatore mobile leggero a [a] commit.

Poiché un ramo è solo un puntatore leggero, git non ha una nozione esplicita della sua storia o data di creazione. "Ma aspetta", ti sento dire, "certo git conosce la mia storia di ramo!" Beh, in un certo senso.

Se si esegue una delle seguenti operazioni:

git log <branch> --not master
gitk <branch> --not master

vedrai quella che sembra la "storia del tuo ramo", ma in realtà è un elenco di commit raggiungibili da "ramo" che non sono raggiungibili dal master. Questo ti dà le informazioni che desideri, ma se e solo se non hai mai unito 'branch' al master e non hai mai unito master in 'branch' da quando l'hai creato. Se ti sei unito, questa cronologia delle differenze crollerà.

Fortunatamente il reflog spesso contiene le informazioni desiderate, come spiegato in varie altre risposte qui. Usa questo:

git reflog --date=local <branch>

per mostrare la storia del ramo. L'ultima voce in questo elenco è (probabilmente) il punto in cui è stato creato il ramo.

Se il ramo è stato cancellato, 'ramo' non è più un identificatore git valido, ma puoi invece usarlo, che potrebbe trovare quello che desideri:

git reflog --date=local | grep <branch>

O in una shell cmd di Windows:

git reflog --date=local | find "<branch>"

Nota che reflog non funzionerà in modo efficace su filiali remote, solo su quelle su cui hai lavorato localmente.

Innanzitutto, se la tua filiale è stata creata in pochi gc.reflogexpiregiorni (impostazione predefinita 90 giorni, ovvero circa 3 mesi), puoi utilizzare git log -g <branch>o git reflog show <branch>trovare la prima voce in reflog, che sarebbe un evento di creazione, e avrà un aspetto simile al seguente (per git log -g):

Reflog: <branch>@{<nn>} (C R Eator <creator@example.com>)
Reflog message: branch: Created from <some other branch>

Otterresti chi ha creato un ramo, quante operazioni fa e da quale ramo (beh, potrebbe essere solo "Creato da HEAD", il che non aiuta molto).

Questo è ciò che MikeSep ha detto nella sua risposta .

In secondo luogo, se hai ramo da più tempo di gc.reflogexpiree hai eseguito git gc(o è stato eseguito automaticamente), dovresti trovare un antenato comune con il ramo da cui è stato creato. Dai un'occhiata al file di configurazione, forse c'è una branch.<branchname>.mergevoce, che ti dirà su quale ramo si basa questo.

Se sai che il ramo in questione è stato creato fuori dal ramo principale (biforcazione dal ramo principale), ad esempio, puoi usare il comando seguente per vedere l'antenato comune:

git show $(git merge-base <branch> master)

Puoi anche provare git show-branch <branch> master, in alternativa.

Questo è ciò che ha detto Gbacon nella sua risposta .

Non sono ancora sicuro del comando git per questo, ma penso che tu possa trovarli nei reflog.

.git/logs/refs/heads/<yourbranch>

I miei file sembrano avere un timestamp unix in essi.

Aggiornamento: sembra esserci un'opzione per utilizzare la cronologia dei reflog invece della cronologia di commit durante la stampa dei registri:

git log -g

Puoi anche seguire questo registro, fino a quando hai creato il ramo. git logmostra la data del commit, tuttavia, non la data in cui è stata effettuata l'azione che ha effettuato una registrazione nel reflog. Non l'ho ancora trovato se non guardando nel reflog reale nel percorso sopra.

Prova questo

  git for-each-ref --format='%(committerdate) %09 %(authorname) %09 %(refname)'

Uso:

git reflog

per mostrare tutto il ciclo di vita del tuo repository nella cartella corrente. Il nome del ramo che appare per primo (dal basso verso l'alto) è la fonte che è stata creata.

855a3ce HEAD@{0}: checkout: moving from development to feature-sut-46
855a3ce HEAD@{1}: checkout: moving from feature-sut-46 to development
855a3ce HEAD@{2}: checkout: moving from feature-jira35 to feature-sut-46
535dd9d HEAD@{3}: checkout: moving from feature-sut-46 to feature-jira35
855a3ce HEAD@{4}: checkout: moving from development to feature-sut-46
855a3ce HEAD@{5}: checkout: moving from feature-jira35 to development
535dd9d HEAD@{6}: commit: insert the format for vendor specific brower - screen.css
855a3ce HEAD@{7}: checkout: moving from development to feature-jira35
855a3ce HEAD@{8}: checkout: moving from master to development

Ciò significa:

• Lo sviluppo del ramo viene creato (checkout -b) dal master

• Il ramo feature-jira35 viene creato (checkout -b) dallo sviluppo

• Il ramo feature-jira-sut-46 viene creato (checkout -b) dallo sviluppo

Questa è una cosa che mi è venuta in mente prima di trovare questa discussione.

git reflog show --date=local --all | sed 's!^.*refs/!refs/!' | grep '/master' | tail -1
git reflog show --date=local --all | sed 's!^.*refs/!refs/!' | grep 'branch:'

Questo comando mostra la data di creazione del ramo devdamain

$git reflog show --date=iso dev
$7a2b33d dev@{2012-11-23 13:20:28 -2100}: branch: Created from main

Se vuoi ottenere i dettagli per tutti i rami

for i in `git branch -r | tail -n +2 `;do git log --reverse $i|grep -A 2 -B 2 `echo $i | awk -F'origin/' '{print $2}'` |head -n 4; done

Ho trovato il modo migliore: controllo sempre l'ultimo ramo creato in questo modo

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

Unito alla risposta di Andrew Sohn ( https://stackoverflow.com/a/14265207/1929406 )

branchcreated=$(git reflog show --date=format:'%Y-%m-%d %H:%M:%S' --all | sed 's!^.*refs/!refs/!' | grep '/master' | tail -1| cut -d'{' -f 2| cut -d'}' -f 1 | xargs)
echo $branchcreated

Questo l'ha fatto per me: (10 anni dopo)

git log [--remotes] --no-walk --decorate

Poiché non vi sono informazioni memorizzate sui tempi di creazione del ramo, ciò che fa è visualizzare il primo commit di ciascun ramo ( --no-walk), che include la data del commit. Utilizzare --remotesper i rami remoti o ometterlo per i rami locali.

Dal momento che eseguo almeno un commit in un ramo prima di crearne un altro, questo mi ha permesso di risalire a qualche mese di creazione di rami (e funzionalità dev-start) a scopo di documentazione.

fonte: AnoE su stackexchange

sintassi: git reflog --date=local | grep checkout: | grep ${current_branch} | tail -1

esempio: git reflog --date=local | grep checkout: | grep dev-2.19.0 | tail -1

risultato: cc7a3a8ec HEAD@{Wed Apr 29 14:58:50 2020}: checkout: moving from dev-2.18.0 to dev-2.19.0