Como obter o nome da tag mais recente na ramificação atual no Git?

462

Qual é a maneira mais simples de obter a tag mais recente no Git?

git tag a HEAD
git tag b HEAD^^
git tag c HEAD^
git tag

resultado:

a
b
c

Devo escrever um script para obter o datetime de cada tag e compará-los?

culebrón
fonte
1
última tag criada ou última tag ordenada por data de confirmação? Sua resposta aceita mostra a última tag criada. Este poderia ser um problema se um decida alterar as tags existig ...
Paebbels

Respostas:

412

Você pode dar uma olhada git describe, o que faz algo parecido com o que você está perguntando.

JB.
fonte
194
Com --abbrev=0ele deve retornar mais próximo anotada tag
Jakub Narębski
13
Retorna a tag mais recente na ramificação atual.
precisa saber é o seguinte
42
Para obter a tag anotada mais recente que segmenta apenas a confirmação atual na ramificação atual , use git describe --exact-match --abbrev=0.
Naftuli Kay
5
Esta resposta, com comentários, não forneceu a tag correta para mim. A @kilianic forneceu uma solução correta.
Herman J. Radtke III
20
git describe --tagse compare a última tag com na página de lançamento do github
Adriano Resende
627

Para obter a tag mais recente:

git describe --tags

Para obter a tag anotada mais recente :

git describe --abbrev=0
acassis
fonte
2
Sim, como a página man git describediz: --abbrev=<n> [...] An <n> of 0 will suppress long format, only showing the closest tag.
Giorgos Kylafas
22
Ou apenasgit describe --tags
james_womack 16/05
5
Esta resposta (e provavelmente as outras) terá problemas se você tiver duas tags apontando para o mesmo commit. A menos que as tags sejam anotadas, acho que não há como o git distinguir qual das duas foi criada anteriormente.
Paul Lynch
10
Essa deve ser a resposta aceita. Obrigado por enviar.
Crmpicco 17/07/2014
6
se você quiser fazer checkout diretamente da tag mais recente:git checkout $(git describe --abbrev=0 --tags)
JohnRDOrazio 26/08
321

Produzirá a tag do último commit marcado em todas as ramificações

git describe --tags $(git rev-list --tags --max-count=1)
kilianc
fonte
8
ou TAG=$(git describe --tags $(git rev-list --tags --max-count=1))@ william-pursell
kilianc
20
Esta é a melhor resposta. Na verdade, ele recebe tags em todos os ramos, não apenas no ramo atual, como a resposta "correta" atual.
brittohalloran
61
Exceto que a pergunta solicita especificamente a ramificação atual.
24512 michaeltwofish
3
@michaeltwofish, na época em que não sabia, descobri mais tarde e corrigi a resposta de acordo. Me desculpe por isso.
#
3
Notas: Este comando retorna a tag "mais recente", mesmo que essa tag esteja em outro ramo.
Alan Zhiliang Feng
47

Para obter a tag mais recente, você pode:

$ git for-each-ref refs / tags --sort = -taggerdate --format = '% (refname)' --count = 1

Obviamente, você pode alterar o argumento de contagem ou o campo de classificação, conforme desejado. Parece que você pretende fazer uma pergunta um pouco diferente, mas isso responde à pergunta como eu a interpreto.

William Pursell
fonte
2
Isto é quase exatamente o que eu estava procurando (o tag mais recente em todos os ramos), mas pelo menos com a minha versão do git (1.7.7.6) as tags são produzidos na mesma ordem para ambos --sort=-authordatee --sort=authordate.
Larsks
3
Aha, porque o que você realmente quer é --sort=-taggerdate. Para tags authordatee committerdateestá vazio (tão inútil quanto as chaves de classificação).
Larsks
8
git for-each-ref refs/tags --sort=-taggerdate --format='%(refname:short)' --count=1é ainda melhor :)
Christophe Eblé 12/11/2015
5
Realmente, recusando uma resposta perfeitamente correta com quase 5 anos de idade sem um comentário? Isso é rude.
William Pursell
1
E --points-at=$SHAfornecerá a tag para um hash de confirmação.
Ryan
35

Que tal agora?

TAG=$(git describe $(git rev-list --tags --max-count=1))

Tecnicamente, você não necessariamente obterá a tag mais recente, mas o commit mais recente que está marcado, que pode ou não ser o que você está procurando.

Wincent Colaiuta
fonte
Este não obtém a tag mais recente na ramificação atual, mas em quaisquer ramificações. O que é ótimo, porque é exatamente o que eu precisava. Obrigado Wincent.
Jasongregori
2
Se você precisar obter o padrão de correspondência de tags, poderá usá --tags=<pattern>-lo rev-list. Por exemplo, obtenha a tag da última versãogit describe --tags $(git rev-list --tags='v[0-9].[0-9]*' --max-count=1)
Wirone
1
$ (git description --contains $ (git rev-parse HEAD))
Vaidas Zilionis
Obrigado, funcionou, mas eu tive que adicionargit describe --tags $(git rev-list --tags --max-count=1)
Gianluca Casati
25

Você pode executar: git describe --tags $(git rev-list --tags --max-count=1)falou aqui: Como obter o nome da tag mais recente?

xserrat
fonte
Comecei com a resposta mais aceita / aceitei e desci. Esta é a primeira resposta que realmente me dá a última tag (não sei porquê, mas simples antigos git describe ...retorna uma tag antes ?!)
Jeremy Davis
Este é o único que funciona para mim. Tentei algumas das --abbrev=0respostas e eles cortaram parte da tag que eu quero.
Luke Davis
22

"Mais recente" pode ter dois significados em termos de git.

Você pode dizer "qual tag tem a data de criação mais recente" e a maioria das respostas aqui são para essa pergunta. Em termos de sua pergunta, você deseja retornar a tagc .

Ou você pode significar "qual tag é a mais próxima do histórico de desenvolvimento de algum ramo nomeado", geralmente o ramo em que você está HEAD,. Na sua pergunta, isso retornaria a taga .

Estes podem ser diferentes, é claro:

A->B->C->D->E->F (HEAD)
       \     \
        \     X->Y->Z (v0.2)
         P->Q (v0.1)

Imagine que o desenvolvedor marcou Zcomo v0.2segunda-feira e depois Qcomo v0.1terça-feira. v0.1é o mais recente, masv0.2 está mais próximo na história do desenvolvimento do HEAD, no sentido de que o caminho em que ele começa começa em um ponto mais próximo do HEAD.

Eu acho que você geralmente quer essa segunda resposta, mais próxima da história do desenvolvimento. Você pode descobrir isso usando git log v0.2..HEADetc para cada tag. Isso fornece o número de confirmações no HEAD desde o caminho que termina emv0.2 divergiu do caminho seguido por HEAD.

Aqui está um script Python que faz isso iterando todas as tags que executam essa verificação e, em seguida, imprimindo a tag com menos confirmações no HEAD, pois o caminho da tag divergiu:

https://github.com/MacPython/terryfy/blob/master/git-closest-tag

git describefaz algo um pouco diferente, na medida em que rastreia de (por exemplo) HEAD para encontrar a primeira tag que está no caminho de volta da história a partir de HEAD. Em termos de git, git describeprocura por tags "acessíveis" a partir do HEAD. Portanto, ele não encontrará tags como v0.2essas que não estão no caminho de volta do HEAD, mas em um caminho que divergiu a partir daí.

Matthew Brett
fonte
21

git describe --tags

retorna a última tag capaz de ser vista pelo ramo atual

beenhere4hours
fonte
15
git log --tags --no-walk --pretty="format:%d" | sed 2q | sed 's/[()]//g' | sed s/,[^,]*$// | sed  's ......  '

SE VOCÊ PRECISA DE MAIS DE UM ÚLTIMO TAG

(git descrevem - tags às vezes dão hashes errados, eu não sei por que, mas para mim --max-count 2 não funciona)

é assim que você pode obter a lista com os 2 últimos nomes de tags em ordem cronológica reversa, funciona perfeitamente no git 1.8.4. Para versões anteriores do git (como 1.7. *), Não há "tag:" string na saída - apenas exclua a última chamada sed

Se você quiser mais de duas tags mais recentes - altere "sed 2q" para "sed 5q" ou o que você precisar

Em seguida, você pode analisar facilmente cada nome de tag como variável.

leste
fonte
isso é realmente útil, muitos desenvolvedores tentarão automatizar o processo de lançamento revertendo para a tag anterior se a implantação for interrompida. Coisas incríveis !!!
AKD
1
Para levar isso adiante: git log --tags --no-walk --pretty="format:%D" | sed -nr '5q;s;^.*(tag: )([^,]*).*;\2;p' where in %Dexclui os ()caracteres circundantes , e o seds inicial 5q deixa 4 linhas antes de 5, depois imprime todos os caracteres entre 'tag: `e o primeiro', '. Então ... supondo que nenhuma vírgula seja usada dentro da tag, isso funciona perfeitamente.
Cometsong 21/02/19
14

O que há de errado com todas as sugestões (exceto a explicação de Matthew Brett , atualizada nesta resposta)?

Basta executar qualquer comando fornecido por outro no histórico do jQuery Git quando você estiver em um ponto diferente do histórico e verificar o resultado com a representação visual do histórico de marcação (eu fiz por isso que você vê este post):

$ git log --graph --all --decorate --oneline --simplify-by-decoration

Atualmente, muitos projetos realizam lançamentos (e, portanto, marcam) em ramificações separadas da linha principal .

fortes razões para isso. Basta olhar para qualquer projeto JS / CSS bem estabelecido. Para convenções de usuários, eles carregam arquivos de liberação binária / minificada no DVCS. Naturalmente, como mantenedor do projeto, você não deseja descartar o histórico de diferenças da linha principal com blobs binários inúteis e executar o commit de artefatos de construção fora da linha principal .

Como o Git usa o DAG e não o histórico linear - é difícil definir a métrica da distância para que possamos dizer - oh, essa rev é a mais próxima da minha HEAD!

Começo minha própria jornada (olhe para dentro, não copiei imagens de prova sofisticadas para este longo post):

Qual é a tag mais próxima no passado em relação à ramificação no Git?

Atualmente, tenho 4 definições razoáveis ​​de distância entre tag e revisão com diminuição da utilidade:

  • comprimento de percurso mais curto a partir HEADde base de intercalação com tag
  • data da base de mesclagem entre HEADe tag
  • número de rotações alcançáveis ​​a partir de HEAD, mas não alcançáveis ​​a partir da tag
  • data da tag, independentemente da base de mesclagem

Não sei como calcular o comprimento do caminho mais curto .

Script que classifica as tags de acordo com a data da base de mesclagem entre HEADe tag:

$ git tag \
     | while read t; do \
         b=`git merge-base HEAD $t`; \
         echo `git log -n 1 $b --format=%ai` $t; \
       done | sort

É utilizável na maioria dos projetos.

Script que classifica as tags de acordo com o número de rotações alcançáveis ​​a partir de HEAD, mas não alcançáveis ​​a partir da tag:

$ git tag \
    | while read t; do echo `git rev-list --count $t..HEAD` $t; done \
    | sort -n

Se o histórico do seu projeto tiver datas estranhas nas confirmações (devido a rebase ou outra reescrita do histórico ou algum idiota, esqueça de substituir a bateria do BIOS ou outras mágicas que você faz no histórico) use o script acima.

Para a última opção ( data da tag, independentemente da base de mesclagem ), para obter a lista de tags classificadas por data, use:

$ git log --tags --simplify-by-decoration --pretty="format:%ci %d" | sort -r

Para conhecer a data atual da revisão, use:

$ git log --max-count=1

Observe que eles git describe --tagstêm uso em seus próprios casos, mas não para encontrar a marca mais próxima esperada humana no histórico do projeto .

NOTA Você pode usar as receitas acima em qualquer revisão, basta substituir HEADpelo que deseja!

gavenkoa
fonte
12

git describe --abbrev=0 --tags

Se você não vir a tag mais recente, verifique a busca da origem antes de executar:

git remote update

Walter B
fonte
12
git tag -l ac* | tail -n1

Obtenha a última tag com o prefixo "ac" . Por exemplo, tag nomeada com ac1.0.0, ou ac1.0.5. Outras marcas nomeados 1.0.0, 1.1.0serão ignorados.

git tag -l [0-9].* | tail -n1

Obtenha a última tag, cujo primeiro caractere é 0-9. Portanto, essas tags com o primeiro caractere a-zserão ignoradas.

Mais informações

git tag --help # Help for `git tag`

git tag -l <pattern>

Listar tags com nomes que correspondam ao padrão fornecido (ou todos, se nenhum padrão for fornecido). Executar "tag git" sem argumentos também lista todas as tags. O padrão é um curinga do shell (ou seja, corresponde ao uso de fnmatch (3)). Padrões múltiplos podem ser dados; se algum deles corresponder, a tag será mostrada.


tail -n <number> # display the last part of a file
tail -n1 # Display the last item 

Atualizar

Com git tag --help, sobre o sortargumento. Ele será usado lexicorgraphic orderpor padrão, se a tag.sortpropriedade não existir.

O padrão da ordem de classificação é o valor configurado para a variável tag.sort, se existir, ou a ordem lexicográfica, caso contrário. Veja git-config (1).

Depois do google, alguém disse que o suporte ao git 2.8.0 segue a sintaxe.

git tag --sort=committerdate
AechoLiu
fonte
não é wok para mim, a última tag é 2.11.174, mas esta impressão é 2.11.99 porque não é classificada como versionamento
Ali.MD 17/16
8
git tag --sort=committerdate | tail -1
user2957741
fonte
Explique como esse trecho de código resolverá o problema, em vez de postar uma resposta somente de código.
Arun Vinoth
5

O seguinte funciona para mim, caso você precise das duas últimas tags (por exemplo, para gerar um log de alterações entre a tag atual e a tag anterior). Eu testei apenas na situação em que a última tag foi HEAD.

PreviousAndCurrentGitTag=`git describe --tags \`git rev-list --tags --abbrev=0 --max-count=2\` --abbrev=0`
PreviousGitTag=`echo $PreviousAndCurrentGitTag | cut -f 2 -d ' '`
CurrentGitTag=`echo $PreviousAndCurrentGitTag | cut -f 1 -d ' '`

GitLog=`git log ${PreviousGitTag}..${CurrentGitTag} --pretty=oneline | sed "s_.\{41\}\(.*\)_; \1_"`

Atende às minhas necessidades, mas como não sou um git wizard, tenho certeza de que poderia ser melhorado ainda mais. Eu também suspeito que isso será interrompido caso o histórico de consolidação avance. Estou apenas compartilhando, caso isso ajude alguém.

Ivan Vučica
fonte
4

Meu primeiro pensamento é que você poderia usar git rev-list HEAD, que lista todas as rotações em ordem cronológica reversa, em combinação com git tag --contains. Quando você encontra uma referência onde git tag --containsproduz uma lista não vazia, você encontra as tags mais recentes.

Greg Hewgill
fonte
4

Se você deseja encontrar a última tag que foi aplicada em uma ramificação específica, tente o seguinte:

git describe --tag $(git rev-parse --verify refs/remotes/origin/"branch_name")
Scyssion
fonte
3

Se você precisar de um liner que obtenha o nome mais recente da tag (por data da tag) na ramificação atual :

git for-each-ref refs/tags --sort=-taggerdate --format=%(refname:short) --count=1 --points-at=HEAD

Usamos isso para definir o número da versão na configuração.

Exemplo de saída:

v1.0.0

Também funciona no Windows.

Markus
fonte
1
No Linux (Debian Stretch) eu recebo-bash: syntax error near unexpected token '('
Jeremy Davis
1
Se eu envolver essa parte entre aspas (ou seja --format="%(refname:short)") e pular o texto, --points-at=HEADele funcionará. Com essa última opção, ele não retorna nada, acho que porque o meu HEADnão está marcado?
Jeremy Davis
@ JeremyDavis, sim, acho que é porque o seu HEADnão está marcado.
Markus
2

Este é um tópico antigo, mas parece que muitas pessoas estão perdendo a resposta mais simples, fácil e correta à pergunta do OP: para obter a última tag do ramo atual , usegit describe HEAD . Feito.

Editar: você também pode fornecer qualquer nome de referência válido, mesmo controles remotos; ou seja, git describe origin/masterinformará a tag mais recente que pode ser acessada a partir da origem / mestre.

dohpaz42
fonte
Nada garante que "a tag mais recente" seja manipulada por qualquer ramificação. As duas soluções de trabalho são o for-each-refcomando ( stackoverflow.com/a/5261470/515973 ) e a combinação de rev-liste describe( stackoverflow.com/a/7979255/515973 )
Julien Carsique
1
Isso não recebe a tag mais recente para mim.
K - A toxicidade no SO está crescendo.
git describe branchname --tagsnão trabalho para mim para receber as últimas tag no ramo (git versão 2.12.2)
Rob_M
0

Para obter a tag mais recente apenas no nome da filial / marca atual que prefixa a filial atual, tive que executar o seguinte

BRANCH=`git rev-parse --abbrev-ref HEAD` && git describe --tags --abbrev=0 $BRANCH^ | grep $BRANCH

Mestre da filial:

git checkout master

BRANCH=`git rev-parse --abbrev-ref HEAD` && git describe --tags 
--abbrev=0 $BRANCH^ | grep $BRANCH

master-1448

Filial personalizada:

git checkout 9.4

BRANCH=`git rev-parse --abbrev-ref HEAD` && git describe --tags 
--abbrev=0 $BRANCH^ | grep $BRANCH

9.4-6

E minha necessidade final de incrementar e obter a tag +1 para a próxima tag.

BRANCH=`git rev-parse --abbrev-ref HEAD` && git describe --tags  --abbrev=0 $BRANCH^ | grep $BRANCH | awk -F- '{print $NF}'
Sankarganesh Eswaran
fonte
0

Para a pergunta feita,

Como obter o nome da tag mais recente na ramificação atual

você quer

git log --first-parent --pretty=%d | grep -m1 tag:

--first-parentdiz git logpara não detalhar nenhuma história mesclada, --pretty=%ddiz para mostrar apenas as decorações, ou seja, nomes locais para quaisquer confirmações. grep -m1diz "corresponder a apenas um", para que você obtenha apenas a tag mais recente.

jthill
fonte
0

se suas tags puderem ser classificadas:

git tag --merged $YOUR_BRANCH_NAME | grep "prefix/" | sort | tail -n 1
Clintm
fonte
0

Não há muita menção de tags não anotadas versus tags anotadas aqui. 'description' funciona em tags anotadas e ignora as não anotadas.

Isso é feio, mas faz o trabalho solicitado e não encontrará nenhuma tag em outras ramificações (e não na especificada no comando: master no exemplo abaixo)

A filtragem provavelmente deve ser otimizada (consolidada), mas, novamente, isso parece funcionar.

git log  --decorate --tags master |grep '^commit'|grep 'tag:.*)$'|awk '{print $NF}'|sed 's/)$//'|head -n 1

As críticas são bem-vindas, pois agora vou colocar isso em uso :)

Rondó
fonte
-2

Outra maneira simples de obter o nome da tag mais recente é com

git tag | tail -1

ou

TAG=$(git tag | tail -1)

para armazená-lo em uma variável.

git taglista todas as tags disponíveis e retornará a última linha se o resultado.tail-1

Xaver
fonte
4
Sem classificação, esta é uma má jogada.
Mjd2