Bash (Git) - arquivos de script Functions, Alias e SH

Question

Eu fiquei bastante prolífico com o uso dos aliases, especialmente com todos os diferentes comandos git e sua ordem e interdependências, etc. Então, eu criei um alias que executam scripts mais complexos.

alias stash='f() { .... }; f'

Acima de tudo muito direto. No entanto, como um pouco mais puro no meu estilo de desenvolvimento, eu gosto de código "bem formatado". A forma às vezes é tão importante quanto a função. Então, com um simples apelido:

alias gca='git commit --amend '

Não tenho problema em listá-los diretamente no arquivo .bash_aliases . Mas para alguns dos aliases de multi-comandos eu gostaria que eles fossem separados.

Digitando help eu vejo

function name { COMMANDS ; } or name () { COMMANDS ; }

mas a única maneira que eu atualmente compreendo usando o function é sob o disfarce de um alias. Mas, dada a colorização de git diff --name-status post que comentei, posso incorporar um script em um arquivo SH e, para esse exemplo, passei os dados para ele via xargs.

Mas é possível (provavelmente) criar "funções" por meio de um script, então, em vez de elas serem listadas como "alias", elas foram listadas como uma função real armazenada em um arquivo sh?

hipotético:

alias stash='f() { if [[ -z $1 ]]; then git stash list; else git stash $1; fi; }; f'

em vez disso, um arquivo stash.sh teria:

function stash
{
  if [[ -z $1 ]]; then
     stash list;
  else git stash $1;
  fi;
}

é algo assim possível, então em ambos os casos eu simplesmente digitaria "stash" no prompt, mas como eles são definidos é bem diferente?

    

Answer 1

Você pode inserir em seu ambiente uma lista de funções necessárias.

Crie um arquivo ~/.bash_functions e opte por ~./bashrc .
Da mesma forma que ./bash_aliases é originado:

if [ -f ~/.bash_functions ]; then
    . ~/.bash_functions
fi

Em seguida, defina quantas funções (e complexas) você desejar.
Você poderia definir aliases (dentro de ~ / .bash_aliases para manter as coisas em ordem) para as funções. Mas isso não é realmente necessário, pois você poderia chamar diretamente as funções de origem. Definindo:

stash() {
    if [[ -z $1 ]]; then
        stash list;
    else
        git stash $1;
    fi;
}

Você poderia chamá-lo simplesmente por stash ou stash this , sem alias necessário.

    

Answer 2

Estou confuso sobre o porquê você está colocando as definições de função em um alias. Seu stash alias define uma função chama f e, em seguida, chama imediatamente de tal forma que recebe os argumentos passados para o alias. Para o uso diário, isso é equivalente a definir uma função chamada stash :

function stash {
  if (($# == 0)); then
     git stash list;
  else
     git stash "$@";
  fi;
}

Comparado com o que você tem no alias:

• Você pode usar function stash { … } ou stash () { … } para definir uma função. Eles são equivalentes, exceto que, se você já tivesse definido um alias chamado stash , ele seria expandido no momento em que você tentasse definir a função, para que a definição não acabasse fazendo o que você queria. Quando você define uma função, certifique-se de que o nome da função ainda não esteja definido como um alias ou use a sintaxe function .
• Eu uso (($#==0)) para testar se a função tem algum argumento, em vez de testar se o primeiro argumento está vazio. A intenção é mais clara. (E isso permite um argumento vazio, mas isso não é significativo aqui mesmo.)
• Sempre use aspas duplas em torno da variável expansões .
• Eu uso "$@" em vez de "$1" ao chamar git. "$@" passa todos os argumentos da função.

Você pode colocar as definições de função no mesmo local das definições de alias: em .bashrc , em .bash_aliases ou em outro arquivo originado por .bashrc , por exemplo,

. ~/lib/git-functions.bash

    

Answer 3

{   cat >myfunction.fn
    .  ./myfunction.fn
    fn  1 2 3 4 5
} <<""
    fn(){
        printf %s\n "$@"
    }

1
2
3
4
5

O comando . do shell irá fornecer um arquivo nomeado no ambiente de execução do shell atual. Quaisquer funções, variáveis, aliases ou outros tipos de estado de shell definidos nele persistirão quando return s.

Você pode fazer um tipo de definição de função autoload , por exemplo, definindo uma função stub:

fn(){ . ./fn.file && fn "$@"; }

... onde o arquivo contém uma redefinição de fn() :

fn(){
   : a whole new fn
}
: any other init state commands you might like to run