Criar um alias do Bash que aceite um parâmetro?

Eu costumava usar o CShell (csh), que permite criar um alias que aceita um parâmetro. A notação era algo como

alias junk="mv \\!* ~/.Trash"

No Bash, isso parece não funcionar. Dado que o Bash tem uma infinidade de recursos úteis, eu assumiria que este foi implementado, mas estou me perguntando como.

O alias do bash não aceita parâmetros diretamente. Você terá que criar uma função.

aliasnão aceita parâmetros, mas uma função pode ser chamada como um alias. Por exemplo:

myfunction() {
    #do things with parameters like $1 such as
    mv "$1" "$1.bak"
    cp "$2" "$1"
}


myfunction old.conf new.conf #calls `myfunction`

A propósito, as funções do Bash definidas no seu .bashrce em outros arquivos estão disponíveis como comandos no seu shell. Por exemplo, você pode chamar a função anterior como esta

$ myfunction original.conf my.conf

Refinando a resposta acima, você pode obter uma sintaxe de 1 linha, como é possível para aliases, o que é mais conveniente para definições ad-hoc em arquivos shell ou .bashrc:

bash$ myfunction() { mv "$1" "$1.bak" && cp -i "$2" "$1"; }

bash$ myfunction original.conf my.conf

Não se esqueça do ponto e vírgula antes do colchete direito de fechamento. Da mesma forma, para a pergunta real:

csh% alias junk="mv \\!* ~/.Trash"

bash$ junk() { mv "$@" ~/.Trash/; }

Ou:

bash$ junk() { for item in "$@" ; do echo "Trashing: $item" ; mv "$item" ~/.Trash/; done; }

A pergunta é simplesmente feita errada. Você não aliascria um alias que aceita parâmetros porque apenas adiciona um segundo nome para algo que já existe. A funcionalidade que o OP deseja é o functioncomando para criar uma nova função. Você não precisa aliasar a função, pois a função já tem um nome.

Eu acho que você quer algo assim:

function trash() { mv "$@" ~/.Trash; }

É isso aí! Você pode usar os parâmetros $ 1, $ 2, $ 3, etc, ou apenas encher todos eles com $ @

TL; DR: faça isso em vez disso

É muito mais fácil e mais legível usar uma função do que um alias para colocar argumentos no meio de um comando.

$ wrap_args() { echo "before $@ after"; }
$ wrap_args 1 2 3
before 1 2 3 after

Se você continuar lendo, aprenderá coisas que não precisa saber sobre o processamento de argumentos de shell. O conhecimento é perigoso. Apenas obtenha o resultado que deseja, antes que o lado sombrio controle seu destino para sempre.

Esclarecimento

bashaliases fazer aceitar argumentos, mas apenas no final :

$ alias speak=echo
$ speak hello world
hello world

Colocar argumentos no meio do comando via aliasé realmente possível, mas fica feio.

Não tente fazer isso em casa, crianças!

Se você gosta de contornar as limitações e fazer o que os outros dizem ser impossível, aqui está a receita. Só não me culpe se seu cabelo estiver desgrenhado e seu rosto acabar coberto de fuligem ao estilo de cientista louco.

A solução alternativa é passar os argumentos que aliasaceitam apenas no final para um wrapper que os insira no meio e execute seu comando.

Solução 1

Se você é realmente contra usar uma função em si, você pode usar:

$ alias wrap_args='f(){ echo before "$@" after;  unset -f f; }; f'
$ wrap_args x y z
before x y z after

Você pode substituir $@por $1se desejar apenas o primeiro argumento.

Explicação 1

Isso cria uma função temporária f, à qual são passados ​​os argumentos (observe que fé chamado no final). Ele unset -fremove a definição da função, pois o alias é executado para que não fique por aí depois.

Solução 2

Você também pode usar um subshell:

$ alias wrap_args='sh -c '\''echo before "$@" after'\'' _'

Explicação 2

O alias cria um comando como:

sh -c 'echo before "$@" after' _

Comentários:

• O espaço reservado _é obrigatório, mas pode ser qualquer coisa. Ele é definido como sh's' $0e é necessário para que o primeiro dos argumentos fornecidos pelo usuário não seja consumido. Demonstração:

  sh -c 'echo Consumed: "$0" Printing: "$@"' alcohol drunken babble
  Consumed: alcohol Printing: drunken babble
  

• As aspas simples dentro das aspas simples são necessárias. Aqui está um exemplo de que não funciona com aspas duplas:

  $ sh -c "echo Consumed: $0 Printing: $@" alcohol drunken babble
  Consumed: -bash Printing:
  

  Aqui, os valores dos shell interativos $0e $@são substituídos pelo duplo entre aspas antes de serem passados ​​para sh. Aqui está a prova:

  echo "Consumed: $0 Printing: $@"
  Consumed: -bash Printing:
  

  As aspas simples garantem que essas variáveis ​​não sejam interpretadas pelo shell interativo e sejam transmitidas literalmente para sh -c.

  Você pode usar aspas duplas e \$@, mas a melhor prática é citar seus argumentos (pois eles podem conter espaços) e \"\$@\"parecer ainda mais feio, mas pode ajudá-lo a vencer um concurso de ofuscação em que cabelos desgrenhados são um pré-requisito para entrada.

Uma solução alternativa é usar o marcador , uma ferramenta que eu criei recentemente que permite "marcar" modelos de comando e colocar facilmente o cursor nos espaços reservados para comandos:

Descobri que, na maioria das vezes, estou usando funções de shell para não precisar escrever comandos usados ​​com freqüência na linha de comando. A questão do uso de funções para este caso de uso é adicionar novos termos ao meu vocabulário de comando e ter que lembrar quais parâmetros de funções se referem no comando real. O objetivo do marcador é eliminar esse fardo mental.

Tudo que você precisa fazer é criar uma função dentro de um alias:

$ alias mkcd='_mkcd(){ mkdir "$1"; cd "$1";}; _mkcd'

Você deve colocar aspas duplas em torno de "$ 1", pois aspas simples não funcionarão.

Aqui estão três exemplos de funções que tenho no meu ~/.bashrc, que são essencialmente aliases que aceitam um parâmetro:

#Utility required by all below functions.
#/programming/369758/how-to-trim-whitespace-from-bash-variable#comment21953456_3232433
alias trim="sed -e 's/^[[:space:]]*//g' -e 's/[[:space:]]*\$//g'"

.

:<<COMMENT
    Alias function for recursive deletion, with are-you-sure prompt.

    Example:
        srf /home/myusername/django_files/rest_tutorial/rest_venv/

    Parameter is required, and must be at least one non-whitespace character.

    Short description: Stored in SRF_DESC

    With the following setting, this is *not* added to the history:
        export HISTIGNORE="*rm -r*:srf *"
    - https://superuser.com/questions/232885/can-you-share-wisdom-on-using-histignore-in-bash

    See:
    - y/n prompt: https://stackoverflow.com/a/3232082/2736496
    - Alias w/param: https://stackoverflow.com/a/7131683/2736496
COMMENT
#SRF_DESC: For "aliaf" command (with an 'f'). Must end with a newline.
SRF_DESC="srf [path]: Recursive deletion, with y/n prompt\n"
srf()  {
    #Exit if no parameter is provided (if it's the empty string)
        param=$(echo "$1" | trim)
        echo "$param"
        if [ -z "$param" ]  #http://tldp.org/LDP/abs/html/comparison-ops.html
        then
          echo "Required parameter missing. Cancelled"; return
        fi

    #Actual line-breaks required in order to expand the variable.
    #- https://stackoverflow.com/a/4296147/2736496
    read -r -p "About to
    sudo rm -rf \"$param\"
Are you sure? [y/N] " response
    response=${response,,}    # tolower
    if [[ $response =~ ^(yes|y)$ ]]
    then
        sudo rm -rf "$param"
    else
        echo "Cancelled."
    fi
}

.

:<<COMMENT
    Delete item from history based on its line number. No prompt.

    Short description: Stored in HX_DESC

    Examples
        hx 112
        hx 3

    See:
    - https://unix.stackexchange.com/questions/57924/how-to-delete-commands-in-history-matching-a-given-string
COMMENT
#HX_DESC: For "aliaf" command (with an 'f'). Must end with a newline.
HX_DESC="hx [linenum]: Delete history item at line number\n"
hx()  {
    history -d "$1"
}

.

:<<COMMENT
    Deletes all lines from the history that match a search string, with a
    prompt. The history file is then reloaded into memory.

    Short description: Stored in HXF_DESC

    Examples
        hxf "rm -rf"
        hxf ^source

    Parameter is required, and must be at least one non-whitespace character.

    With the following setting, this is *not* added to the history:
        export HISTIGNORE="*hxf *"
    - https://superuser.com/questions/232885/can-you-share-wisdom-on-using-histignore-in-bash

    See:
    - https://unix.stackexchange.com/questions/57924/how-to-delete-commands-in-history-matching-a-given-string
COMMENT
#HXF_DESC: For "aliaf" command (with an 'f'). Must end with a newline.
HXF_DESC="hxf [searchterm]: Delete all history items matching search term, with y/n prompt\n"
hxf()  {
    #Exit if no parameter is provided (if it's the empty string)
        param=$(echo "$1" | trim)
        echo "$param"
        if [ -z "$param" ]  #http://tldp.org/LDP/abs/html/comparison-ops.html
        then
          echo "Required parameter missing. Cancelled"; return
        fi

    read -r -p "About to delete all items from history that match \"$param\". Are you sure? [y/N] " response
    response=${response,,}    # tolower
    if [[ $response =~ ^(yes|y)$ ]]
    then
        #Delete all matched items from the file, and duplicate it to a temp
        #location.
        grep -v "$param" "$HISTFILE" > /tmp/history

        #Clear all items in the current sessions history (in memory). This
        #empties out $HISTFILE.
        history -c

        #Overwrite the actual history file with the temp one.
        mv /tmp/history "$HISTFILE"

        #Now reload it.
        history -r "$HISTFILE"     #Alternative: exec bash
    else
        echo "Cancelled."
    fi
}

Referências:

• Cortando o espaço em branco das strings: como aparar o espaço em branco de uma variável do Bash?
• Quebras de linha reais: https://stackoverflow.com/a/4296147/2736496
• Alias ​​com param: https://stackoverflow.com/a/7131683/2736496 (outra resposta nesta pergunta)
• HISTIGNORE: /superuser/232885/can-you-share-wisdom-on-using-histignore-in-bash
• Prompt de Y / N: https://stackoverflow.com/a/3232082/2736496
• Exclua todos os itens correspondentes do histórico: /unix/57924/how-to-delete-commands-in-history-matching-a-given-string
• A cadeia é nula / vazia: http://tldp.org/LDP/abs/html/comparison-ops.html

O alias do Bash absolutamente aceita parâmetros. Acabei de adicionar um alias para criar um novo aplicativo de reação que aceita o nome do aplicativo como parâmetro. Aqui está o meu processo:

Abra o bash_profile para editar no nano

nano /.bash_profile

Adicione seus aliases, um por linha:

alias gita='git add .'
alias gitc='git commit -m "$@"'
alias gitpom='git push origin master'
alias creact='npx create-react-app "$@"'

nota: o "$ @" aceita parâmetros passados ​​como "creact my-new-app"

Salvar e sair do nano editor

ctrl + o para escrever (pressione enter); ctrl + x para sair

Diga ao terminal para usar os novos aliases em .bash_profile

source /.bash_profile

É isso aí! Agora você pode usar seus novos aliases

NB: Caso a idéia não seja óbvia, é uma má idéia usar aliases para qualquer coisa, exceto alias, sendo o primeiro a 'função em um alias' e o segundo o 'difícil redirecionar / fonte'. Além disso, existem falhas (que eu pensei que seriam óbvias, mas apenas no caso de você estar confuso: não pretendo que elas sejam realmente usadas ... em qualquer lugar!)

.................................................. .................................................. ............................................

Eu já respondi isso antes, e sempre foi assim no passado:

alias foo='__foo() { unset -f $0; echo "arg1 for foo=$1"; }; __foo()'

o que é bom e bom, a menos que você esteja evitando o uso de funções todos juntos. Nesse caso, você pode aproveitar a vasta capacidade do bash para redirecionar texto:

alias bar='cat <<< '\''echo arg1 for bar=$1'\'' | source /dev/stdin'

Ambos têm aproximadamente o mesmo comprimento, fornecem ou recebem alguns caracteres.

O verdadeiro kicker é a diferença de tempo, sendo a parte superior o 'método da função' e a parte inferior o método da 'fonte de redirecionamento'. Para provar essa teoria, o momento fala por si:

arg1 for foo=FOOVALUE
 real 0m0.011s user 0m0.004s sys 0m0.008s  # <--time spent in foo
 real 0m0.000s user 0m0.000s sys 0m0.000s  # <--time spent in bar
arg1 for bar=BARVALUE
ubuntu@localhost /usr/bin# time foo FOOVALUE; time bar BARVALUE
arg1 for foo=FOOVALUE
 real 0m0.010s user 0m0.004s sys 0m0.004s
 real 0m0.000s user 0m0.000s sys 0m0.000s
arg1 for bar=BARVALUE
ubuntu@localhost /usr/bin# time foo FOOVALUE; time bar BARVALUE
arg1 for foo=FOOVALUE
 real 0m0.011s user 0m0.000s sys 0m0.012s
 real 0m0.000s user 0m0.000s sys 0m0.000s
arg1 for bar=BARVALUE
ubuntu@localhost /usr/bin# time foo FOOVALUE; time bar BARVALUE
arg1 for foo=FOOVALUE
 real 0m0.012s user 0m0.004s sys 0m0.004s
 real 0m0.000s user 0m0.000s sys 0m0.000s
arg1 for bar=BARVALUE
ubuntu@localhost /usr/bin# time foo FOOVALUE; time bar BARVALUE
arg1 for foo=FOOVALUE
 real 0m0.010s user 0m0.008s sys 0m0.004s
 real 0m0.000s user 0m0.000s sys 0m0.000s
arg1 for bar=BARVALUE

Esta é a parte inferior de cerca de 200 resultados, feitos em intervalos aleatórios. Parece que a criação / destruição de funções leva mais tempo que o redirecionamento. Esperemos que isso ajude os futuros visitantes a esta pergunta (não queria mantê-la para mim).

Se você estiver procurando uma maneira genérica de aplicar todos os parâmetros a uma função, não apenas uma ou duas ou outra quantidade codificada, você pode fazer isso desta maneira:

#!/usr/bin/env bash

# you would want to `source` this file, maybe in your .bash_profile?
function runjar_fn(){
    java -jar myjar.jar "$@";
}

alias runjar=runjar_fn;

Portanto, no exemplo acima, passo todos os parâmetros a partir de quando corro runjarpara o alias.

Por exemplo, se eu fizesse runjar hi thereisso acabaria realmente em execução java -jar myjar.jar hi there. Se eu fizesse runjar one two threeisso iria correr java -jar myjar.jar one two three.

Gosto desta $@solução porque funciona com qualquer número de parâmetros.

Respeitosamente para todos aqueles que dizem que você não pode inserir um parâmetro no meio de um alias, eu apenas testei e descobri que funcionava.

alias mycommand = "python3" $ 1 "script.py --folderoutput RESULTADOS /"

quando executei meu comando foobar, ele funcionou exatamente como se eu tivesse digitado o comando à mão.

Existem razões técnicas legítimas para querer uma solução generalizada para o problema de o alias do bash não ter um mecanismo para reposicionar argumentos arbitrários. Uma razão é se o comando que você deseja executar seria afetado negativamente pelas mudanças no ambiente resultantes da execução de uma função. Em todos os outros casos, as funções devem ser usadas.

O que recentemente me levou a tentar uma solução para isso é que eu queria criar alguns comandos abreviados para imprimir as definições de variáveis ​​e funções. Então, eu escrevi algumas funções para esse fim. No entanto, existem certas variáveis ​​que são (ou podem ser) alteradas por uma chamada de função. Entre eles estão:

FUNCNAME BASH_SOURCE BASH_LINENO BASH_ARGC BASH_ARGV

O comando básico que eu estava usando (em uma função) para imprimir defns de variáveis. na saída do formulário pelo comando set foi:

sv () { set | grep --color=never -- "^$1=.*"; }

Por exemplo:

> V=voodoo
sv V
V=voodoo

Problema: Isso não imprimirá as definições das variáveis ​​mencionadas acima, como estão no contexto atual , por exemplo, se em um prompt de shell interativo (ou não em nenhuma chamada de função), FUNCNAME não estiver definido. Mas minha função me diz a informação errada:

> sv FUNCNAME
FUNCNAME=([0]="sv")

Uma solução que eu encontrei foi mencionada por outras pessoas em outros posts sobre esse tópico. Para que este comando específico imprima a variável defns., E que requer apenas um argumento, eu fiz o seguinte:

alias asv='(grep -- "^$(cat -)=.*" <(set)) <<<'

O que fornece a saída correta (nenhuma) e o status do resultado (falso):

> asv FUNCNAME
> echo $?
1

No entanto, ainda me sentia obrigado a encontrar uma solução que funcionasse para números arbitrários de argumentos.

Uma solução geral para passar argumentos arbitrários para um comando com alias do Bash:

# (I put this code in a file "alias-arg.sh"):

# cmd [arg1 ...] – an experimental command that optionally takes args,
# which are printed as "cmd(arg1 ...)"
#
# Also sets global variable "CMD_DONE" to "true".
#
cmd () { echo "cmd($@)"; declare -g CMD_DONE=true; }

# Now set up an alias "ac2" that passes to cmd two arguments placed
# after the alias, but passes them to cmd with their order reversed:
#
# ac2 cmd_arg2 cmd_arg1 – calls "cmd" as: "cmd cmd_arg1 cmd_arg2"
#
alias ac2='
    # Set up cmd to be execed after f() finishes:
    #
    trap '\''cmd "${CMD_ARGV[1]}" "${CMD_ARGV[0]}"'\'' SIGUSR1;
    #        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    #       (^This is the actually execed command^)
    #
    # f [arg0 arg1 ...] – acquires args and sets up trap to run cmd:
    f () {
        declare -ag CMD_ARGV=("$@");  # array to give args to cmd
        kill -SIGUSR1 $$;             # this causes cmd to be run
        trap SIGUSR1;                 # unset the trap for SIGUSR1
        unset CMD_ARGV;               # clean up env...
        unset f;                      # incl. this function!
    };
    f'  # Finally, exec f, which will receive the args following "ac2".

Por exemplo:

> . alias-arg.sh
> ac2 one two
cmd(two one)
>
> # Check to see that command run via trap affects this environment:
> asv CMD_DONE
CMD_DONE=true

Uma coisa boa dessa solução é que todos os truques especiais usados ​​para manipular parâmetros posicionais (argumentos) para comandos funcionarão ao compor o comando interceptado. A única diferença é que a sintaxe da matriz deve ser usada.

Por exemplo,

Se você deseja "$ @", use "$ {CMD_ARGV [@]}".

Se você quiser "$ #", use "$ {# CMD_ARGV [@]}".

Etc.

Uma vez eu fiz um projeto divertido e ainda o uso. Está mostrando alguma animação enquanto eu copio arquivos via cpcomando coz cp, não mostramos nada e é meio frustrante. Então eu fiz esse alias

alias cp="~/SCR/spiner cp"

E este é o script spiner

#!/bin/bash

#Set timer
T=$(date +%s)

#Add some color
. ~/SCR/color

#Animation sprites
sprite=( "(* )  ( *)" " (* )( *) " " ( *)(* ) " "( *)  (* )" "(* )  ( *)" )

#Print empty line and hide cursor
printf "\n${COF}"

#Exit function
function bye { printf "${CON}"; [ -e /proc/$pid ] && kill -9 $pid; exit; }; trap bye INT

#Run our command and get its pid
"$@" & pid=$!

#Waiting animation
i=0; while [ -e /proc/$pid ]; do sleep 0.1

    printf "\r${GRN}Please wait... ${YLW}${sprite[$i]}${DEF}"
    ((i++)); [[ $i = ${#sprite[@]} ]] && i=0

done

#Print time and exit
T=$(($(date +%s)-$T))
printf "\n\nTime taken: $(date -u -d @${T} +'%T')\n"

bye

É assim

Animação Ciclada)

Para obter parâmetros, você deve usar funções!

No entanto, $ @ é interpretado ao criar o alias em vez de durante a execução do alias e escapar do $ também não funciona. Como eu resolvo este problema?

Você precisa usar a função shell em vez de um alias para se livrar desse problema. Você pode definir foo da seguinte maneira:

function foo() { /path/to/command "$@" ;}

OU

foo() { /path/to/command "$@" ;}

Por fim, chame seu foo () usando a seguinte sintaxe:

foo arg1 arg2 argN

Certifique-se de adicionar seu foo () ~/.bash_profileou ~/.zshrcarquivo.

No seu caso, isso funcionará

function trash() { mv $@ ~/.Trash; }

As funções são de fato quase sempre a resposta, já amplamente contribuída e confirmada por esta citação da página de manual: "Para quase todos os propósitos, os aliases são substituídos pelas funções de shell".

Para garantir a integridade e como isso pode ser útil (sintaxe ligeiramente mais leve), pode-se observar que, quando os parâmetros seguem o alias, eles ainda podem ser usados ​​(embora isso não atenda aos requisitos do OP). Provavelmente, isso é mais fácil de demonstrar com um exemplo:

alias ssh_disc='ssh -O stop'

permite digitar smth like ssh_disc myhost, que é expandido conforme o esperado:ssh -O stop myhost

Isso pode ser útil para comandos que usam argumentos complexos (minha memória não é mais o que costumava ser ...)

Ambas as funções e aliases podem usar parâmetros como outros mostraram aqui. Além disso, gostaria de destacar alguns outros aspectos:

1. função é executada em seu próprio escopo, alias compartilha escopo

Pode ser útil conhecer essa diferença nos casos em que você precisa ocultar ou expor algo. Também sugere que uma função é a melhor escolha para encapsulamento.

function tfunc(){
    GlobalFromFunc="Global From Func" # Function set global variable by default
    local FromFunc="onetwothree from func" # Set a local variable

}

alias talias='local LocalFromAlias="Local from Alias";  GlobalFromAlias="Global From Alias" # Cant hide a variable with local here '
# Test variables set by tfunc
tfunc # call tfunc
echo $GlobalFromFunc # This is visible
echo $LocalFromFunc # This is not visible
# Test variables set by talias
# call talias
talias
echo $GlobalFromAlias # This is invisible
echo $LocalFromAlias # This variable is unset and unusable 

Resultado:

bash-3.2$     # Test variables set by tfunc
bash-3.2$     tfunc # call tfunc
bash-3.2$     echo $GlobalFromFunc # This is visible
Global From Func
bash-3.2$     echo $LocalFromFunc # This is not visible

bash-3.2$     # Test variables set by talias
bash-3.2$     # call talias
bash-3.2$     talias
bash: local: can only be used in a function
bash-3.2$     echo $GlobalFromAlias # This is invisible
Global From Alias
bash-3.2$ echo $LocalFromAlias # This variable is unset and unusable

2. script wrapper é uma escolha melhor

Ocorreu-me várias vezes que um alias ou função não pode ser encontrado ao efetuar login viassh ou envolvendo a alternância de nomes de usuário ou ambiente multiusuário. Existem dicas e truques com arquivos de ponto de origem, ou um interessante com alias: alias sd='sudo 'permite que esse alias subseqüente alias install='sd apt-get install'funcione conforme o esperado (observe o espaço extra sd='sudo '). No entanto, um script de wrapper funciona melhor que uma função ou alias em casos como este. A principal vantagem de um script de wrapper é que ele é visível / executável para o caminho pretendido (por exemplo, / usr / loca / bin /) onde, como função / alias, precisa ser originado antes de ser utilizado. Por exemplo, você coloca uma função em ~ / .bash_profile ou ~ / .bashrc for bash, mas depois muda para outro shell (por exemplo,zsh), a função não está mais visível. Portanto, quando você está em dúvida, um script de wrapper é sempre a solução mais confiável e portátil.

Aqui está o exemplo:

alias gcommit='function _f() { git add -A; git commit -m "$1"; } ; _f'

Muito importante:

1. Há um espaço depois {e antes }.
2. Há um ;após cada comando em sequência. Se você esquecer isso após o último comando, verá um >prompt!
3. O argumento está entre aspas como "$1"

Como já foi apontado por outros, o uso de uma função deve ser considerado uma prática recomendada.

No entanto, aqui está outra abordagem, aproveitando xargs:

alias junk="xargs -I "{}" -- mv "{}" "~/.Trash" <<< "

Observe que isso tem efeitos colaterais em relação ao redirecionamento de fluxos.

Você não precisa fazer nada, o alias faz isso automaticamente.

Por exemplo, se eu quiser tornar o mestre de origem do git pull parametrizado, posso simplesmente criar um alias da seguinte maneira:

alias gpull = 'git pull origin '

e quando realmente chamá-lo, você pode passar 'master' (o nome do ramo) como um parâmetro, como este:

gpull master
//or any other branch
gpull mybranch