¿Cómo imprimo una lista de mis alias git, es decir, algo análogo al aliascomando bash ?

Esta respuesta se basa en la respuesta de Johnny . Se aplica si no está utilizando git-aliasdesde git-extras.

En Linux, ejecute una vez:

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

Esto creará un alias git permanente llamado aliasque se almacena en su ~/.gitconfigarchivo. Usarlo enumerará todos sus alias git, en casi el mismo formato que están en el ~/.gitconfigarchivo. Para usarlo, escriba:

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

Se aplican las siguientes consideraciones:

• Para evitar que el alias aliasaparezca en la lista anterior, agregue | grep -v ^'alias 'justo antes de la comilla doble de cierre. No recomiendo esto para que los usuarios no olviden que el comando no aliases más que un alias y no es una característica de git.

• Para ordenar los alias enumerados, agregue | sortjusto antes de la comilla doble de cierre. Alternativamente, puede mantener los alias ~/.gitconfigordenados.

• Para agregar el alias como un alias de todo el sistema, reemplace --global(para el usuario actual) con --system(para todos los usuarios). Esto generalmente va en el /etc/gitconfigarchivo.

$ git config --get-regexp alias

Creé un alias de git llamado (curiosamente) aliasexactamente para este propósito ... útil de vez en cuando si usa el alias lo suficiente ...

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

Tenga en cuenta que la expresión regular se asegura de que la línea comience con alias..

Otra alternativa (puramente algo que encuentro fácil de recordar):

git config --list | grep alias

Lo siguiente funciona en Linux, MacOSX y Windows (con msysgit).

Use git la para mostrar alias en .gitconfig

¿Escuché 'scripting bash'? ;)

Sobre la parte 'no necesaria' en un comentario anterior, básicamente creé una página de manual como resumen para mis alias. ¿Por qué tanto alboroto? ¿No es una exageración completa?

Sigue leyendo ...

He configurado los comandos como este en mi .gitconfig, separados como TAB=TAB:

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

y simplemente definió otro alias para grep la TAB=parte de los alias definidos. (Todas las demás opciones no tienen pestañas antes y después del '=' en su definición, solo espacios).

Los comentarios no agregados a un alias también tienen un TAB=====anexo, por lo que se muestran después del grepping.

Para una mejor visualización, estoy canalizando la salida grep en menos, así:

versión básica: (negro / blanco)

  #.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=' coincide TAB=.

Para tener una mejor visión general de los alias que tengo, y desde que uso la consola bash, coloreé la salida con colores de terminal:

• todos '=' están impresos en rojo
• todos los '#' están impresos en verde

versión avanzada: (coloreada)

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

Básicamente igual que el anterior, solo se agrega el uso de sed para obtener los códigos de color en la salida.

La -Rbandera de menos es necesaria para obtener los colores que se muestran en menos.

(Recientemente descubrí que los comandos largos con una barra de desplazamiento debajo de su ventana no se muestran correctamente en los dispositivos móviles: el texto está cortado y simplemente falta la barra de desplazamiento. Ese podría ser el caso con el último fragmento de código aquí, manténgalo en importa cuando mires fragmentos de código aquí mientras estás en movimiento).

¿Por qué hacer que funcione tanta magia?

Tengo como media milla de alias, adaptados a mis necesidades.
Además, algunos de ellos cambian con el tiempo , por lo que, después de todo, la mejor idea para tener una lista actualizada es analizar el .gitconfig.

Un extracto breve **** de mis 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

En mis estaciones de trabajo Linux o Mac también existen más alias en los .bashrc, algo así 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

De esa manera, no es necesario escribir git help submodule, no es necesario git h submodule, solo gh submodulees todo lo que se necesita para obtener la ayuda. Son solo algunos caracteres, pero ¿con qué frecuencia los escribe?

Uso todo lo siguiente, por supuesto solo con atajos ...

• añadir
• cometer
• comprometerse
• restablecer - CABEZA dura
• empujar
• ir a buscar
• rebase
• revisa
• rama
• show-branch (en muchas variaciones)
• shortlog
• volver a registrar
• diff (en variaciones)
• log (en muchas variaciones)
• estado
• show
• notas
• ...

Esto fue solo desde lo alto de mi cabeza.

A menudo tengo que usar git sin una interfaz gráfica de usuario, ya que muchos de los comandos de git no se implementan correctamente en ninguna de las interfaces gráficas. Pero cada vez que los uso, es principalmente de la misma manera.

En la parte 'no implementada' mencionada en el último párrafo:
todavía tengo que encontrar algo que se compare con esto en una GUI:
sba = show-branch --color=always -a --more=10 --no-name- muestre todas las ramas locales y remotas, así como las confirmaciones que tienen dentro de ellas
ccm = "!git reset --soft HEAD~ && git commit"- cambie el último mensaje de confirmación

Desde un punto de vista que es más simple:
¿con qué frecuencia escribe git add .o git commit -am "..."? Sin contar ni el resto ...
Conseguir que las cosas funcionen como git aao git ca "..."en Windows,
o con alias bash gaa/ g aao gca "..."/ g ca "..."en Linux y en Mac ...

Para mis necesidades, parecía una cosa inteligente de hacer, personalizar comandos de git como este ...
... y para un uso más fácil, solo me ayudé a mí mismo para comandos menos utilizados, así que no tengo que consultar las páginas de manual cada vez. Los comandos están predefinidos y buscarlos es lo más fácil posible.

Quiero decir, ¿somos programadores después de todo? Hacer que las cosas funcionen como las necesitamos es nuestro trabajo.

Aquí hay una captura de pantalla adicional, esto funciona en Windows:

BONIFICACIÓN: si está en Linux o Mac, las páginas man coloreadas pueden ayudarlo un poco:

páginas man coloreadas

Usando git vary filtrando solo aquellos que comienzan con alias:

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

Como se mencionó en otras respuestas, git config -lenumera todos los detalles de configuración de su archivo de configuración. Aquí hay un ejemplo parcial de esa salida para mi configuración:

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

Entonces podemos extraer las líneas 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 hacer esto más bonito simplemente cutseñalando la alias.parte de cada línea, dejándonos con 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 último, no olvides agregar esto como un alias:

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

¡Disfrutar!

para ventanas:

git config --list | findstr "alias"

Mencioné en junio de 2018 con la " lista de resumen: los comandos de git más utilizados ", el Git 2.18 "use --list-cmds=alias( commit 3301d36 )", que carej informa en su respuesta .

 git --list-cmds=alias

Además de eso o de git config --get-regexp alias, puede combinar su salida con git help, cuya salida cambiará con Git 2.14.x / 2.15:

" git help co" ahora dice " co is aliased to ...", no " git co is".

Ver commit b3a8076 (12 de septiembre de 2017) por Kaartic Sivaraam ( sivaraam) .
^{(Fusionada por Junio ​​C Hamano - gitster- en commit 5079cc8 , 25 sep 2017)}

help: cambiar un mensaje para ser más preciso

Cuando el usuario intenta usar la --helpopción ' ' en un comando con alias, la información sobre el alias se imprime como se muestra a continuación:

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

Esto no parece correcto ya que el usuario solo ha alias ' co' y no ' git co'.
Esto podría incluso ser incorrecto en los casos en que el usuario haya usado un alias como ' tgit'.

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

Buscar o mostrar todos los alias

Añadir a su .gitconfigdebajo [alias]:

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

Entonces puedes hacer

• git aliases - mostrar TODOS los alias
• git aliases commit - solo alias que contienen "commit"

Yo uso este alias en mi 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 producir el siguiente resultado

$ 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: Esto funciona para mí en git bash en Windows . Para otros terminales, es posible que deba adaptar el escape ) .

Explicación

1. !git config --get-regexp ^alias\\. imprime todas las líneas de git config que comienzan con alias.
2. sed -e s/^alias.//elimina alias.de la línea
3. sed -e s/\\ /\\ $(printf \"\\043\")--\\>\\ /reemplaza la primera aparición de un espacio con \\ $(printf \"\\043\")--\\>(que se evalúa como #-->).
4. column -t -s $(printf \"\\043\")formatea todas las líneas en una tabla de columnas espaciadas uniformemente. El carácter $(printf \"\\043\")que evalúa #se utiliza como separador.
5. sort -k 1 ordena todas las líneas según el valor de la primera columna

$ (printf \ "\ 043 \")

Esto solo imprime el carácter #(hexadecimal 043) que se utiliza para la separación de columnas. Utilizo este pequeño truco para que el aliases alias en sí no contenga literalmente el #personaje. De lo contrario, reemplazaría esos #caracteres al imprimir. Nota : Cambie esto a otro carácter si necesita alias con #signos literales .

Hay una función incorporada ... intente

$ __git_aliases

enumera todos los alias :)

Si conoce el nombre del alias, puede usar la --helpopción para describirlo. Por ejemplo:

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

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

A partir de git 2.18 puedes usar git --list-cmds=alias

Otro gitalias (llamado alias) que imprime alias git: agregue lo siguiente a su [alias]sección gitconfig :

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

Ejemplo de uso, dando el nombre completo del alias (coincide exactamente con el nombre del alias: es decir, ^foobar$), y simplemente muestra el valor:

$ git alias st
alias.st status -s

$ git alias dif
alias.dif diff

O bien, proporcione regexp, que muestra todos los alias y valores coincidentes:

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

Advertencias: cite la expresión regular para evitar la expansión de la shell como un globo, aunque no es técnicamente necesario si / cuando ningún archivo coincide con el patrón. Además: cualquier expresión regular está bien, excepto que no se puede usar ^(inicio del patrón) y $(final del patrón); Están implícitos. Asume que no está utilizando git-aliasdesde git-extras.

Además, obviamente sus alias serán diferentes; Estos son solo algunos que he configurado. (Quizás los encuentres útiles también).