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 mkdir
e pressione a tecla de retorno, então entramos cd
para 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
: Executacommand1
primeiro. Em seguida, executacommand2
somente secommand1
não retornou um código de saída diferente de zerocommand1 || command2
: Executacommand1
. Em seguida, executacommand2
somente secommand1
retorna um código de saída diferente de zerocommand1 | command2
: Executa ambos os comandos sequencialmente enviandocommand1
saída padrão paracommand2
entrada padrão docommand1 |& command2
: Funciona da mesma forma que o|
operador, mas envia saída padrão e dados de erro paracommand2
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 mkdircd
comando!
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
12 thoughts on “Combinações de comandos Unix/Linux que todo desenvolvedor deve saber”
Comments are closed.