5 Truques de Comandos Linux Que Vão Mudar a Sua Vida!

A interface de linha de comando (CLI) é essencial para a maioria dos profissionais de tecnologia, especialmente desenvolvedores e administradores de sistemas. Se você está escrevendo scripts, configurando servidores ou automatizando tarefas, conhecer bem os comandos do Linux pode economizar horas de trabalho.

Para muitos, o Linux pode parecer intimidador à primeira vista, mas, uma vez que você desbloqueia o potencial da CLI, percebe que ela é a melhor amiga do programador. Desde a navegação em diretórios até a manipulação de arquivos e até mesmo depuração, dominar esses comandos simples, mas poderosos, pode melhorar drasticamente seu fluxo de trabalho.

1. Criando Múltiplas Combinações de Pastas com mkdir e Chaves {}

Organizar arquivos e diretórios é uma tarefa frequente para desenvolvedores e analistas, especialmente ao gerenciar projetos ou configurar estruturas de diretórios complexas. Normalmente, criar múltiplos diretórios envolve muita digitação repetitiva. No entanto, há um truque poderoso com o comando mkdir que permite criar múltiplos diretórios de uma vez usando chaves {}.

O Problema

Digamos que você queira criar uma estrutura de pastas para diferentes ambientes (desenvolvimento, teste e produção) para vários serviços em seu projeto. Tradicionalmente, você poderia fazer isso manualmente, o que poderia ser algo assim:

mkdir dev
mkdir test
mkdir prod

Isso se torna complicado quando sua estrutura se torna mais complexa. Por exemplo, se você precisasse de pastas para serviços de backend e frontend em todos os três ambientes, o processo se torna tedioso.

A Solução: mkdir com Chaves {}

Em vez de criar cada diretório um por um, você pode combinar tudo isso em um único comando usando mkdir e chaves {}. Isso permite criar combinações de diretórios de forma eficiente.

Por exemplo:

mkdir -p {dev,test,prod}/{backend,frontend}

Explicação

• A flag -p informa ao mkdir para criar diretórios pai conforme necessário (ou seja, não lançará erros se os diretórios pai ainda não existirem).
• As chaves {} permitem especificar múltiplas opções que o mkdir combinará automaticamente.
• O primeiro conjunto {dev,test,prod} cria diretórios para diferentes ambientes.
• O segundo conjunto {backend,frontend} cria diretórios para diferentes serviços.

Estrutura Criada

Quando esse comando é executado, a seguinte estrutura de pastas é criada:

dev/
  backend/
  frontend/
test/
  backend/
  frontend/
prod/
  backend/
  frontend/

Por Que Este Truque Mudaria sua Vida?

Este método economiza um tempo significativo e reduz erros humanos, especialmente ao configurar grandes projetos com estruturas de pastas complexas. Em vez de digitar cada combinação manualmente, você pode defini-las em um comando conciso.

2. Navegar de Volta com cd - em Vez de Usar Repetidamente cd ..

Como programador, é comum se encontrar trabalhando em diretórios profundamente aninhados. Por exemplo, você pode estar movendo-se da raiz do projeto para subdiretórios para código, arquivos de configuração ou logs. No entanto, quando é hora de voltar para onde você começou, navegar manualmente digitando cd .. várias vezes pode se tornar frustrante e propenso a erros.

O Problema

Imagine que você está trabalhando em um diretório aninhado como este:

/home/usuario/projetos/webapp/src/frontend/componentes

Para voltar à raiz do projeto, você normalmente teria que digitar cd .. várias vezes, assim:

cd ..
cd ..
cd ..
cd ..

Isso são quatro comandos separados apenas para voltar a /home/usuario/projetos/. Isso não é apenas tedioso, mas também é fácil perder o controle de onde você veio.

A Solução: cd -

Aqui está uma alternativa mais simples e rápida: use o comando cd - para voltar instantaneamente ao diretório anterior, não importa o quão profundamente você tenha entrado em uma estrutura aninhada.

Como Funciona

O comando cd - não navega para cima na árvore de diretórios como cd ... Em vez disso, ele leva você de volta ao último diretório em que estava, quase como um botão “voltar” em um navegador web.

Por exemplo, digamos que você começou na raiz do projeto /home/usuario/projetos/webapp/ e, em seguida, moveu-se para o diretório aninhado /home/usuario/projetos/webapp/src/frontend/componentes. Agora, em vez de digitar cd .. várias vezes para voltar, você pode simplesmente digitar:

cd -

E você estará instantaneamente de volta em /home/usuario/projetos/webapp/.

Explicação Técnica

O comando cd - armazena o diretório anterior na memória, então, quando você o usa, ele troca seu diretório atual pelo último. É uma maneira altamente eficiente de navegar de volta e adiante entre dois diretórios, especialmente quando você está alternando entre um diretório de trabalho e um aninhado profundamente.

Caso de Uso Prático

Este truque é especialmente útil quando você está depurando ou trabalhando em várias partes de um projeto. Se você precisar alternar frequentemente entre a raiz do projeto e um subdiretório profundo, cd - economiza o trabalho de digitar longos caminhos ou navegar passo a passo para cima.

3. Criar Múltiplos Arquivos Rapidamente com touch e um Intervalo de Números

Criar múltiplos arquivos é uma tarefa comum para desenvolvedores, seja gerando arquivos de teste, marcadores de posição ou logs. Embora você possa criar arquivos um de cada vez, fazer isso manualmente para um grande número de arquivos se torna complicado. Felizmente, o Linux oferece uma maneira de criar múltiplos arquivos em um único comando usando touch e um intervalo de números dentro de chaves {}.

O Problema

Imagine que você precisa criar 100 arquivos numerados para uma série de casos de teste, como teste1.txt, teste2.txt, até teste100.txt. Fazer isso manualmente com comandos touch individuais seria algo assim:

touch teste1.txt
touch teste2.txt
touch teste3.txt
...
touch teste100.txt

Como você pode imaginar, isso é tedioso e consome muito tempo. Mas existe uma maneira melhor!

A Solução: touch com um Intervalo de Números e Chaves {}

Você pode usar o comando touch com um intervalo de números dentro de chaves {} para criar múltiplos arquivos de uma só vez. Veja como funciona:

touch teste{1..100}.txt

Explicação

• O comando touch é usado para criar novos arquivos. Normalmente, você o usaria assim: touch nome_do_arquivo.txt.
• Ao adicionar um intervalo de números dentro de chaves {1..100}, você diz ao shell para criar arquivos numerados de 1 a 100.
• O resultado é a criação de teste1.txt, teste2.txt, teste3.txt, até teste100.txt — em um único comando.

Exemplo

Vamos detalhar. Executando:

touch teste{1..10}.txt

Cria os seguintes arquivos em seu diretório:

teste1.txt
teste2.txt
teste3.txt
...
teste10.txt

Por Que Este Truque é Transformador

Este método permite gerar múltiplos arquivos instantaneamente, poupando você de criar cada arquivo manualmente um por um. É particularmente útil em cenários onde você precisa de arquivos de marcador de posição para teste ou registro, ou quando automatizando processos que exigem múltiplos arquivos como entrada.

Caso de Uso Prático

Por exemplo, você pode usar este truque para gerar rapidamente arquivos de log para testar uma aplicação que processa um grande número de arquivos. Em vez de criar manualmente cada arquivo, você pode gerá-los todos com um comando e focar seu tempo em escrever e testar seu código.

4. Atualizações de Arquivos em Tempo Real com tail -f

Como programador, especialmente ao trabalhar com sistemas de backend, você frequentemente precisa monitorar arquivos de log em busca de erros, comportamento do sistema ou propósitos de depuração. Nesses casos, verificar manualmente um arquivo de log repetidamente pode ser ineficiente. Felizmente, o comando tail tem uma opção para seguir atualizações automaticamente em tempo real, permitindo monitorar mudanças à medida que acontecem.

O Problema

Digamos que você está trabalhando em uma aplicação e precisa monitorar o arquivo de log erro_log.txt para rastrear novos erros sendo registrados. Normalmente, você pode usar o comando tail para ler as últimas linhas do arquivo assim:

tail erro_log.txt

Embora isso lhe dê o estado atual do arquivo, não atualiza em tempo real. Se o arquivo

mudar, você terá que executar o comando novamente para ver as novas linhas. Isso está longe de ser ideal, especialmente ao solucionar problemas de sistemas ao vivo ou monitorar logs para eventos em tempo real.

A Solução: tail -f para Atualizações em Tempo Real

Usando o comando tail -f, você pode seguir as mudanças no arquivo de log à medida que acontecem. Isso permite ver novas linhas adicionadas ao arquivo sem precisar re-executar o comando.

tail -f erro_log.txt

Explicação

• O comando tail por si só mostra as últimas 10 linhas de um arquivo.
• A opção -f significa “follow” (seguir), que mantém o terminal aberto e exibe continuamente novas linhas conforme elas são adicionadas ao arquivo.
• Isso é especialmente útil ao monitorar arquivos de log durante a execução de sua aplicação, pois você pode ver mensagens de erro ou saída em tempo real.

Exemplo

Vamos dizer que você está monitorando o arquivo de log de um servidor web para ver requisições e erros:

tail -f /var/log/nginx/access.log

À medida que novas requisições chegam, você as verá exibidas ao vivo em seu terminal. Não há necessidade de atualizar ou re-executar o comando — ele segue continuamente o arquivo para atualizações.

Caso de Uso Prático

Um dos usos mais práticos de tail -f é durante a depuração. Imagine que você está tentando encontrar a causa de um problema intermitente em sua aplicação. Ao seguir o arquivo de log de erros da aplicação em tempo real, você pode ver novas mensagens de erro conforme aparecem e agir imediatamente.

Por exemplo, você pode executar:

tail -f /var/log/app/erro.log

Se sua aplicação falhar, você verá a mensagem de erro aparecer em tempo real, permitindo solucionar o problema sem demora.

Dica Bônus: Combine com grep

Se você quiser seguir um arquivo de log em tempo real, mas só se importa com entradas específicas, você pode combinar tail -f com grep. Por exemplo:

tail -f erro_log.txt | grep "ERRO"

Este comando mostrará apenas as linhas que contêm a palavra “ERRO”, ajudando a filtrar a saída do log para informações relevantes.

5. Revisar Comandos Recentes com history 5

Como desenvolvedores, muitas vezes nos encontramos repetindo certos comandos durante uma sessão de trabalho — seja compilando código, gerenciando arquivos ou reiniciando serviços. Lembrar a sintaxe exata de um comando que você usou anteriormente ou reconstituir seus passos pode ser complicado, especialmente se você esteve trabalhando no terminal por horas.

Felizmente, o Linux mantém um registro de todos os comandos que você executa em uma sessão. O comando history permite ver uma lista de seus comandos executados anteriormente, e usá-lo de forma eficiente pode economizar muito tempo e esforço.

O Problema

Digamos que você esteve trabalhando por um tempo e executou um comando grep ou find complexo que agora precisa reutilizar. Você não consegue lembrar exatamente a sintaxe e rolar manualmente pelo terminal para encontrá-lo é tedioso.

A Solução: history 5 para Relembrar Comandos Recentes

O comando history exibe uma lista dos comandos que você executou em sua sessão de shell atual. Por padrão, ele mostra todo o histórico de comandos, mas você pode limitar o número de comandos exibidos especificando um número.

Por exemplo:

history 5

Isso exibirá os últimos cinco comandos que você executou, facilitando a lembrança e a reutilização rápida.

Explicação

• history sozinho imprimirá todo o histórico de comandos da sessão.
• Ao adicionar um número (por exemplo, history 5), você limita a saída aos cinco comandos mais recentes, ajudando a focar apenas nas últimas tarefas que você realizou.

Exemplo

Se seus últimos cinco comandos foram:

  123  ls
  124  cd src/
  125  mkdir novadir
  126  touch novoarquivo.txt
  127  history 5

Executar history 5 mostraria:

  123  ls
  124  cd src/
  125  mkdir novadir
  126  touch novoarquivo.txt
  127  history 5

Por Que Este Truque é Útil

Se você esqueceu como executou um comando, history evita que você precise descobrir tudo novamente. Também é ótimo para lembrar comandos complexos, como aqueles com longas flags ou opções que você não quer digitar novamente de memória.

Caso de Uso Prático

Digamos que você está depurando um programa e executando vários comandos diferentes para compilar, verificar logs e reiniciar o serviço. Em vez de lembrar cada comando ou rolar para trás no terminal, você pode simplesmente executar:

history 5

Você obterá uma lista dos seus últimos cinco comandos, facilitando a lembrança e a reutilização de qualquer um deles com esforço mínimo.

Dica Bônus: Reexecutar Comandos

Você pode reexecutar rapidamente qualquer comando do histórico usando o ponto de exclamação (!) seguido pelo número do comando. Por exemplo, se você quisesse executar novamente o comando mkdir novadir acima (comando número 125), você simplesmente digitaria:

!125

Isso evita que você precise digitar o comando inteiro novamente e pode ser um grande economizador de tempo, especialmente quando se trabalha com comandos longos.

• Aprendendo Linux Parte 2 – Comandos Básicos do Linux e Gestão de Arquivos
• Compreendendo o Redirecionamento Bash: “>file 2>&1” vs. “2>&1 >file”
• Desconexão de Receptores USB da Logitech Travava o Kernel Linux
• Correções de Segurança para Apple, Google, Microsoft e Mais
• 16 Comandos de Rede e Solução de Problemas

Dominar a interface de linha de comando do Linux é essencial para desenvolvedores, e os truques que cobrimos aqui são ferramentas poderosas para ter em sua caixa de ferramentas. Desde gerenciar arquivos e pastas de forma eficiente até navegar em diretórios e relembrar comandos, esses cinco truques podem simplificar significativamente seu fluxo de trabalho e aumentar a produtividade.