terminal tags - Aliases do Git de lista




sort checkout (13)

Como faço para imprimir uma lista dos meus apelidos git, isto é, algo análogo ao comando bash alias ?


Answers

Pesquisar ou mostrar todos os aliases

Adicione ao seu .gitconfig sob [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 - somente aliases contendo "commit"

Existe uma função incorporada ... tente

$ __git_aliases

lista todos os aliases :)


$ git config --get-regexp alias

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

[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 ao nome do alias exatamente: isto é, ^foobar$ ) e simplesmente mostra o valor:

$ git alias st
alias.st status -s

$ git alias dif
alias.dif diff

Ou, dê 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 [email protected]{u}
alias.outgoing log @{u}..

Advertências: cite o regexp para evitar a expansão do shell como glob, 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 $ (fim do padrão) não pode ser usado; eles estão implícitos. Supõe que você não esteja usando o git-alias do git-extras .

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


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, eu basicamente criei uma página de manual como visão geral para meus aliases. Por que todo esse barulho? Isso não é um exagero total?

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 grep a parte TAB = dos aliases definidos. (Todas as outras opções não possuem abas 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 = = = = = acrescentado, então eles são mostrados após o grepping.

Para uma melhor visualização, estou colocando a saída do grep em 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 parte ' \t= ' corresponde a TAB = .

Para ter uma visão geral ainda melhor de quais aliases eu tenho, e desde que eu uso o console bash, eu colori 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.

O sinalizador -R de menos é necessário para obter as cores mostradas em menos.

(Descobri recentemente que os comandos longos com uma barra de rolagem na janela não são mostrados corretamente em dispositivos móveis: o texto é cortado e a barra de rolagem simplesmente está faltando. Esse pode ser o caso do último trecho de código aqui, mantenha isso em lembre-se quando olhar para os trechos de código aqui enquanto estiver em movimento.)

Por que essa magia funciona?

Eu tenho uma meia milha de aliases, adaptada às minhas necessidades.
Além disso, algumas delas mudam ao longo do tempo , então, depois de toda a melhor idéia para ter uma lista atualizada, está analisando o .gitconfig.

Um **** 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

Em minhas estações de trabalho linux ou mac também existem aliases adicionais nos .bashrc, 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 há necessidade de digitar o git help submodule , não há necessidade de git h submodule , apenas o gh submodule é tudo o que é necessário para obter ajuda. São apenas alguns personagens, mas com que frequência você os digita?

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

  • adicionar
  • cometer
  • commit --endend
  • reset --hard HEAD
  • empurrar
  • buscar
  • rebase
  • Confira
  • 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.

Eu geralmente tenho que usar o git sem um gui, já que muitos dos comandos do git não são implementados corretamente em nenhum dos frontends gráficos. Mas toda vez que eu os uso, é basicamente da mesma maneira.

Na parte "não implementada" mencionada no último parágrafo:
Eu ainda tenho que encontrar algo que se compare a isso em uma interface gráfica:
sba = show-branch --color=always -a --more=10 --no-name - mostra todos os ramos locais e remotos, bem como os commits que eles têm dentro deles
ccm = "!git reset --soft HEAD~ && git commit" - altera a última mensagem de commit

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

Para as minhas necessidades, parecia uma coisa inteligente de se fazer, para adaptar comandos git como este ...
... e para facilitar o uso eu apenas me ajudei para comandos menos usados, então eu não tenho que consultar as páginas de manual toda vez. Comandos são pré-definidos e procurá-los é o mais fácil possível.

Quero dizer, somos programadores afinal de contas? Fazer as coisas funcionarem como precisamos é o nosso trabalho.

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

BONUS: Se você está no linux ou no mac, as man pages coloridas podem te ajudar bastante:

páginas de homem coloridas


Eu uso este 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, talvez seja necessário adaptar o escape. )

Explicação

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

$ (printf \ "\ 043 \")

Isto apenas imprime o caractere # (hexadecimal 043) que é usado para separação de colunas. Eu uso esse pequeno truque para que o próprio aliases não contenha literalmente o caractere # . Caso contrário, substituiria esses caracteres # ao imprimir. Nota : Altere isso para outro caractere se você precisar de aliases com sinais # literais.


Esta resposta é baseada na answer de . Aplica-se se você não estiver usando o git-alias do git-extras .

No Linux, execute uma vez:

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

Isto irá criar um alias git permanente chamado alias que é armazenado em seu arquivo ~/.gitconfig . Usá-lo listará todos os aliases do seu git, quase no mesmo formato em que estão no arquivo ~/.gitconfig . 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 opcionais se aplicam:

  • Para evitar que o alias alias seja listado como acima, acrescente | grep -v ^'alias ' | grep -v ^'alias ' antes do aspas duplas finais. Eu não recomendo isso para usuários do Linux para que eles não esqueçam que o alias do comando é apenas um alias e não é um recurso do git.

  • Para classificar os aliases listados, acrescente | sort | sort pouco antes do aspas duplas finais. Como alternativa, você pode manter os aliases em ~/.gitconfig classificados.

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


para Windows:

git config --list | findstr "alias"

Como outras respostas mencionadas, o git config -l lista todos os seus detalhes de 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
...

Então podemos grep out as linhas alias, usando git config -l | grep alias 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 simplesmente cut o 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-"

Apreciar!


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

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

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


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

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

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

Usando git var e filtrando apenas aqueles que iniciam com alias :

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

Outros garotos e garotas dão as soluções, mas talvez eu possa lhe dizer por quê.

teste de checkout git que não faz nada

Does nothing faz Does nothing não igual doesn't work , então eu acho que quando você digita 'git checkout test' no seu terminal e pressiona a tecla Enter, nenhuma mensagem aparece e nenhum erro ocorre. Estou certo?

Se a resposta for "sim", posso dizer-lhe a causa.

A causa é que existe um arquivo (ou pasta) chamado 'teste' na sua árvore de trabalho.

Quando git checkout xxx analisado,

  1. Git parece em xxx como um nome de ramificação no início, mas não há nenhum ramo chamado test.
  2. Então Git pensa que xxx é um caminho e, felizmente (ou infelizmente), existe um arquivo chamado test. Então git checkout xxx significa descartar qualquer modificação no arquivo xxx .
  3. Se não houver um arquivo chamado xxx , o Git tentará criar o xxx acordo com algumas regras. Uma das regras é criar uma ramificação denominada xxx se remotes/origin/xxx existirem.






git terminal alias