Eu vi um screencast onde alguém tinha conseguido

git st
git ci

trabalhar. Quando faço isso, recebo um erro perguntando se eu quis dizer outra coisa.
Sendo um git newb, preciso saber o que você precisa fazer para fazer isso?

Basicamente, você só precisa adicionar linhas para ~/.gitconfig

[alias]
    st = status
    ci = commit -v

Ou você pode usar o comando git config alias:

$ git config --global alias.st status 

No unix, use aspas simples se o alias tiver um espaço:

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

No Windows, use aspas duplas se o alias tiver um espaço ou um argumento de linha de comando:

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

O comando alias ainda aceita funções como parâmetros. Dê uma olhada nos aliases .

Como já foi dito, a maneira apropriada de adicionar aliases de git está no seu .gitconfigarquivo global , editando ~/.gitconfigou usando ogit config --global alias.<alias> <git-command> comando

Abaixo está uma cópia da seção de alias do meu ~/.gitconfigarquivo:

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

Além disso, se você estiver usando o bash, eu recomendaria configurar a conclusão do bash copiando git-completion.bashpara o diretório inicial e obtendo-o do seu ~/.bashrc. (Acredito que aprendi sobre isso no livro on-line do Pro Git .) No Mac OS X, realizei isso com os seguintes 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: A conclusão do bash funcionará não apenas para os comandos git padrão, mas também para os seus aliases git.

Por fim, para realmente reduzir as teclas digitadas, adicionei o seguinte ao meu ~/.bash_aliasesarquivo, que é originário 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'

Eu acho que o gitconfig mais útil é assim, sempre usamos a função 20% no git, você pode tentar o "g ll", é incrível, os detalhes:

[user]
    name = my name
    email = [email protected]
[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

Você precisa do git config aliascomando Execute o seguinte em um repositório Git:

git config alias.ci commit

Para alias global:

git config --global alias.ci commit

Isso funcionou para mim:

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

em:

$ git --version

git version 1.7.7.5 (Apple Git-26)

Isso criará um alias stpara status:

git config --add alias.st status

A seguir, são apresentados os atalhos ou aliases de 4 git que você pode usar para economizar tempo.

Abra a linha de comando e digite estes comandos abaixo de 4 e use os atalhos depois.

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

Agora teste-os!

$ 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 aqueles que procuram executar comandos shell em um alias do git , por exemplo:

$ git pof

No meu terminal, forçarei a ramificação atual ao meu repositório de origem:

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

Onde o

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

O comando retorna a ramificação atual.

Portanto, este é um atalho para digitar manualmente o nome do ramo:

git push origin -f <current-branch>

Você pode alias os comandos git e non-git. Parece que isso foi adicionado na versão 1.5. Um trecho da git config --helppágina da versão 2.5.4 no meu Mac mostra:

Se a expansão do alias for prefixada com um ponto de exclamação, será tratada como um comando shell.

Por exemplo, em seu .gitconfigarquivo global, você pode ter:

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

E então execute-os:

$ git hi
hello
$ git st
On branch master

...

Adicione as seguintes linhas ao seu ~ / .gitconfig no seu diretório pessoal

[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-"

Feito isso, você pode fazer em git avez de, git addpor exemplo. O mesmo se aplica a outros comandos sob o cabeçalho de alias.

atualização $ git
git: 'update' não é um comando git. Veja 'git --help'.

Você quis dizer isso?
    update-ref

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

atualização $ git
Do git: //git.kernel.org/pub/scm/git/git
 = [atualizado] html -> origem / html
 = [atualizado] maint -> origin / maint
 = [atualizado] homem -> origem / homem
 = mestre [atualizado] -> origem / mestre
 = [atualizado] próximo -> origem / próximo
 = [atualizado] pu -> origem / pu
 = [atualizado] todo -> origem / todo
Já atualizado.

Criei o alias dogpara mostrar o gráfico do log:

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

E use-o da seguinte maneira:

git dog

Você também pode encadear comandos se usar o '!' operador para gerar uma concha:

aa = !git add -A && git status

Isso adicionará todos os arquivos e fornecerá um relatório de status $ git aa.

Para uma maneira prática de verificar seus aliases, adicione este alias:

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

Depois, um rápido $ git aliasfornece seus apelidos atuais e o que eles fazem.

Você pode definir aliases personalizados do git usando a configuração do git. Aqui está a sintaxe:

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

Por exemplo, se você precisar de um alias para exibir uma lista de arquivos que possuem conflitos de mesclagem, execute:

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

Agora você pode usar o comando acima apenas usando "conflitos":

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

Para mim ( eu estou usando mac com terminal ) só funcionou quando adicionei .bash_profile e abri outra guia para carregar a alteração:

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"

Apenas para obter os aliases ainda mais curtos do que o modo de configuração padrão do git mencionado em outras respostas, criei um pacote npm mingit ( npm install -g mingit) para que a maioria dos comandos se tornasse 2 caracteres em vez de 2 palavras. Aqui estão os exemplos:

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

e outros comandos seriam igualmente curtos. Isso também mantém as conclusões do bash. O pacote adiciona uma função bash aos seus arquivos de ponto, funciona em osx, linux e windows. Além disso, diferentemente dos outros aliases, ele aliases git-> gassim como o segundo parâmetro.

Se você deseja uma alternativa à ~/.gitconfigopção e está aberto a se aprofundar um pouco mais, outra opção é escrever comandos git totalmente personalizados, envolvendo-os em um pacote de nó global.

No package.json, você definiria o comando root (exemplo:) gte depois filtraria os comandos específicos para executar os comandos git corretos. Por exemplo, git checkout my-branchpoderia ser gt co mybranch.

O pacote "christian-git" no npm usa este método: https://github.com/alexmacarthur/christian-git

É dado aqui Aliases. Mesmo que haja ótimas respostas aqui, eu adicionei isso porque difere no windows e linux

Captura de tela do PFA do meu arquivo .gitconfig

com os aliases abaixo

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

Inclua vários arquivos de alias no seu .gitconfig

Sugiro usar um .gitconfig include para seus aliases. Depois de começar a criar aliases, você provavelmente acabará com muitos deles. Eles provavelmente serão algo que você deseja compartilhar com outras pessoas. Colocá-los em um arquivo dedicado facilita o compartilhamento. Sua equipe pode até usar um repositório git para armazenar aliases compartilhados. E, é claro, alguns aliases que você não deseja compartilhar, portanto, mantenha-os em um arquivo de alias privado.

[include]
    path=src/dotfiles/.gitaliases

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

[include]
    path=.gitaliases.private

Outra possibilidade para o Windows seria ter um diretório preenchido com arquivos .bat que contenham seus atalhos. O nome do arquivo é o atalho a ser usado. Basta adicionar o diretório à sua variável de ambiente PATH e você terá todos os atalhos à sua disposição na janela do cmd.

Por exemplo (gc.bat):

git commit -m %1

Em seguida, você pode executar o seguinte comando no console:

gc "changed stuff"

A razão pela qual adiciono isso como resposta é porque, ao usá-lo, você não está limitado git ...apenas a comandos.