Como usar 'which' em um comando com alias?

Question

Como a maioria dos usuários, tenho vários aliases configurados para fornecer um conjunto padrão de sinalizadores para programas usados com frequência. Por exemplo,

alias vim='vim -X'
alias grep='grep -E'
alias ls='ls -G'

O problema é que, se eu quiser usar which para ver de onde meu vim / grep / ls / etc está vindo, o alias fica no caminho:

$ which vim
vim: aliased to vim -X

Esta é uma saída útil, mas não o que estou procurando neste caso; Eu sei que vim tem um alias para vim -X , mas eu quero saber de onde esse vim está vindo.

Pouco tempo para desfazer a definição do alias apenas para que eu possa usar which , existe uma maneira fácil de ter which 'desembrulhar' o alias e executar ele mesmo?

Editar: Parece que which é uma construção de shell com diferentes comportamentos em diferentes shells. No Bash, a sugestão de SiegeX da --skip-alias flag funciona; no entanto, estou no Zsh. Existe algo similar aí?

    

Answer 1

which é, na verdade, uma maneira ruim de fazer coisas como essa, pois faz suposições sobre seu ambiente com base em $SHELL e nos arquivos de inicialização (que ele acha) que o shell usa; não só às vezes adivinha errado, mas geralmente não é possível dizer que ele se comporta de maneira diferente. ( which no meu Ubuntu 10.10 não entende --skip-alias como mencionado pelo @SiegeX, por exemplo). type usa o ambiente shell atual em vez de cutucar seus arquivos de configuração, e pode ser instruído a ignorar partes daquele ambiente, para mostrar o que realmente acontecerá em vez do que aconteceria em uma reconstrução do seu shell padrão.

Nesse caso, type -P ignorará os aliases ou funções:

$ type -P vim
/usr/bin/vim

Você também pode pedir para remover todas as camadas, uma de cada vez, e mostrar o que ela encontraria:

$ type -a vim
vim is aliased to 'vim -X'
vim is /usr/bin/vim

(Expandindo isso a partir dos comentários:)

O problema com which é que geralmente é um programa externo em vez de um shell embutido, o que significa que ele não pode ver seus aliases ou funções e precisa tentar reconstruí-los a partir dos arquivos startup / config do shell. (Se é um shell embutido, como é em zsh , mas aparentemente não em bash , é mais provável usar o ambiente do shell e fazer a coisa certa.)

type é um comando compatível com POSIX que é necessário para se comportar como se fosse um built-in (ou seja, deve usar o ambiente do shell é invocado de incluindo aliases locais e funções), por isso normalmente é um built-in.

Geralmente não é encontrado em csh / tcsh , embora na maioria das versões modernas desses which seja um shell embutido e faça a coisa certa; às vezes o built-in é what , e às vezes não há uma boa maneira de ver o ambiente atual do shell a partir de csh / tcsh .

    

Answer 2

Em bash :

type -P vim

Em zsh :

type -p vim

Em ambos:

/usr/bin/which vim

Ou:

( unalias vim; type vim )

    

Answer 3

Em zsh which é um embutido como este comando reporta:

$ whence -w which
which: builtin

Para executar o comando externo (em qualquer shell) which , use o caminho completo :

$ /bin/which ls; echo $?
/bin/ls
0

assim, o comando ls foi encontrado (um valor de saída de 0) e está localizado em /bin/ls .

Dentro de zsh ; um caminho (ao lado do acima) para procurar por comandos externos é:

$ whence -p ls
/bin/ls

No entanto, isso não resolverá aliases aninhados como:

$ alias dire='ls -l'

O comando informará que nenhum comando dire foi encontrado.

$ whence -p dire; echo $?
1

Para resolver aliases aninhados (manualmente), consulte Resolve nested aliases to their source commands

    

Answer 4

Tente o seguinte:

which --skip-alias vim

    

Answer 5

Mina definida como tal

alias which='alias | /usr/bin/which --tty-only --read-alias --show-dot --show-tilde'

    

Answer 6

Outra alternativa é command which vim , que funciona da mesma maneira em zsh e bash

Por exemplo no meu mac:

LOLcalhost :: ~ % command which grep
/usr/local/bin/grep