Come faccio a stampare un elenco dei miei alias git, ovvero qualcosa di analogo al aliascomando bash ?

Questa risposta si basa sulla risposta di Johnny . Si applica se non si utilizza git-aliasda git-extras.

Su Linux, esegui una volta:

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

Questo creerà un alias git permanente chiamato aliasche viene memorizzato nel tuo ~/.gitconfigfile. Usandolo elencherà tutti i tuoi alias git, quasi nello stesso formato in cui si trovano nel ~/.gitconfigfile. Per usarlo, digitare:

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

Si applicano le seguenti considerazioni:

• Per evitare che l'alias aliasvenga elencato come sopra, aggiungi | grep -v ^'alias 'poco prima della doppia virgoletta di chiusura. Non lo consiglio quindi gli utenti non dimenticano che il comando aliasè solo un alias e non è una funzionalità di git.

• Per ordinare gli alias elencati, aggiungi | sortsubito prima della doppia virgoletta di chiusura. In alternativa, è possibile mantenere gli alias in ~/.gitconfigordine.

• Per aggiungere l'alias come alias a livello di sistema, sostituire --global(per l'utente corrente) con --system(per tutti gli utenti). Questo in genere va nel /etc/gitconfigfile.

$ git config - alias -get-regexp

Ho creato un alias git chiamato (abbastanza stranamente) aliasproprio per questo scopo ... utile di tanto in tanto se usi abbastanza alias ...

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

Nota, regex si assicura che la linea inizi con alias..

Un'altra alternativa (puramente qualcosa che trovo facile da ricordare):

git config --list | grep alias

Quanto segue funziona su Linux, MacOSX e Windows (con msysgit).

Usa git la per mostrare gli alias in .gitconfig

Ho sentito "bash scripting"? ;)

A proposito della parte "non necessaria" in un commento sopra, ho praticamente creato una pagina man come panoramica per i miei alias. Perché tutto il clamore? Non è un eccesso eccessivo?

Continuare a leggere...

Ho impostato i comandi in questo modo nel mio .gitconfig, separati come TAB=TAB:

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

e semplicemente definito un altro alias per grep la TAB=parte degli alias definiti. (Tutte le altre opzioni non hanno schede prima e dopo il '=' nella loro definizione, solo spazi.)

Anche i commenti non aggiunti a un alias hanno un TAB=====allegato, quindi vengono visualizzati dopo il grepping.

Per una migliore visualizzazione, sto eseguendo il piping dell'output grep in meno, in questo modo:

versione base: (bianco / nero)

  #.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" 

La parte ' \t=' corrisponde TAB=.

Per avere una panoramica ancora migliore di ciò che ho alias e, dato che utilizzo la console bash, ho colorato l'output con i colori dei terminali:

• tutti '=' sono stampati in rosso
• tutti i '#' sono stampati in verde

versione avanzata: (colorata)

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

Sostanzialmente come sopra, viene aggiunto solo l' uso di sed per ottenere i codici colore nell'output.

La -Rbandiera di less è necessaria per visualizzare i colori in meno.

(Di recente ho scoperto che i comandi lunghi con una barra di scorrimento sotto la loro finestra non vengono visualizzati correttamente sui dispositivi mobili: il testo viene troncato e la barra di scorrimento è semplicemente mancante. Potrebbe essere il caso dell'ultimo frammento di codice qui, tenerlo presente attenzione quando guardi i frammenti di codice qui mentre sei in movimento.)

Perché far funzionare tale magia?

Ho un mezzo miglio di alias, su misura per le mie esigenze.
Inoltre alcuni di essi cambiano nel tempo , quindi dopo tutto l'idea migliore di avere un elenco aggiornato a portata di mano è l'analisi di .gitconfig.

Un breve **** estratto dal mio alias .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

Nelle mie workstation Linux o Mac esistono anche altri alias nei .bashrc, in qualche modo simili:

#.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

In questo modo non è necessario digitare git help submodule, non è necessario git h submodule, gh submoduleè tutto ciò che serve per ottenere aiuto. Sono solo alcuni personaggi, ma quanto spesso li digiti?

Uso tutto quanto segue, ovviamente solo con le scorciatoie ...

• Inserisci
• commettere
• commit --amend
• reset --hard HEAD
• Spingere
• andare a prendere
• rebase
• check-out
• ramo
• show-branch (in molte varianti)
• shortlog
• reflog
• diff (nelle variazioni)
• log (in molte varianti)
• stato
• mostrare
• Appunti
• ...

Questo era proprio dalla cima della mia testa.

Spesso devo usare git senza una GUI, poiché molti comandi git non sono implementati correttamente in nessuno dei frontend grafici. Ma ogni volta che li metto in uso, è per lo più allo stesso modo.

Nella parte "non implementata" menzionata nell'ultimo paragrafo:
devo ancora trovare qualcosa di paragonabile a questo in una GUI:
sba = show-branch --color=always -a --more=10 --no-name- mostra tutti i rami locali e remoti, nonché i commit che hanno al loro interno
ccm = "!git reset --soft HEAD~ && git commit"- cambia l'ultimo messaggio di commit

Da un punto di vista più semplice: con quale
frequenza digiti git add .o git commit -am "..."? Senza contare anche il resto ...
Far funzionare le cose come git aao git ca "..."in Windows,
o con alias bash gaa/ g aao gca "..."/ g ca "..."in Linux e su Mac ...

Per le mie esigenze sembrava una cosa intelligente da fare, adattare comandi git come questo ...
... e per un uso più semplice mi sono semplicemente aiutato per comandi meno usati, quindi non devo consultare le pagine man ogni volta. I comandi sono predefiniti e cercarli è il più semplice possibile.

Voglio dire, dopo tutto siamo programmatori? Far funzionare le cose come se ne avessimo bisogno è il nostro lavoro.

Ecco uno screenshot aggiuntivo, questo funziona in Windows:

BONUS: Se sei su Linux o Mac, le pagine man colorate possono aiutarti parecchio:

pagine man colorate

Utilizzando git vare filtrando solo quelli che iniziano con alias:

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

Come altre risposte menzionate, git config -lelenca tutti i dettagli di configurazione dal tuo file di configurazione. Ecco un esempio parziale di quell'output per la mia configurazione:

...
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
...

Quindi possiamo estrarre le linee di 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

Possiamo renderlo più bello semplicemente cutcancellando la alias.parte di ogni riga, lasciandoci con questo comando:

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

Che stampa:

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

Infine, non dimenticare di aggiungere questo come alias:

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

Godere!

per windows:

git config --list | findstr "alias"

Ho menzionato a giugno 2018 con " elenco di riepilogo - i comandi git più utilizzati " Git 2.18 "use --list-cmds=alias( commit 3301d36 )", che carej riporta nella sua risposta .

 git --list-cmds=alias

Inoltre git config --get-regexp alias, puoi combinare il suo output con git help, il cui output cambierà con Git 2.14.x / 2.15:

" git help co" ora dice " co is aliased to ...", non " git co is".

Vedi commit b3a8076 (12 set 2017) di Kaartic Sivaraam ( sivaraam) .
^{(Unita da Junio ​​C Hamano - gitster- in commit 5079cc8 , 25 set 2017)}

help: cambia un messaggio per essere più precisi

Quando l'utente tenta di utilizzare l' --helpopzione " " su un comando con alias, le informazioni sull'alias vengono stampate come mostrato di seguito:

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

Questo non sembra corretto in quanto l'utente ha solo alias " co" e non "git co '.
Questo potrebbe anche essere errato nei casi in cui l'utente ha usato un alias come ' tgit'.

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

Cerca o mostra tutti gli alias

Aggiungi al tuo .gitconfigsotto [alias]:

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

Quindi puoi farlo

• git aliases - mostra TUTTI gli alias
• git aliases commit - solo alias contenenti "commit"

Uso questo alias nel mio globale~/.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

per produrre il seguente output

$ 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: questo funziona per me in git bash su Windows . Per altri terminali potrebbe essere necessario adattare l'escaping. )

Spiegazione

1. !git config --get-regexp ^alias\\. stampa tutte le righe da git config che iniziano con alias.
2. sed -e s/^alias.//rimuove alias.dalla linea
3. sed -e s/\\ /\\ $(printf \"\\043\")--\\>\\ /sostituisce la prima occorrenza di uno spazio con \\ $(printf \"\\043\")--\\>(che valuta #-->).
4. column -t -s $(printf \"\\043\")formatta tutte le linee in una tabella di colonne con spaziatura uniforme. Il carattere $(printf \"\\043\")che valuta #viene utilizzato come separatore.
5. sort -k 1 ordina tutte le righe in base al valore nella prima colonna

$ (printf \ "\ 043 \")

Questo stampa solo il carattere #(esadecimale 043) utilizzato per la separazione delle colonne. Uso questo piccolo trucco in modo che l' aliases alias stesso non contenga letteralmente il #personaggio. Altrimenti sostituirà quei #caratteri durante la stampa. Nota : cambialo con un altro personaggio se hai bisogno di alias con #segni letterali .

C'è una funzione integrata ... prova

$ __git_aliases

elenca tutti gli alias :)

Se conosci il nome dell'alias, puoi utilizzare l' --helpopzione per descriverlo. Per esempio:

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

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

A partire da git 2.18 puoi usare git --list-cmds=alias

Ancora un altro gitalias (chiamato alias) che stampa gli alias git: aggiungi quanto segue alla [alias]sezione gitconfig :

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

Esempio di utilizzo, fornendo il nome completo dell'alias (corrisponde esattamente al nome alias: ie, ^foobar$) e mostra semplicemente il valore:

$ git alias st
alias.st status -s

$ git alias dif
alias.dif diff

Oppure, dai a regexp, che mostra tutti gli alias e i valori corrispondenti:

$ 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}..

Avvertenze: citare il regexp per impedire l'espansione della shell come glob, sebbene non sia tecnicamente necessario se / quando nessun file corrisponde allo schema. Inoltre: qualsiasi regexp va bene, tranne ^(inizio modello) e $(fine modello) non possono essere usati; sono impliciti. Presuppone che non si sta usando git-aliasdagit-extras .

Inoltre, ovviamente i tuoi alias saranno diversi; questi sono solo alcuni che ho configurato. (Forse li troverai utili anche tu.)