A maioria dos desenvolvedores que usam sistemas operacionais baseados em Unix ou semelhantes a Unix gostam de instruir o computador por meio do terminal. Eles normalmente usam comandos Unix/Linux padrão (POSIX) e outros comandos do sistema para lidar com operações de arquivo, configurações do sistema e controle de processo. Os programadores se esforçam para economizar tempo seguindo várias dicas de linha de comando, como usar atalhos de teclado de terminal, definir aliases e usar combinações de comando. A combinação de vários comandos Unix/Linux com operadores lógicos, de concatenação ou de pipeline é uma ótima maneira de aumentar a produtividade ao trabalhar com terminais e scripts de shell.

Nesta história, explicarei técnicas de combinação de comandos e várias combinações de comandos que você pode usar durante suas atividades diárias de programação e desenvolvimento de scripts de shell.

Técnicas de combinação de comandos

Na maioria das vezes, inserimos um único comando e pressionamos a tecla Enter para executá-lo usando o Bash como interpretador de comandos do terminal. Por exemplo, costumamos usar mkdire pressione a tecla de retorno, então entramos cdpara alterar o diretório. O Bash (e outros interpretadores de linha de comando, ou seja, Z shell) suporta a combinação de comandos com vários operadores, para que possamos usá-los para mesclar vários comandos e criar um para aumentar a produtividade da programação.

Veja as seguintes técnicas de concatenação de comandos:

• command1 && command2: Executa command1primeiro. Em seguida, executa command2somente se command1 não retornou um código de saída diferente de zero
• command1 || command2: Executa command1. Em seguida, executa command2 somente se command1retorna um código de saída diferente de zero
• command1 | command2: Executa ambos os comandos sequencialmente enviando command1 saída padrão para command2 entrada padrão do
• command1 |& command2: Funciona da mesma forma que o |operador, mas envia saída padrão e dados de erro para command2
• command1 ; command2: Executa ambos os comandos sequencialmente, independentemente dos códigos de saída do processo (o mesmo que a tecla de retorno)
• command1 & command2 &: Executa ambos os comandos como trabalhos em segundo plano

Vamos verificar como usar esses operadores de concatenação de comandos com comandos Unix/Linux do dia-a-dia!

Navegando no histórico da linha de comando e executando novamente os itens do histórico

Os programadores normalmente não mudam ou abandonam os ambientes de desenvolvedor com frequência, portanto, geralmente precisam executar novamente os comandos inseridos anteriormente. E se você precisar executar novamente um comando executado recentemente? Você pode primeiro tentar pressionar a tecla de seta para cima e procurar o comando específico. Se você inseriu o comando há algum tempo, talvez use o conhecido recurso de pesquisa reversa pressionando Ctrl + R.

O recurso de pesquisa reversa é rápido e produtivo, mas às vezes você precisa ver todos os comandos anteriores relacionados antes de executá-los. Existe uma maneira melhor e integrada de pesquisa reversa se você precisar pesquisar, comparar e executar comandos do histórico da linha de comando. Você pode pesquisar o histórico da linha de comando combinando history e grep comandos:

!1575 # Installs typescript

Indo para o diretório recém-criado instantaneamente

Muitas vezes temos que criar novos diretórios quando trabalhamos em projetos de software. Por exemplo, se você fizer uma tarefa de refatoração, pode ser necessário criar vários diretórios para armazenar o código-fonte refatorado recentemente. Normalmente usamos o mkdir comando para criar um novo diretório. Então, muitas vezes usamos o cd comando para ir para o diretório recém-criado. Podemos combinar essas duas ações em uma e fazer um comando combinado, conforme mostrado abaixo:

mkdir app_settings && cd $_

O comando acima primeiro cria o app_settings diretório. Em seguida, ele altera o diretório de trabalho atual para app_settings somente se a criação do diretório for bem-sucedida. Em Bash, o $_parâmetro se expande para o último argumento do comando anterior, que é app_settings no exemplo acima. Você pode até colocar este comando em uma função Bash e definir o mkdircdcomando!

Detectando status de comando de execução longa

Freqüentemente, inserimos comandos relativamente rápidos em nossos programas de terminal. Por exemplo, quando entramos cd para alterar o diretório de trabalho atual, ele faz seu trabalho instantaneamente. Em alguns cenários, também trabalhamos com comandos de execução longa que atrasam a execução do comando devido a operações de rede, manipulação de arquivos e várias atividades de processamento intensivo de CPU. A instalação de uma ferramenta de software de grande porte a partir de um repositório de pacotes é um excelente exemplo de comando de execução longa.

Normalmente, mudamos para outra tarefa depois de inserir um comando de execução longa, em vez de olhar e esperar. Como você sabe o status de conclusão (ou falha) do comando?

A maioria das distribuições GNU/Linux vem pré-instalada zenity e notify-send versões, para que possamos usá-los para criar uma notificação sempre que um comando de execução longa terminar. Veja os exemplos a seguir:

npm install; notify-send Done
apt update; notify-send Done

Você também pode exibir uma notificação apenas se o comando específico falhar da seguinte forma:

make || notify-send Error

Referência: Unix/Linux Command Combinations That Every Developer Should Know