Como determinar quando um ramo Git foi criado?

Existe uma maneira de determinar quando um ramo Git foi criado? Eu tenho um ramo no meu repositório e não me lembro de criá-lo e pensei que talvez ver o timestamp da criação despertasse minha memória.

Usar

git show --summary `base de mesclagem git foo master`

Se você preferir vê-lo em contexto usando o gitk, use

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

(onde foo é o nome do ramo que você está procurando.)

Conforme indicado nos comentários e na resposta do Jackub , desde que sua ramificação seja menor que o número de dias definido na configuração gc.reflogexpire(o padrão é 90 dias), você poderá utilizar seu reflog para descobrir quando uma referência de ramificação foi criado pela primeira vez.

Observe que git reflogpode receber a maioria dos git logsinalizadores. Observe também que os HEAD@{0}seletores de estilo são efetivamente noções de tempo e, de fato, são tratados (de uma maneira hackeada) como seqüências de datas. Isso significa que você pode usar o sinalizador --date=locale obter uma saída como esta:

$ git reflog --date = local
763008c HEAD @ {Fri, 20 de agosto às 10:09:18 2010}: pull: Avanço rápido
f6cec0a HEAD @ {Ter, 10 de agosto às 09:37:55 2010}: pull: Avanço rápido
e9e70bc HEAD @ {Qui Fev 4 02:51:10 2010}: pull: Avanço rápido
836f48c HEAD @ {Qui Jan 21 14:08:14 2010}: checkout: movendo de mestre para mestre
836f48c HEAD @ {Qui Jan 21 14:08:10 2010}: pull: Avanço rápido
24bc734 HEAD @ {Wed Jan 20 12:05:45 2010}: checkout: saindo de 74fca6a42863ffacaf7ba6f1936a9f228950f657 
74fca6a HEAD @ {Wed Jan 20 11:55:43 2010}: checkout: movendo do master para a v2.6.31
24bc734 HEAD @ {Wed Jan 20 11:44:42 2010}: pull: Avanço rápido
964fe08 HEAD @ {segunda-feira, 26 de outubro, 15:29:29 2009}: checkout: saindo de 4a6908a3a050aacc9c3a2f36b276b46c0629ad91 
4a6908a HEAD @ {segunda-feira, 26 de outubro, 14:52:12 2009}: checkout: movendo-se do master para a v2.6.28

Às vezes, também pode ser útil usar --date=relative:

$ git reflog --date = relativo
763008c HEAD @ {4 semanas atrás}: pull: Avanço rápido
f6cec0a HEAD @ {6 semanas atrás}: pull: Avanço rápido
e9e70bc HEAD @ {8 meses atrás}: pull: Avanço rápido
836f48c HEAD @ {8 meses atrás}: checkout: movendo de mestre para mestre
836f48c HEAD @ {8 meses atrás}: pull: Avanço rápido
24bc734 HEAD @ {8 meses atrás}: checkout: saindo de 74fca6a42863ffacaf7ba6f1936a9f228950f657 para dominar
74fca6a HEAD @ {8 meses atrás}: checkout: movendo do master para a v2.6.31
24bc734 HEAD @ {8 meses atrás}: pull: Avanço rápido
964fe08 HEAD @ {11 meses atrás}: checkout: saindo de 4a6908a3a050aacc9c3a2f36b276b46c0629ad91 para dominar
4a6908a HEAD @ {11 meses atrás}: checkout: movendo do master para a v2.6.28

Uma última observação: o --allsinalizador (que é realmente um sinalizador de git-log entendido por git-reflog) mostrará os refletores de todos os representantes conhecidos em refs/( em vez de simplesmente HEAD) que mostrarão claramente os eventos de ramificação:

git reflog --date = local --todos
860e4e4 refs / heads / master @ {Dom 19 de setembro 23:00:30 2010}: commit: Second.
17695bc refs / heads / example_branch @ {Seg 20 de setembro 00:31:06 2010}: ramo: Criado a partir de HEAD

Pro Git § 3.1 Ramificação Git - O que é uma ramificação tem uma boa explicação sobre o que realmente é uma ramificação git

Uma ramificação no Git é simplesmente um ponteiro móvel leve para [a] confirmar.

Como um ramo é apenas um ponteiro leve, o git não tem noção explícita de seu histórico ou data de criação. "Mas espere", eu ouvi você dizer, "é claro que o git conhece minha história no ramo!" Bem, mais ou menos.

Se você executar um dos seguintes:

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

você verá o que se parece com o "histórico de sua ramificação", mas é realmente uma lista de confirmações alcançáveis ​​a partir de 'ramificação' que não são alcançáveis ​​pelo mestre. Isso fornece as informações que você deseja, mas se e somente se você nunca mesclou 'ramificação' de volta ao mestre e nunca mesclou o mestre em 'ramificação' desde que você a criou. Se vocês se fundiu, esse histórico de diferenças entrará em colapso.

Felizmente, o reflog geralmente contém as informações que você deseja, conforme explicado em várias outras respostas aqui. Usa isto:

git reflog --date=local <branch>

para mostrar o histórico do ramo. A última entrada nesta lista é (provavelmente) o ponto em que você criou a ramificação.

Se a ramificação foi excluída, 'ramificação' não é mais um identificador válido do git, mas você pode usá-lo, o que pode encontrar o que você deseja:

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

Ou em um shell cmd do Windows:

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

Observe que o reflog não funcionará efetivamente em ramificações remotas, apenas nas que você trabalhou localmente.

Primeiro, se sua ramificação foi criada dentro de gc.reflogexpiredias (padrão 90 dias, ou seja, cerca de 3 meses), você pode usar git log -g <branch>ou git reflog show <branch>para encontrar a primeira entrada no reflog, que seria um evento de criação, e se parece com abaixo (para git log -g):

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

Você saberia quem criou um ramo, quantas operações atrás e de qual ramo (bem, pode ser apenas "Criado a partir do HEAD", o que não ajuda muito).

Foi o que MikeSep disse em sua resposta .

Segundo, se você tem ramificação por mais tempo gc.reflogexpiree executou git gc(ou foi executada automaticamente), teria que encontrar um ancestral comum com a ramificação da qual foi criada. Dê uma olhada no arquivo de configuração, talvez exista uma branch.<branchname>.mergeentrada, que diria em que ramo este se baseia.

Se você souber que a ramificação em questão foi criada fora da ramificação principal (bifurcação da ramificação principal), por exemplo, você pode usar o seguinte comando para ver o ancestral comum:

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

Você também pode tentar git show-branch <branch> master, como alternativa.

Foi o que gbacon disse em sua resposta .

Ainda não tenho certeza do comando git, mas acho que você pode encontrá-los nos reflogs.

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

Meus arquivos parecem ter um carimbo de data / hora unix.

Atualização: parece haver uma opção para usar o histórico de reflog em vez do histórico de confirmação ao imprimir os logs:

git log -g

Você também pode seguir esse log, quando criou a ramificação. git logestá mostrando a data da confirmação, no entanto, não a data em que você fez a ação que fez uma entrada no reflog. Ainda não encontrei isso, exceto olhando o reflog real no caminho acima.

Tente isto

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

Usar:

git reflog

para mostrar todo o ciclo de vida do seu repositório na pasta atual. O nome do ramo que aparece pela primeira vez (de baixo para cima) é a fonte que foi criada.

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

Isso significa:

• O desenvolvimento da filial é criado (checkout -b) a partir do mestre

• O recurso de ramificação-jira35 é criado (check-b) a partir do desenvolvimento

• A ramificação feature-jira-sut-46 é criada (checkout -b) a partir do desenvolvimento

Isso é algo que eu criei antes de encontrar esse tópico.

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

Este comando mostra a data da ramificação criada a devpartir demain

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

Se você deseja obter os detalhes de todas as filiais

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

Encontrei o melhor caminho: sempre verifico o último ramo criado dessa maneira

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

Combinado com a resposta de 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

Isso fez por mim: (10 anos depois)

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

Como não há informações armazenadas nos horários de criação da filial, o que isso faz é exibir o primeiro commit de cada branch ( --no-walk), que inclui a data do commit. Usar--remotes para as ramificações remotas ou omita-as nas ramificações locais.

Como faço pelo menos um commit em uma ramificação antes de criar outra, isso me permitiu rastrear alguns meses de criações de ramificações (e o recurso dev-start) para fins de documentação.

fonte: AnoE na stackexchange

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

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

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