Vi un screencast donde alguien había recibido

git st
git ci

trabajar. Cuando lo hago, aparece un error que me pregunta si quise decir algo más.
Siendo un git newb, ¿necesito saber qué tienes que hacer para hacer esto?

Básicamente solo necesitas agregar líneas a ~/.gitconfig

[alias]
    st = status
    ci = commit -v

O puede usar el comando git config alias:

$ git config --global alias.st status 

En Unix, use comillas simples si el alias tiene un espacio:

$ git config --global alias.ci 'commit -v'

En Windows, use comillas dobles si el alias tiene un espacio o un argumento de línea de comando:

c:\dev> git config --global alias.ci "commit -v"

El comando alias incluso acepta funciones como parámetros. Echa un vistazo a los alias .

Como otros han dicho, la forma apropiada de agregar alias git es en su .gitconfigarchivo global editando ~/.gitconfigo usando elgit config --global alias.<alias> <git-command> comando

A continuación hay una copia de la sección de alias de mi ~/.gitconfigarchivo:

[alias]
    st = status
    ci = commit
    co = checkout
    br = branch
    unstage = reset HEAD --
    last = log -1 HEAD

Además, si está utilizando bash, recomendaría configurar la finalización de bash copiando git-completion.bashen su directorio de inicio y obteniéndolo de su ~/.bashrc. (Creo que aprendí sobre esto del libro en línea Pro Git ). En Mac OS X, logré esto con los siguientes comandos:

# Copy git-completion.bash to home directory
cp usr/local/git/contrib/completion/git-completion.bash ~/

# Add the following lines to ~/.bashrc
if [ -x /usr/local/git/bin/git ]; then
    source ~/.git-completion.bash
fi

Nota: La finalización de bash funcionará no solo para los comandos git estándar sino también para sus alias git.

Finalmente, para reducir realmente las pulsaciones de teclas, agregué lo siguiente a mi ~/.bash_aliasesarchivo, que se obtiene de ~/.bashrc:

alias gst='git status'
alias gl='git pull'
alias gp='git push'
alias gd='git diff | mate'
alias gau='git add --update'
alias gc='git commit -v'
alias gca='git commit -v -a'
alias gb='git branch'
alias gba='git branch -a'
alias gco='git checkout'
alias gcob='git checkout -b'
alias gcot='git checkout -t'
alias gcotb='git checkout --track -b'
alias glog='git log'
alias glogp='git log --pretty=format:"%h %s" --graph'

Creo que el gitconfig más útil es así, siempre usamos la función del 20% en git, puedes probar el "g ll", es increíble, los detalles:

[user]
    name = my name
    email = me@example.com
[core]  
    editor = vi 
[alias]
    aa = add --all
    bv = branch -vv
    ba = branch -ra
    bd = branch -d
    ca = commit --amend
    cb = checkout -b
    cm = commit -a --amend -C HEAD
    ci = commit -a -v
    co = checkout
    di = diff
    ll = log --pretty=format:"%C(yellow)%h%Cred%d\\ %Creset%s%Cblue\\ [%cn]" --decorate --numstat
    ld = log --pretty=format:"%C(yellow)%h\\ %C(green)%ad%Cred%d\\ %Creset%s%Cblue\\ [%cn]" --decorate --date=short --graph
    ls = log --pretty=format:"%C(green)%h\\ %C(yellow)[%ad]%Cred%d\\ %Creset%s%Cblue\\ [%cn]" --decorate --date=relative
    mm = merge --no-ff
    st = status --short --branch
    tg = tag -a 
    pu = push --tags
    un = reset --hard HEAD  
    uh = reset --hard HEAD^
   [color]  
    diff = auto  
    status = auto  
    branch = auto 
   [branch]  
    autosetuprebase = always

Necesitas el git config aliascomando. Ejecute lo siguiente en un repositorio de Git:

git config alias.ci commit

Para alias global:

git config --global alias.ci commit

Esto funcionó para mí:

bco = "!f(){ git branch ${1} && git checkout ${1}; };f"

en:

$ git --version

git version 1.7.7.5 (Apple Git-26)

Esto creará un alias stpara status:

git config --add alias.st status

Follwing son los 4 atajos de git o alias que puedes usar para ahorrar tiempo.

Abra la línea de comandos y escriba estos 4 comandos a continuación y use los atajos después.

git config --global alias.co checkout  
git config --global alias.ci commit    
git config --global alias.st status    
git config --global alias.br branch  

¡Ahora pruébalos!

$ git co              # use git co instead of git checkout
$ git ci              # use git ci instead of git commit
$ git st              # use git st instead of git status
$ git br              # use git br instead of git branch

Para aquellos que buscan ejecutar comandos de shell en un alias git , por ejemplo:

$ git pof

En mi terminal empujaré forzar la rama actual a mi repositorio de origen:

[alias]
    pof = !git push origin -f $(git branch | grep \\* | cut -d ' ' -f2)

Donde el

$(git branch | grep \\* | cut -d ' ' -f2)

El comando devuelve la rama actual.

Este es un acceso directo para escribir manualmente el nombre de la rama:

git push origin -f <current-branch>

Puede alias tanto los comandos git como los que no son git. Parece que esto se agregó en la versión 1.5. Un fragmento de la git config --helppágina en la versión 2.5.4 en mi Mac muestra:

Si la expansión del alias tiene el prefijo de un signo de exclamación, se tratará como un comando de shell.

Por ejemplo, en su .gitconfigarchivo global podría tener:

[alias]
    st = status
    hi = !echo 'hello'

Y luego ejecutarlos:

$ git hi
hello
$ git st
On branch master

...

Agregue las siguientes líneas a su ~ / .gitconfig en su directorio de inicio

[alias]
# one-line log
l = log --pretty=format:"%C(yellow)%h\\ %ad%Cred%d\\ %Creset%s%Cblue\\ [%cn]" --decorate --date=short
ll = log --pretty=format:"%C(yellow)%h%Cred%d\\ %Creset%s%Cblue\\ [%cn]" --decorate --numstat
ld = log --pretty=format:"%C(yellow)%h\\ %C(green)%ad%Cred%d\\ %Creset%s%Cblue\\ [%cn]" --decorate --date=short --graph
ls = log --pretty=format:"%C(green)%h\\ %C(yellow)[%ad]%Cred%d\\ %Creset%s%Cblue\\ [%cn]" --decorate --date=relative

a = add
ap = add -p
c = commit --verbose
ca = commit -a --verbose
cm = commit -m
cam = commit -a -m
m = commit --amend --verbose

d = diff
ds = diff --stat
dc = diff --cached

s = status -s
co = checkout
cob = checkout -b
# list branches sorted by last modified
b = "!git for-each-ref --sort='-authordate' --format='%(authordate)%09%(objectname:short)%09%(refname)' refs/heads | sed -e 's-refs/heads/--'"

# list aliases
la = "!git config -l | grep alias | cut -c 7-"

Una vez hecho esto, puede hacerlo en git alugar de, git addpor ejemplo. Lo mismo se aplica a otros comandos bajo el encabezado de alias.

actualización de $ git
git: 'actualizar' no es un comando git. Ver 'git --help'.

¿Te refieres a esto?
    actualización-ref

$ git config --global alias.update 'pull -v'

actualización de $ git
De git: //git.kernel.org/pub/scm/git/git
 = [actualizado] html -> origen / html
 = [actualizado] maint -> origen / maint
 = [actualizado] hombre -> origen / hombre
 = [actualizado] maestro -> origen / maestro
 = [actualizado] siguiente -> origen / siguiente
 = [actualizado] pu -> origen / pu
 = [actualizado] todo -> origen / todo
Ya está actualizado.

Creé el alias dogpara mostrar el gráfico de registro:

git config --global alias.dog "log --all --decorate --oneline --graph"

Y úsalo de la siguiente manera:

git dog

También puede encadenar comandos si usa '!' operador para generar un caparazón:

aa = !git add -A && git status

Esto agregará todos los archivos y le dará un informe de estado $ git aa.

Para una forma práctica de verificar sus alias, agregue este alias:

alias = config --get-regexp ^alias\\.

Luego, un rápido $ git aliasle brinda sus alias actuales y lo que hacen.

Puede establecer alias personalizados de git usando la configuración de git. Aquí está la sintaxis:

git config --global alias.<aliasName> "<git command>"

Por ejemplo, si necesita un alias para mostrar una lista de archivos que tienen conflictos de fusión, ejecute:

git config --global alias.conflicts "diff --name-only --diff-filter=U"

Ahora puede usar el comando anterior solo usando "conflictos":

git conflicts
# same as running: git diff --name-only --diff-filter=U

Para mí ( estoy usando mac con terminal ) solo funcionó cuando agregué .bash_profile y abrí otra pestaña para cargar el cambio:

alias gst="git status"
alias gd="git diff"
alias gl="git log"
alias gco="git commit"
alias gck="git checkout"
alias gl="git pull"
alias gpom="git pull origin master"
alias gp="git push"
alias gb="git branch"

Solo para obtener los alias aún más cortos que la forma de configuración estándar de git mencionada en otras respuestas, creé un paquete npm mingit ( npm install -g mingit) para que la mayoría de los comandos se conviertan en 2 caracteres en lugar de 2 palabras. Aquí están los ejemplos:

g a .                   // git add .
g b other-branch        // git branch other-branch
g c "made some changes" // git commit -m "made some changes"
g co master             // git checkout master
g d                     // git diff
g f                     // git fetch
g i                     // git init 
g m hotfix              // git merge hotfix
g pll                   // git pull
g psh                   // git push
g s                     // git status

y otros comandos serían igualmente cortos. Esto también mantiene las terminaciones de bash. El paquete agrega una función bash a sus archivos de puntos, funciona en osx, linux y windows. Además, a diferencia de los otros alias, alias git-> gasí como el segundo parámetro.

Si desea una alternativa a la ~/.gitconfigopción y está abierto a cavar un poco más, otra opción es escribir comandos git completamente personalizados envolviéndolos en un paquete de nodo global.

En su package.json, definiría el comando raíz (ejemplo:) gty luego filtraría los comandos específicos para ejecutar los comandos git correctos. Por ejemplo, git checkout my-branchpodría ser gt co mybranch.

El paquete "christian-git" en npm utiliza este método: https://github.com/alexmacarthur/christian-git

Se da aquí Alias .Incluso hay grandes respuestas aquí, he añadido esto porque es diferente en Windows y Linux

Captura de pantalla de PFA de mi archivo .gitconfig

con los siguientes alias

[alias]
    cb = checkout branch
    pullb = pull main branch

Incluya múltiples archivos de alias en su .gitconfig

Sugiero usar un .gitconfig include para sus alias. Una vez que comience a crear alias, probablemente terminará con muchos de ellos. Es probable que sean algo que quieras compartir con los demás. Ponerlos en un archivo dedicado hace que sea fácil compartirlos. Su equipo incluso puede usar un repositorio git para mantener alias compartidos. Y, por supuesto, algunos alias que no querrás compartir, así que mantenlos en un archivo de alias privado.

[include]
    path=src/dotfiles/.gitaliases

[include]
    path=src/team-utils/gitaliases

[include]
    path=.gitaliases.private

Otra posibilidad para Windows sería tener un directorio lleno de archivos .bat que contengan sus accesos directos. El nombre del archivo es el acceso directo que se utilizará. Simplemente agregue el directorio a su variable de entorno PATH y tendrá todos los accesos directos a su disposición en la ventana cmd.

Por ejemplo (gc.bat):

git commit -m %1

Luego puede ejecutar el siguiente comando en la consola:

gc "changed stuff"

La razón por la que agrego esto como respuesta es porque al usar esto no está limitado a git ...solo comandos.