Exemplos de uma linha do Linux Complex Bash

Liners de uma batida podem reduzir a carga de trabalho, automatizar algo rapidamente e colocar o poder do controle final do sistema em suas mãos. Com o tempo, você provavelmente aprenderá a escrever uma linha mais complexa e algumas das coisas que você acaba escrevendo como profissional experiente será quase visível por um iniciante. Dito isto, o comando e o idioma de desenvolvimento Bash é altamente estruturado - e relativamente fácil de entender - depois que você souber sobre o interior e a saída. É realmente como se tornar proficiente em uma língua estrangeira.

Neste tutorial, você aprenderá:

• Como escrever comandos e scripts mais avançados da Bash One-liner
• Entenda como combinar vários comandos em scripts de uma linha
• Entender como os códigos de saída de um comando podem afetar outros comandos ao usar && e ||
• Entenda como a entrada de um comando pode ser modificada e depois usada pelo próximo comando
• Uso e vida real como exemplos de uma frase mais avançada

Requisitos de software e convenções usadas

Exemplo 1: Controle de processo

Vamos começar com um exemplo de como encerrar determinados processos em Bash de uma maneira fácil de seguir:

$ SLUGA 3600 e [1] 1792341 $ ps -ef | Grep 'Sleep' Roel 1792441 1701839 0 12:59 pts/13 00:00:00 Sono 3600 Roel 1792452 1701839 0 12:59 pts/13 00:00:00 Grep -cor = sono automático = Auto Sleep 

Primeiro, configuramos um comando de sono, por 3600 segundos (uma hora), e posteriormente encontramos esse processo na lista de processos. Ótimo, mas temos o real grep comando como uma linha extra na saída de listagem do processo. Vamos filtrar isso e também extrair o ID do processo em seguida, em vez da saída de informações completas do processo:

$ ps -ef | Grep 'Sleep' | Grep -v Grep Roel 1792441 1701839 0 12:59 pts/13 00:00:00 Sono 3600 $ PS -EF | Grep 'Sleep' | grep -v grep | awk 'print $ 2' 1792441 

No primeiro comando, filtramos o grep ativo. No segundo comando, demos este passo adiante imprimindo a segunda coluna $ 2 (dentro Awk) usando o Awk comando. Agora podemos usar o dega um passo adiante e na verdade matar esse processo. Digamos que façamos isso com sinal 9 que é altamente destrutivo para qualquer processo Linux (Sigkill):

$ ps -ef | Grep 'Sleep' | grep -v grep | awk 'print $ 2' | Xargs Kill -9 [1]+ Sleep Killed 3600 

E podemos ver que nosso processo foi morto corretamente. Enquanto este foi um exemplo mais simples, envolveu 6 comandos diferentes: ps, grep, grep de novo, Awk, Xargs e matar. Você pode ver como o Bash One-Liners pode criar rapidamente a complexidade de muitas maneiras diferentes e em muitos níveis diferentes de complexidade e capacidade de processamento de dados.

E, para saber mais sobre Xargs, consulte nossos artigos Xargs para iniciantes com exemplos e Xargs com vários rosqueados com exemplos.

Exemplo 2: Diversão com sucesso e fracasso!

$ echo '0'> a && echo '1'> b && echo '2'> c && ls não éTexist || LS A && LS B && LS C && LS D && LS E LS: Não é possível acessar 

Que linha complexa! No entanto, uma vez que você sabe lê -lo, ou talvez você já o faça, fica muito fácil de ler. Vamos demonstrar essa afirmação a ser válida, interrompendo o comando em pedaços menores do tamanho de uma mordida, mais fáceis de entender e seguir:

$ echo '0'> a && echo '1'> b && echo '2'> c 

Todo esse conjunto de comandos faz é o mesmo que o seguinte com uma pequena ressalva:

$ echo '0'> a $ echo '1'> b $ echo '2'> c 

Então, qual é a diferença (e a pequena ressalva)?

Que nesta última série de comandos cada comando será executado, independentemente do resultado do comando anterior. A sequência anterior (usando &&) só prosseguirá para o segundo eco se O resultado do primeiro comando foi 0 (eu.e. Sucesso - no sucesso do Bash em um comando é indicado por 0 e falha com 1 ou superior como um código de saída).

Assim, a sequência de comando usando && também poderia ser escrito da seguinte maneira;

$ echo '0'> a $ se [$ ? -eq 0]; então eco '1'> b; fi $ se [$ ? -eq 0]; então eco '2'> c; fi 

O $ ? (ou $? em resumo de sintaxe) a variável sempre contém o resultado do último comando, eu.e. o código de saída (0, 1 ou superior) gerado pelo último comando.

Como podemos ver, a criação de uma linha de echo '0'> a && echo '1'> b && echo '2'> c Certamente é mais fácil para os olhos e entender agora, e definitivamente reduz a complexidade do código correspondente e correspondente exibido logo acima.

Vamos seguir apenas um comando mais:

$ echo '0'> a && echo '1'> b && echo '2'> c && ls não éTexist ls: não pode acessar 

Isso agora parece muito mais fácil, certo?

Acabamos de adicionar outro comando, nomeadamente LS não está existente desde que o comando antes dele (e neste caso toda a linha, pois todos os comandos são unidos por && Em uma configuração em forma de corrente, onde um comando defeituoso quebrará a corrente e interrompe a execução da cadeia na íntegra) foi bem-sucedido. À medida que todos os comandos são bem -sucedidos, o ls é executado e um erro é produzido como resultado do mesmo porque o arquivo, bem, realmente não existe 🙂

Então, o que aconteceria se nos juntarmos a outro && no final? A cadeia de comandos terminaria como dissemos? Vamos ajustar um pouco o comando:

$ echo '0'> a && echo '1'> b && echo '2'> c && ls não éTexist && echo 'certamente não' ls: não pode acessar 'não é 

E, certamente não executou. Vamos então apresentar nosso próximo comando em nossa cadeia a partir do exemplo original:

$ echo '0'> a && echo '1'> b && echo '2'> c && ls não éTexist || LS A LS: Não é possível acessar 

Você pode ver o que está acontecendo? Aqui temos um novo símbolo de sintaxe, a saber || que é diferente de && na medida em que ele é executado apenas se houve um resultado diferente de zero no comando anterior. Observe que ambos || e && aplique apenas ao último comando, e não à cadeia de comandos, mesmo que se pudesse pensar nisso como uma cadeia em geral.

Você pode pensar sobre && como o idioma inglês equivalente e e, até certo ponto, o comum e presentes nas linguagens de programação, mas com a reviravolta que aqui estamos verificando uma condição antes do && e executar o que está por trás disso, a condição de saída é 0.

Outra reviravolta é que a maioria das linguagens de programação verificará veracidade como um binário 1 quando && Sintaxe é usada. Por exemplo, considere o código pseudo; Se test1_flag && test2_flag então… que geralmente avaliará para Verdadeiro em geral (e assim executar o então comandos) se as bandeiras binárias test1_flag e test2_flag são 1 ou verdadeiro, enquanto em Bash veracidade é indicado por um 0 (e não 1) Status de saída do último comando!

Você pode pensar em || como o idioma inglês equivalente ou (ou como em Ou se isso falhar, então .. ). Nesta situação, há uma conexão mais forte com linguagens de programação comuns: quando um idioma de programa comum verifica, por exemplo se test1_flag || test2_flag então… , então um positivo binário test1_flag (eu.e. valor 1) ou test2_flag produziria a condição geral para ser verdadeira (e, portanto, o então Cláusula seria executada). Vemos o mesmo em Bash; Se o código de saída do comando for diferente de zero (i.e. 1 ou um valor mais alto em alguns casos), então o comando por trás do || Cláusula será executada.

Vamos agora voltar ao comando original e analisá -lo integralmente:

$ echo '0'> a && echo '1'> b && echo '2'> c && ls não éTexist || LS A && LS B && LS C && LS D && LS E LS: Não é possível acessar 

Você pode ver o que acontece? Porque o LS não está existente O comando falha internamente e produz uma saída diferente de zero (use LS não existe; eco $? em Bash para verificar; a saída é 2), o ou (||) Cláusula é acionada e, em seguida, executamos ls. Imagine como uma corrente fluindo em direção a uma direção diferente, mas ainda é uma corrente.

Enquanto o ls a o comando é bem -sucedido e é seguido pelo e (&&) Cláusula, o próximo comando é executado e assim por diante. Observe que a execução chega a ls d, e a saída para o mesmo (LS: Não é possível acessar 'D': nenhum arquivo ou diretório) é mostrado, mas o ls e O comando não é executado! Isso é esperado, como && foi usado e o ls d comando falhou. Por isso, ls e nunca é executado.

Conclusão

Quanto mais proficiente você se tornar ao escrever um Bash One-Liners, mais rápido, melhor, menos propenso a erros e mais suaves, seus scripts de uma linha se tornarão, e quanto menos tempo você gastará para escrever-os. Os desenvolvedores da linguagem Bash colocaram todo o controle em suas mãos. O que você fará com esse controle hoje?

Deixe-nos uma mensagem abaixo com suas criações mais legais de uma linha!

Tutoriais do Linux relacionados:

• Uma introdução à automação, ferramentas e técnicas do Linux
• Coisas para instalar no Ubuntu 20.04
• Coisas para fazer depois de instalar o Ubuntu 20.04 fossa focal linux
• Mastering Bash Script Loops
• Recuperando as páginas da web usando WGE, CURL e Lynx
• Mint 20: Melhor que o Ubuntu e o Microsoft Windows?
• Ubuntu 20.04 Guia
• Loops aninhados em scripts de basquete
• Manipulação de big data para diversão e lucro Parte 1
• Coisas para fazer depois de instalar o Ubuntu 22.04 Jellyfish…