Bash shadow a command - função com o mesmo nome do comando [duplicado]

Qualquer caractere na frente de um alias impedirá que o alias seja acionado:

alias ls='ls -la'
ls foo.txt     #will run ls -la foo.txt
\ls foo.txt    #will run ls foo.txt
'ls' foo.txt   #will run ls foo.txt
'ls foo.txt'   #will run ls foo.txt

No entanto, isso não interrompe as funções e você precisa commandfazer referência ao interno subjacente se criar uma função com o mesmo nome.

ls () {
    echo "not an alias"
}
alias ls='echo "an alias"'

ls foo.txt          #will echo "an alias"
\ls foo.txt         #will echo "not an alias"
'ls' foo.txt        #will echo "not an alias"
command ls foo.txt  #will actually run `ls`

Explicação

O problema é que as duas primeiras opções só podem lidar com aliases. Eles não são operadores de redirecionamento especiais que podem detectar se você tem uma função ou comando com o mesmo nome. Tudo o que eles fazem é colocar algo na frente do alias, pois os aliases só se expandem se forem a primeira parte de um pipe ou comando

alias v='sudo vim'
v x.txt
#automatically expands "v" to "sudo vim" and then does the rest of the command
# v x.txt ==> sudo vim x.txt

Bash apenas tenta expandir a primeira palavra de um comando usando a lista de aliases que ele conhece (que você pode obter com alias). Os aliases não aceitam argumentos e podem ser apenas a primeira palavra (separada por espaços; vim x.txt não será expandida sudo vimim x.txtusando o alias acima) em um comando para expandir corretamente.

No entanto, a expansão nunca acontece com aspas simples: echo '$USER'imprimirá um literal $USERe não o que a variável representa. Além disso, o bash se expande \xpara ser x(principalmente). Essas não são formas extras adicionadas especificamente para escapar de um alias, elas são apenas parte de como a expansão do bash foi escrita. Assim, você pode usar esses métodos para permitir que um alias sombreie um comando e ainda tenha acesso ao comando real.

Por que as outras opções não funcionam como eu esperava?

Porque existem alguns detalhes na forma como uma linha de comando é executada.

O conceito básico é que a primeira palavra de uma linha de comando é o comando que o shell irá pesquisar e tentar executar, nesta ordem :

1. A linha de comando é dividida em metacaracteres (principalmente):

   metacaracteres
   Um caractere que, quando não citado, separa palavras. Um dos seguintes:
   | & ; ( ) < > nova linha de tabulação de espaço

2. Se a primeira palavra sem aspas corresponder a uma palavra de alias, ela será substituída pela definição de alias. Para evitar loops, isso é executado apenas uma vez se a nova primeira palavra corresponder a um alias que está sendo expandido. Isso faz com que isso funcione sem loops:

   $ alias ls='ls -la'
   $ ls dir               # will expand to `ls -la dir`
   

   Observe que: Se o último caractere do valor do alias estiver em branco, a próxima palavra de comando após o alias também será verificada quanto à expansão do alias.

3. Se a primeira palavra (resultante) for uma expansão (como um $var), ela será substituída (e sujeita à divisão de palavras IFS (e globing) se não for citada):

   $ var='echo -e '
   $ $var test '\twords'            # will expand to `echo -e test words`
   test    words
   

4. A primeira palavra resultante após as expansões acima (após atribuições de variáveis ​​opcionais) será pesquisada nesta ordem:

   • builtins especiais (somente no modo POSIX)
   • funções
   • embutidos
   • comandos com hash (leia hash de ajuda)
   • comandos externos (pesquisados ​​em $PATHdirs)

   A primeira correspondência encontrada será executada.

A ordem pode ser alterada por (para teste):

• Para contornar apenas alias, use \testou qualquer outro tipo de expansão.
• Para ignorar funções e aliases, use command test.
• Para executar um builtin, use builtin test.
• Para executar um aplicativo externo, use um caminho explícito: /bin/test.

Assim, uma função definida como:

$ ls(){ ls; }

Será chamado em um loop infinito. Como também um script que chama a mesma primeira palavra. Algo como:

#!/bin/bash
$0 "$@"

Reexecutará o mesmo script em um loop até que o kernel seja interrompido (se o kernel em uso tiver um limite de chamadas sucessivas para scripts).

A ordem será mostrada executando type -a:

$ test(){ echo test function; }
$ alias test=test
$ type -a
test is aliased to `test'
test is a function
test ()
{
    echo test function
}
test is a shell builtin
test is /usr/bin/test

A função (conforme definido na pergunta) ignorará apenas o alias, \vimmas não a função. Para ignorar alias e funções, use o comando. Esta função deve fazer o que você precisa:

vim() {
        if [ -w "$1" ]; then
            command vim "$1"
        else
            sudo HOME="$HOME" bash -c 'command vim "$@"' _ -u ~/.vimrc "$1"
        fi
      }

Se você fizer a função chamar o caminho completo para o vimbinário, não obterá o loop recursivo. Além disso, usando a -Hopção sudo define $HOME.

vim() {
    if [ -w "$1" ]; then
        command vim "$1"
    else
        sudo env HOME="$HOME" \vim -u ~/.vimrc "$1"
    fi
}

Obrigado. Eu não tinha pensado nisso, mas agora eu tenho isso no meu .bashrctambém.

EDITADO: chamada atualizada command vime sudo envem vez de sudo -h. desta forma, não há loop para ficar.