Quais são todos os comandos de uma letra do Ubuntu?

TL;DR : Isso informa sobre cada comando cujo nome é um único caractere, embora você queira simplificá-lo ou ajustá-lo:

(set -f; type -a $(compgen -cX '!?' | sort -u))

Listando comandos de um caractere comcompgen

O Bash tem preenchimento de tabulação e oferece um compgenbuilt-in, que fornece informações sobre como o texto é concluído. Ao executar compgen -c, você pode listar todos os comandos em seu sistema. Portanto, uma maneira de listar todos os comandos com apenas um caractere é filtrar a saída de compgen -c:

compgen -c | grep '^.$'

Como o steeldriver apontou ,compgen aceita a opção de -Xfazer sua própria filtragem. De forma um pouco não intuitiva, o operando to -Xé um padrão cujas correspondências são removidas . Ele suporta sintaxe globbing que funciona como expansão de nome de arquivo, mas também suporta uma inicial !para negá-la, alcançando o efeito desejado aqui. (Consulte Programmable Completion Builtins para obter mais informações sobre a sintaxe.) ?corresponde a qualquer caractere único, portanto, !?corresponde a qualquer coisa que não seja um único caractere, portanto, -X '!?'remove tudo o que não é um único caractere, deixando apenas comandos de caractere único:

compgen -cX '!?'

Isso mostra os mesmos resultados, na mesma ordem, que a tubulação para grep. Você pode passar -ce -Xem um argumento como -cXou (como o steeldriver mostra ) em dois argumentos como -c -X.

No meu sistema, recebo:

l
p
{
}
!
.
:
[
s
t
[
X
w

se tno meu sistema estão os scripts que escrevi; você provavelmente não tem comandos com esses nomes. Você provavelmente tem os outros.

Se estes são realmente comandos ou não, depende do que se pensa como um comando. {, }e !são palavras- chave shell , como if, case, whilee for. Os outros (incluindo shell builtins) são comandos inequivocamente no sentido usual.

O significado de resultados repetidos

Alguns comandos, como [na saída acima, podem ser repetidos. Isso acontece quando existe mais de um comando com o mesmo nome. O Bash oferece [como um shell embutido, mas também é um executável localizado em /usr/bin. Running mostra que tipo de comando é e, se for um comando externo, onde está localizado. Quando há mais de um comando com o mesmo nome, mostra aquele que realmente será utilizado. Como Kulfy apontou , você pode ver todos eles usando .type cmdcmdtype -a cmd

$ type -a [
[ is a shell builtin
[ is /usr/bin/[

Há outra fonte de possível duplicação: em alguns sistemas, /bine /usr/binna verdade são o mesmo diretório (mais precisamente: /biné um link simbólico para /usr/bin) e você verá entradas em /bine /usr/bin. Por exemplo, você pode ter tanto /bin/[e /usr/bin/[como o [interno, bem como ambos /bin/we /usr/bin/we ambos /bin/Xe /usr/bin/X. Estes são comandos tecnicamente separados, mas na verdade se referem ao mesmo executável.

Tradicionalmente, /bine /usr/bineram diretórios separados (para que os comandos /binfossem utilizáveis ​​mesmo quando /usré um volume NFS que ainda não está montado). Mas hoje em dia isso não costuma oferecer um benefício. Assim, os sistemas mais novos tendem a unificá-los. Se você estiver usando uma versão mais recente, provavelmente terá isso, a menos que tenha atualizado para ela de uma versão mais antiga que não tinha o .

Se desejar, você pode classificar a saída compgene remover duplicatas:

compgen -c | grep '^.$' | sort -u

compgen -cX '!?' | sort -u

Mostrando detalhes sobre todos os comandos

Para mais detalhes, você pode querer saber que tipo de comando é cada um e:

• para os comandos externos, onde estão localizados.
• para aliases e funções de shell, como eles são definidos.

Como mencionado acima, o built-in do Bash typelhe dirá tudo isso. Você pode escrever um comando que forneça a saída filtrada de compgenpara type.

type $(compgen -c | grep '^.$')

type $(compgen -cX '!?')

Isso vai se comportar mal se você tiver um comando *ou . ?Isso é bastante improvável, mas não impossível. Para se proteger contra isso, você pode desabilitar o globbing:

(set -f; type $(compgen -c | grep '^.$'))

(set -f; type $(compgen -cX '!?'))

Mas isso (com qualquer uma dessas quatro alternativas) é imperfeito, porque todos os comandos com o mesmo nome têm a mesma explicação, o que é correto apenas para o primeiro. Por exemplo, no meu sistema, recebo:

l is aliased to `ls -CF'
p is aliased to `printf "\e[?2004l"'
{ is a shell keyword
} is a shell keyword
! is a shell keyword
. is a shell builtin
: is a shell builtin
[ is a shell builtin
s is /home/ek/bin/s
t is /home/ek/bin/t
[ is a shell builtin
X is /usr/bin/X
w is /usr/bin/w

Você pode muito bem querer ver apenas informações sobre a primeira ocorrência de cada comando com o mesmo nome (por exemplo, o shell embutido [). Afinal, esses são os que realmente são executados, quando você escreve um comando cuja primeira palavra é qualquer um desses nomes de um caractere (por exemplo, [ -f /bin/nano ]executa o shell embutido [, não /usr/bin/[). Nesse caso, você pode classificar a saída compgene remover duplicatas antes de entregar os resultados para type:

type $(compgen -c | grep '^.$' | sort -u)

type $(compgen -cX '!?' | sort -u)

Ou, também para proteger contra globbing:

(set -f; type $(compgen -c | grep '^.$' | sort -u))

(set -f; type $(compgen -cX '!?' | sort -u))

No entanto, se você quiser informações sobre todos os comandos (por exemplo, /usr/bin/[assim como [), você pode passar -apara type. Eu recomendo que você ainda classifique e remova as duplicatas dos resultados primeiro, ou você terá muitas repetições na saída.

type -a $(compgen -c | grep '^.$' | sort -u)

type -a $(compgen -cX '!?' | sort -u)

Ou, também para proteger contra globbing:

(set -f; type -a $(compgen -c | grep '^.$' | sort -u))

(set -f; type -a $(compgen -cX '!?' | sort -u))

Quais comandos você tem varia entre os ambientes de shell

Observe que os comandos de um caractere que você possui, como os comandos que você possui em geral, são uma propriedade do seu ambiente de shell. Diferentes usuários, ou diferentes shells em execução pelo mesmo usuário, podem ter diferentes comandos disponíveis. O lcomando no Ubuntu, por exemplo, é definido em /etc/skel/.bashrc, que é copiado para ~/.bashrcquando as contas de usuário são criadas da maneira usual.

# some more ls aliases
alias ll='ls -alF'
alias la='ls -A'
alias l='ls -CF'

Assim, você pode alterar ou remover a definição de lem seu arquivo ~/.bashrc. Ou simplesmente execute unalias lpara afetar apenas seu shell atual.