Como imprimo uma lista dos meus aliases do git, ou seja, algo análogo ao aliascomando bash ?

Esta resposta baseia-se na resposta de johnny . Aplica-se, se você não está usando git-aliasa partir git-extras.

No Linux, execute uma vez:

git config --global alias.alias "! git config --get-regexp ^alias\. | sed -e s/^alias\.// -e s/\ /\ =\ /"

Isso criará um alias permanente do git chamado aliasque é armazenado no seu ~/.gitconfigarquivo. Usá-lo listará todos os seus aliases do git, quase no mesmo formato em que estão no ~/.gitconfigarquivo. Para usá-lo, digite:

$ git alias
loga = log --graph --decorate --name-status --all
alias = ! git config --get-regexp ^alias\. | sed -e s/^alias\.// -e s/\ /\ =\ /

As seguintes considerações se aplicam:

• Para impedir que o alias aliasseja listado como acima, acrescente um | grep -v ^'alias 'pouco antes da aspas duplas de fechamento. Eu não recomendo isso, para que os usuários não esqueçam que o comando aliasé apenas um alias e não é um recurso do git.

• Para classificar os aliases listados, acrescente um | sortpouco antes da aspas duplas de fechamento. Como alternativa, você pode manter os aliases ~/.gitconfigclassificados.

• Para adicionar o alias como um alias em todo o sistema, substitua --global(para usuário atual) por --system(para todos os usuários). Isso normalmente aparece no /etc/gitconfigarquivo.

Alias ​​do $ git config --get-regexp

Eu criei um alias do git chamado (estranhamente) aliaspara exatamente esse propósito ... útil de vez em quando se você usar o aliasing o suficiente ...

$ git config --global alias.alias "config --get-regexp ^alias\."

Observe que o regex garante que a linha comece com alias..

Outra alternativa (puramente algo que acho fácil de lembrar):

git config --list | grep alias

O seguinte funciona no Linux, MacOSX e Windows (com msysgit).

Use git la para mostrar aliases em .gitconfig

Eu ouvi 'bash scripting'? ;)

Sobre a parte 'não necessária' em um comentário acima, basicamente criei uma página de manual como visão geral para meus apelidos. Por que todo esse barulho? Isso não é um exagero completo?

Leia...

Eu configurei os comandos como este no meu .gitconfig, separados como TAB=TAB:

[alias]
        alias1            =            foo -x -y --z-option
        alias2            =            bar -y --z-option --set-something

e simplesmente definiu outro alias para saudar a TAB=parte dos alias definidos. (Todas as outras opções não têm guias antes e depois do '=' em sua definição, apenas espaços.)

Os comentários não anexados a um alias também têm um TAB=====anexo; portanto, eles são mostrados após o grepping.

Para uma melhor visualização, estou canalizando a saída grep para menos, assim:

versão básica: (preto / branco)

  #.gitconfig
  [alias]
        # use 'git h <command>' for help, use 'git la' to list aliases  =====
        h     =     help #... <git-command-in-question>
        la    =     "!grep '\t=' ~/.gitconfig | less" 

A \t=parte ' ' corresponde TAB=.

Para ter uma visão geral ainda melhor de quais aliases eu tenho e, desde que eu uso o console bash, pintei a saída com cores de terminal:

• todos '=' são impressos em vermelho
• todos os '#' são impressos em verde

versão avançada: (colorido)

       la      =       "!grep '\t=' ~/.gitconfig | sed -e 's/=/^[[0;31m=^[[0m/g' | sed -e 's/#.*/^[[0;32m&^[[0m/g' | less -R"

Basicamente o mesmo que acima, apenas o uso sed é adicionado para obter os códigos de cores na saída.

A -Rbandeira de menos é necessária para obter as cores mostradas em menos.

(Descobri recentemente que comandos longos com uma barra de rolagem embaixo da janela não são mostrados corretamente em dispositivos móveis: o texto é cortado e a barra de rolagem está simplesmente ausente. Esse pode ser o caso do último snippet de código aqui, mantenha-o em (observe os trechos de código aqui em movimento).

Por que fazer tanta mágica funcionar?

Eu tenho um tipo de meia milha de aliases, adaptados às minhas necessidades.
Além disso, alguns deles mudam com o tempo , portanto, a melhor idéia de ter uma lista atualizada em mãos é analisar o .gitconfig.

Um trecho curto **** dos meus aliases .gitconfig:

    #  choose       =====
    a       =       add #...
    aa      =       add .
    ai      =       add -i
    #  unchoose     =====
    rm      =       rm -r #... unversion and delete
    rmc     =       rm -r --cached #... unversion, but leave in working copy
    #  do   =====
    c       =       commit -m #...
    fc      =       commit -am "fastcommit"
    ca      =       commit -am #...
    mc      =       commit # think 'message-commit'
    mca     =       commit -a
    cam     =       commit --amend -C HEAD # update last commit
    #  undo =====
    r       =       reset --hard HEAD
    rv      =       revert HEAD

Nas minhas estações de trabalho linux ou mac também existem outros aliases nos .bashrc's, como:

#.bashrc
alias g="git"
alias gh="git h"
alias gla="git la"
function gc { git c "$*" } # this is handy, just type 'gc this is my commitmessage' at prompt

Dessa forma, não é necessário digitar git help submodule, não é necessário git h submodule, apenas gh submoduleé tudo o que é necessário para obter a ajuda. São apenas alguns caracteres, mas com que frequência você os digita?

Eu uso todos os itens a seguir, é claro, apenas com atalhos ...

• adicionar
• comprometer
• commit --amend
• reset --hard HEAD
• empurrar
• buscar
• rebase
• Verificação de saída
• ramo
• show-branch (em muitas variações)
• shortlog
• reflog
• diff (em variações)
• log (em muitas variações)
• status
• exposição
• notas
• ...

Isso foi apenas do topo da minha cabeça.

Geralmente, tenho que usar o git sem uma GUI, pois muitos dos comandos do git não são implementados corretamente em nenhuma das interfaces gráficas. Mas toda vez que eu os uso, é principalmente da mesma maneira.

Na parte 'não implementada' mencionada no último parágrafo:
Ainda preciso encontrar algo que se compare a isso em uma GUI:
sba = show-branch --color=always -a --more=10 --no-name- mostre todas as ramificações locais e remotas, bem como os commits que elas possuem
ccm = "!git reset --soft HEAD~ && git commit"- altere a última mensagem de confirmação

De um ponto de vista mais simples: com
que freqüência você digita git add .ou git commit -am "..."? Sem contar o resto ...
Fazer as coisas funcionarem como git aaou git ca "..."no Windows,
ou com aliases do bash gaa/ g aaou gca "..."/ g ca "..."no linux e no mac ...

Para minhas necessidades, parecia uma coisa inteligente a se fazer, adaptar comandos git como este ...
... e para facilitar o uso, eu apenas me ajudei a usar comandos menos utilizados, para que eu não precise consultar as páginas de manual todas as vezes. Os comandos são predefinidos e procurá-los é o mais fácil possível.

Quero dizer, afinal somos programadores? Fazer com que as coisas funcionem como precisamos delas é o nosso trabalho.

Aqui está uma captura de tela adicional, que funciona no Windows:

BÔNUS: Se você estiver no linux ou mac, as páginas de manual coloridas podem ajudá-lo um pouco:

páginas de manual coloridas

Usando git vare filtrando apenas aqueles que começam com alias:

git var -l | grep -e "^alias"

Como outras respostas mencionadas, git config -llista todos os detalhes de sua configuração do seu arquivo de configuração. Aqui está um exemplo parcial dessa saída para minha configuração:

...
alias.force=push -f
alias.wd=diff --color-words
alias.shove=push -f
alias.gitignore=!git ls-files -i --exclude-from=.gitignore | xargs git rm --cached
alias.branches=!git remote show origin | grep \w*\s*(new^|tracked) -E
core.repositoryformatversion=0
core.filemode=false
core.bare=false
...

Assim, podemos destacar as linhas de alias usando git config -l | grep alias:

alias.force=push -f
alias.wd=diff --color-words
alias.shove=push -f
alias.gitignore=!git ls-files -i --exclude-from=.gitignore | xargs git rm --cached
alias.branches=!git remote show origin | grep \w*\s*(new^|tracked) -E

Podemos tornar isso mais bonito, apenas cutdestacando a alias.parte de cada linha, deixando-nos com este comando:

git config -l | grep alias | cut -c 7-

Que imprime:

force=push -f
wd=diff --color-words
shove=push -f
gitignore=!git ls-files -i --exclude-from=.gitignore | xargs git rm --cached
branches=!git remote show origin | grep \w*\s*(new^|tracked) -E

Por fim, não se esqueça de adicionar isso como um alias:

git config --global alias.la "!git config -l | grep alias | cut -c 7-"

Aproveitar!

para Windows:

git config --list | findstr "alias"

Eu mencionei em junho de 2018 com a " lista de visão geral - comandos git mais usados ", o Git 2.18 "use --list-cmds=alias( commit 3301d36 )", que carej relata em sua resposta .

 git --list-cmds=alias

Além disso ou de git config --get-regexp alias, você pode combinar sua saída com git help, cuja saída será alterada com o Git 2.14.x / 2.15:

" git help co" agora diz " co is aliased to ...", não " git co is".

Consulte commit b3a8076 (12 de setembro de 2017) por Kaartic Sivaraam ( sivaraam) .
^{(Mesclado por Junio ​​C Hamano - gitster- na confirmação 5079cc8 , 25 de setembro de 2017)}

help: altere uma mensagem para ser mais preciso

Quando o usuário tenta usar a --helpopção ' ' em um comando com alias, as informações sobre o alias são impressas como mostrado abaixo:

$ git co --help
`git co' is aliased to `checkout'

Isso não parece correto, pois o usuário alias apenas ' co' e não ' git co'.
Isso pode até estar incorreto nos casos em que o usuário usou um alias como ' tgit'.

$ tgit co --help
`git co' is aliased to `checkout'

Pesquisar ou mostrar todos os aliases

Adicione ao seu .gitconfigsob [alias]:

aliases = !git config --list | grep ^alias\\. | cut -c 7- | grep -Ei --color \"$1\" "#"

Então você pode fazer

• git aliases - mostrar TODOS os aliases
• git aliases commit - apenas aliases contendo "commit"

Eu uso esse alias no meu global~/.gitconfig

# ~/.gitconfig

[alias]
    aliases = !git config --get-regexp ^alias\\. | sed -e s/^alias.// -e s/\\ /\\ $(printf \"\\043\")--\\>\\ / | column -t -s $(printf \"\\043\") | sort -k 1

para produzir a seguinte saída

$ git aliases
aliases   --> !git config --get-regexp ^alias\. | sed -e s/^alias.// -e s/\ /\ $(printf "\043")--\>\ / | column -t -s $(printf "\043") | sort -k 1
ci        --> commit -v
cim       --> commit -m
co        --> checkout
logg      --> log --graph --decorate --oneline
pl        --> pull
st        --> status
...       --> ...

( Nota: Isso funciona para mim no git bash no Windows . Para outros terminais, pode ser necessário adaptar o escape. )

Explicação

1. !git config --get-regexp ^alias\\. imprime todas as linhas do git config que começam com alias.
2. sed -e s/^alias.//remove alias.da linha
3. sed -e s/\\ /\\ $(printf \"\\043\")--\\>\\ /substitui a primeira ocorrência de um espaço por \\ $(printf \"\\043\")--\\>(que é avaliado como #-->).
4. column -t -s $(printf \"\\043\")formata todas as linhas em uma tabela de colunas com espaçamento uniforme. O caractere $(printf \"\\043\")que avalia #é usado como separador.
5. sort -k 1 classifica todas as linhas com base no valor na primeira coluna

$ (printf \ "\ 043 \")

Isso apenas imprime o caractere #(hexadecimal 043) que é usado para a separação da coluna. Eu uso esse pequeno truque para que o aliases apelido em si não contenha literalmente o #personagem. Caso contrário, ele substituiria esses #caracteres ao imprimir. Nota : Altere para outro caractere se precisar de aliases com #sinais literais .

Há uma função interna ... tente

$ __git_aliases

lista todos os aliases :)

Se você souber o nome do alias, poderá usar a --helpopção para descrevê-lo. Por exemplo:

$ git sa --help
`git sa' is aliased to `stash'

$ git a --help
`git a' is aliased to `add'

A partir do git 2.18, você pode usar git --list-cmds=alias

Ainda outro gitalias (chamado alias) que imprime aliases do git: adicione o seguinte à sua [alias]seção gitconfig :

[alias]
    # lists aliases matching a regular expression
    alias = "!f() { git config --get-regexp "^alias.${1}$" ; }; f"

Exemplo de uso, fornecendo o nome completo do alias (corresponde exatamente ao nome do alias: ie, ^foobar$) e simplesmente mostra o valor:

$ git alias st
alias.st status -s

$ git alias dif
alias.dif diff

Ou, forneça regexp, que mostra todos os aliases e valores correspondentes:

$ git alias 'dif.*'
alias.dif diff
alias.difs diff --staged
alias.difh diff HEAD
alias.difr diff @{u}
alias.difl diff --name-only

$ git alias '.*ing'
alias.incoming !git remote update -p; git log ..@{u}
alias.outgoing log @{u}..

Advertências: cite o regexp para impedir a expansão do shell como um globo, embora não seja tecnicamente necessário se / quando nenhum arquivo corresponder ao padrão. Além disso: qualquer regexp é bom, exceto ^(início do padrão) e $(final do padrão) não podem ser usados; eles estão implícitos. Assume que você não está usando git-aliasa partir git-extras.

Além disso, obviamente, seus apelidos serão diferentes; estes são apenas alguns que eu configurei. (Talvez você os ache úteis também.)