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?
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?
Respostas:
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 .
git config --global
para colocar os aliases em ~/.gitconfig
vez do .git/config
seu repositório atual.
st
para status -s
(status curto)
'
comogit config --global alias.sr 'svn rebase'
"
em vez de aspas simples ao adicionar comando com espaços, por exemplogit config --global alias.ci "commit -v"
Como já foi dito, a maneira apropriada de adicionar aliases de git está no seu .gitconfig
arquivo global , editando ~/.gitconfig
ou usando ogit config --global alias.<alias> <git-command>
comando
Abaixo está uma cópia da seção de alias do meu ~/.gitconfig
arquivo:
[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.bash
para 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_aliases
arquivo, 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'
~/.bashrc
arquivo?
~/.bashrc
: realmente cortar os toques das teclas. Exatamente o que estava procurando.
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 = 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
Você precisa do git config alias
comando 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)
git cob
. me lembra o verão, como na espiga de milho. na verdade, uma grande palavra em que não pensamos o suficiente ... cob que é #
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>
git push -f origin HEAD
empurrar a ramificação atual para sua contraparte remota? Além disso, um atalho para empurrar com força? Se você precisar pressionar a força com frequência suficiente para se beneficiar de um atalho, não há algo errado em outra parte da sua configuração ou fluxo de trabalho?
!git
pelo último comando git), mas editar manualmente o arquivo de configuração fez o truque.
Você pode alias os comandos git e non-git. Parece que isso foi adicionado na versão 1.5. Um trecho da git config --help
pá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 .gitconfig
arquivo 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 a
vez de, git add
por 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 dog
para 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 alias
fornece 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
-> g
assim como o segundo parâmetro.
Se você deseja uma alternativa à ~/.gitconfig
opçã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:) gt
e depois filtraria os comandos específicos para executar os comandos git corretos. Por exemplo, git checkout my-branch
poderia 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
.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.