Ho visto uno screencast in cui qualcuno era arrivato

git st
git ci

lavorare. Quando lo faccio, ricevo un errore che mi chiede se intendevo qualcos'altro.
Essendo un git newb, devo sapere cosa devi fare per farlo?

Fondamentalmente devi solo aggiungere delle righe a ~/.gitconfig

[alias]
    st = status
    ci = commit -v

Oppure puoi usare il comando alias git config:

$ git config --global alias.st status 

Su unix, usa virgolette singole se l'alias ha uno spazio:

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

Su Windows, usa le virgolette doppie se l'alias ha uno spazio o un argomento da riga di comando:

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

Il comando alias accetta anche funzioni come parametri. Dai un'occhiata agli alias .

Come altri hanno già detto, il modo appropriato per aggiungere alias git è nel .gitconfigfile globale modificando ~/.gitconfigo usando il git config --global alias.<alias> <git-command>comando

Di seguito una copia della sezione alias del mio ~/.gitconfigfile:

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

Inoltre, se stai usando bash, ti consiglio di impostare il completamento bash copiando la git-completion.bashtua home directory e acquistandola dalla tua ~/.bashrc. (Credo di averlo appreso dal libro online di Pro Git .) Su Mac OS X, l'ho realizzato con i seguenti comandi:

# 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: il completamento bash funzionerà non solo per i comandi git standard ma anche per i tuoi alias git.

Infine, per ridurre davvero le sequenze di tasti, ho aggiunto quanto segue al mio ~/.bash_aliasesfile, che proviene da ~/.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'

Penso che il gitconfig più utile sia così, usiamo sempre la funzione 20% in git, puoi provare "g ll", è incredibile, i dettagli:

[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

Hai bisogno del git config aliascomando. Eseguire quanto segue in un repository Git:

git config alias.ci commit

Per alias globale:

git config --global alias.ci commit

Questo ha funzionato per me:

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

su:

$ git --version

git version 1.7.7.5 (Apple Git-26)

Questo creerà un alias stper status:

git config --add alias.st status

Le seguenti sono le scorciatoie o gli alias di 4 git che puoi usare per risparmiare tempo.

Apri la riga di comando e digita questi sotto i 4 comandi e usa le scorciatoie dopo.

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

Ora provali!

$ 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

Per coloro che cercano di eseguire comandi shell in un alias git , ad esempio:

$ git pof

Nel mio terminale spingerà forzare il ramo corrente al mio repository di origine:

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

Dove il

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

Il comando restituisce il ramo corrente.

Quindi questa è una scorciatoia per digitare manualmente il nome del ramo:

git push origin -f <current-branch>

Puoi alias comandi sia git che non git. Sembra che questo sia stato aggiunto nella versione 1.5. Uno snippet dalla git config --helppagina sulla versione 2.5.4 sul mio Mac mostra:

Se l'espansione dell'alias è preceduta da un punto esclamativo, verrà trattata come un comando shell.

Ad esempio, nel tuo .gitconfigfile globale potresti avere:

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

E poi eseguili:

$ git hi
hello
$ git st
On branch master

...

Aggiungi le seguenti righe al tuo ~ / .gitconfig nella tua home directory

[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 volta fatto, puoi fare git ainvece che git addper esempio. Lo stesso vale per altri comandi nella sezione alias.

$ git update
git: 'update' non è un comando git. Vedi 'git --help'.

Intendevi questo?
    update-ref

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

$ git update
Da git: //git.kernel.org/pub/scm/git/git
 = [aggiornato] html -> origin / html
 = [aggiornato] maint -> origin / maint
 = [aggiornato] man -> origin / man
 = [aggiornato] master -> origin / master
 = [aggiornato] successivo -> origine / successivo
 = [aggiornato] pu -> origin / pu
 = [aggiornato] todo -> origin / todo
Già aggiornato.

Ho creato l'alias dogper mostrare il grafico del registro:

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

E usalo come segue:

git dog

Puoi anche concatenare i comandi se usi '!' operatore per generare una shell:

aa = !git add -A && git status

Ciò aggiungerà tutti i file e ti darà un rapporto sullo stato con $ git aa.

Per un modo pratico per controllare i tuoi alias, aggiungi questo alias:

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

Quindi una rapida $ git aliasti dà i tuoi attuali alias e cosa fanno.

Puoi impostare alias git personalizzati usando la configurazione di git. Ecco la sintassi:

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

Ad esempio, se è necessario un alias per visualizzare un elenco di file che presentano conflitti di unione, eseguire:

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

Ora puoi usare il comando sopra usando solo "conflitti":

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

Per me ( sto usando mac con terminale ) ha funzionato solo quando ho aggiunto su .bash_profile e ho aperto un'altra scheda per caricare la modifica:

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 per rendere gli alias ancora più brevi della modalità di configurazione git standard menzionata in altre risposte, ho creato un pacchetto npm mingit ( npm install -g mingit) in modo che la maggior parte dei comandi diventasse 2 caratteri anziché 2 parole. Ecco gli esempi:

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 altri comandi sarebbero ugualmente brevi. Ciò mantiene anche i completamenti bash. Il pacchetto aggiunge una funzione bash ai tuoi dotfile, funziona su osx, linux e windows. Inoltre, a differenza degli altri alias, alias git-> gcosì come il secondo parametro.

Se si desidera un'alternativa ~/.gitconfigall'opzione e si apre a scavare un po 'di più, un'altra opzione è quella di scrivere comandi git completamente personalizzati avvolgendoli in un pacchetto nodo globale.

Nel tuo package.json, definiresti il ​​comando root (esempio:) gt, e quindi filtrare i comandi specifici per eseguire i comandi git corretti. Ad esempio, git checkout my-branchpotrebbe essere gt co mybranch.

Il pacchetto "christian-git" su npm utilizza questo metodo: https://github.com/alexmacarthur/christian-git

È dato qui Alias. Anche qui ci sono ottime risposte, l'ho aggiunto perché differisce in Windows e Linux

Schermata PFA del mio file .gitconfig

con i seguenti alias

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

Includi più file alias nel tuo .gitconfig

Suggerisco di usare un .gitconfig include per i tuoi alias. Una volta che inizi a creare alias, probabilmente ne finirai molti. Probabilmente saranno qualcosa che vuoi condividere con gli altri. Metterli in un file dedicato semplifica la condivisione. Il tuo team può persino usare un repository git per contenere alias condivisi. E ovviamente alcuni alias che non vorrai condividere, quindi tienili in un file di alias privato.

[include]
    path=src/dotfiles/.gitaliases

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

[include]
    path=.gitaliases.private

Un'altra possibilità per Windows sarebbe quella di avere una directory piena di file .bat che contengono le scorciatoie. Il nome del file è il collegamento da utilizzare. Aggiungi semplicemente la directory alla tua variabile d'ambiente PATH e avrai tutte le scorciatoie a tua disposizione nella finestra cmd.

Ad esempio (gc.bat):

git commit -m %1

Quindi è possibile eseguire il comando seguente nella console:

gc "changed stuff"

Il motivo per cui lo sto aggiungendo come risposta è perché quando lo usi non sei limitato ai git ...soli comandi.