etecanos Entrar Abrir laboratório

Início › Artigos › Linha de Comando

Linux: redirecionamento e pipes, os comandos em cadeia

Entenda entrada e saída padrão, os operadores >, >> e <, e como o pipe | liga comandos pequenos para resolver tarefas grandes no terminal do Linux.

Uma das ideias mais elegantes do Unix e do Linux é a de ferramentas pequenas que fazem uma coisa bem feita, e podem ser combinadas para resolver problemas maiores. Para isso funcionar, os comandos precisam receber e entregar dados de um jeito padronizado, e o shell oferece operadores para ligar uma coisa à outra.

Neste artigo você vai entender os fluxos padrão de um programa, aprender a gravar resultados em arquivos com > e >>, a ler dados de arquivos com < e a encadear comandos com o pipe (|). É um dos assuntos que mais separam quem apenas "digita comandos" de quem realmente domina o terminal.

Os três fluxos padrão

Todo programa em Linux nasce com três "canais" abertos:

Um comando no centro, com a entrada padrão (stdin) vinda do teclado e duas saídas: a saída padrão (stdout) e a saída de erros (stderr), ambas na tela
Figura 1 — Um comando no centro, com a entrada padrão (stdin) vinda do teclado e duas saídas: a saída padrão (stdout) e a saída de erros (stderr), ambas na tela
  • Entrada padrão (stdin): de onde o programa lê dados. Por padrão, o teclado.
  • Saída padrão (stdout): para onde vai o resultado normal. Por padrão, a tela.
  • Erro padrão (stderr): para onde vão as mensagens de erro. Também a tela, mas em um canal separado.

Por que separar os erros? Porque assim você pode guardar o resultado em um arquivo sem misturar mensagens de falha no meio dos dados. Redirecionar significa apenas trocar a tela ou o teclado por outro destino ou origem.

Gravando a saída em um arquivo: > e >>

O operador > envia a saída de um comando para um arquivo, em vez de mostrá-la na tela:

ls -l > lista.txt          # grava a listagem em lista.txt
echo "primeira linha" > diario.txt

Atenção: o > substitui o conteúdo do arquivo, se ele já existir. Para acrescentar ao final, sem apagar nada, use >>:

echo "segunda linha" >> diario.txt
date >> diario.txt         # acrescenta a data atual
OperadorEfeito
>Cria o arquivo ou sobrescreve o conteúdo
>>Cria o arquivo ou acrescenta ao final
<Usa um arquivo como entrada do comando
2>Envia apenas as mensagens de erro para um arquivo
pipe (barra vertical)Liga a saída de um comando à entrada do próximo
Os quatro operadores principais: maior que grava e substitui, dois maior que acrescenta, menor que lê de um arquivo e a barra vertical liga dois comandos
Figura 2 — Os quatro operadores principais: maior que grava e substitui, dois maior que acrescenta, menor que lê de um arquivo e a barra vertical liga dois comandos

Lendo de um arquivo: o operador <

O < faz o oposto: o comando passa a ler de um arquivo em vez de esperar que você digite. Muitos programas já aceitam um arquivo como argumento (wc -l lista.txt), mas o < é útil com os que só leem da entrada padrão:

wc -l < lista.txt          # conta as linhas do arquivo lido pela entrada

A diferença é discreta: com <, o wc nem sabe o nome do arquivo e, por isso, mostra só o número.

O pipe: a saída de um é a entrada do outro

O pipe, escrito com a barra vertical (|), é a peça central. Ele conecta a saída padrão de um comando à entrada padrão do seguinte, sem arquivos temporários no meio. Imagine uma linha de montagem: cada estação faz uma tarefa e passa o resultado adiante.

Terminal com exemplos de pipes e de redirecionamento: ls ligado a wc para contar arquivos, cat, grep e wc em cadeia, e echo gravando com maior que e dois maior que
Figura 3 — Terminal com exemplos de pipes e de redirecionamento: ls ligado a wc para contar arquivos, cat, grep e wc em cadeia, e echo gravando com maior que e dois maior que
ls /etc | wc -l                    # quantos itens existem em /etc?
cat log.txt | grep erro | wc -l    # quantas linhas de log têm "erro"?
ps | grep bash                     # o processo bash está rodando?

No segundo exemplo há três comandos em cadeia: cat lê o arquivo, grep filtra as linhas com "erro" e wc -l conta o que sobrou. Cada programa é simples; a combinação é poderosa. Você poderia escrever isso em um único programa, mas as peças separadas servem para mil outros problemas.

Redirecionando os erros

Como o erro tem um canal próprio, é possível tratá-lo à parte. O número 2 representa o canal de erros:

ls pasta-que-nao-existe 2> erros.txt    # a mensagem de erro vai para o arquivo
find / -name "*.conf" 2> /dev/null      # descarta os erros "Permissão negada"

O arquivo especial /dev/null é um "buraco negro": tudo o que for enviado para ele desaparece. É muito usado para silenciar mensagens que você sabe que não interessam, como os avisos de pastas às quais você não tem acesso.

Combinando redirecionamento e pipe

Os operadores se misturam livremente, e é aí que o terminal mostra sua força. Um exemplo comum é produzir um relatório sobre o sistema:

echo "Relatório de $(hostname)" > relatorio.txt
date >> relatorio.txt
df >> relatorio.txt
free >> relatorio.txt

Quatro comandos, quatro informações e um arquivo de texto pronto para ser enviado a alguém. O mesmo roteiro, colocado em um script, pode rodar todo dia automaticamente, assunto que aparece no artigo sobre scripts Bash.

Armadilhas que pegam até quem tem experiência

Alguns erros se repetem e vale conhecê-los antes de cair neles:

  • Ler e gravar no mesmo arquivo: um comando como sort lista.txt > lista.txt esvazia o arquivo antes mesmo de o sort lê-lo, porque o shell abre o destino para escrita primeiro. Grave em um arquivo temporário e depois renomeie com mv.
  • Confundir > com |: o > envia para um arquivo; o | envia para outro comando. Escrever ls > wc cria um arquivo chamado wc em vez de contar as linhas.
  • Esquecer que o erro não passa pelo pipe: só a saída padrão atravessa o |; as mensagens de erro continuam aparecendo na tela, a menos que você as redirecione com 2>&1.
  • Descobrir tarde demais que sobrescreveu algo: use >> quando estiver em dúvida.

Existe ainda o comando tee, que duplica a saída: ele grava em um arquivo e, ao mesmo tempo, continua mostrando na tela ou passando adiante no pipeline. É útil quando você quer guardar um registro sem deixar de acompanhar o resultado, como em df | tee espaco.txt.

Boas práticas

Depois de conhecer os operadores, o que faz a diferença no dia a dia é o método de trabalho. Quem usa redirecionamento e pipes com disciplina produz resultados reproduzíveis, que outra pessoa consegue refazer, e isso é exatamente o que se espera de um profissional de suporte ou de infraestrutura.

  • Use > apenas quando quiser substituir; prefira >> em registros.
  • Teste o pipeline por etapas, aumentando a cadeia aos poucos.
  • Guarde o resultado de comandos demorados em um arquivo, para não precisar repeti-los.
  • Separe erros de resultados com 2> quando for processar os dados depois.
  • Documente o que o pipeline faz, em um comentário, se for reutilizá-lo no futuro.

Pratique no laboratório

No Pinguim Linux, abra o terminal e monte a sua linha de montagem:

cd ~
mkdir pipes
cd pipes
echo "primeira" > diario.txt
echo "segunda" >> diario.txt
echo "terceira" >> diario.txt
cat diario.txt
wc -l diario.txt
ls /etc | wc -l
ls /etc | grep host
cat diario.txt | grep segunda
date >> diario.txt
cat diario.txt

Repita o primeiro echo com > em vez de >> e veja o que acontece com o conteúdo do arquivo: o histórico some, porque o > sobrescreve.

Resumo

  • Todo programa tem entrada padrão, saída padrão e saída de erro.
  • > grava a saída em arquivo e substitui; >> acrescenta; < lê de um arquivo; 2> redireciona erros.
  • O pipe (|) liga a saída de um comando à entrada do próximo, formando uma cadeia.
  • Monte pipelines passo a passo e use /dev/null para descartar o que não interessa.
  • Ferramentas pequenas combinadas resolvem problemas grandes: essa é a filosofia do Unix.

Referências

  1. SHOTTS, W. The Linux Command Line: A Complete Introduction. 2. ed. San Francisco: No Starch Press, 2019. Disponível em: https://linuxcommand.org/tlcl.php.
  2. GNU Bash Reference Manual: Redirections e Pipelines. Free Software Foundation. Disponível em: https://www.gnu.org/software/bash/manual/.
  3. RAYMOND, E. S. The Art of Unix Programming. Boston: Addison-Wesley, 2003. Disponível em: http://www.catb.org/esr/writings/taoup/.

Teste seus conhecimentos

1. O que faz o operador >>?

Não é essa. Isso é o >.

Correto. Com >> o conteúdo existente é preservado.

Não é essa. A leitura é feita com <.

Não é essa. O descarte usa /dev/null.

2. O que o pipe (|) conecta?

Não é essa. O pipe liga comandos, não arquivos.

Correto. É a "linha de montagem" do shell.

Não é essa. Esses são os fluxos padrão, não o pipe.

Não é essa. Isso seria sudo ou su.

3. Por que o Linux separa a saída normal da saída de erros?

Não é essa. O motivo não é esse.

Correto. Com 2> os erros podem ir para outro lugar.

Não é essa. A separação trata do destino, não da gravidade.

Não é essa. A tela recebe os dois, mas eles são canais distintos.

4. O que acontece com echo "novo" > diario.txt se diario.txt já tiver conteúdo?

Não é essa. Isso aconteceria com >>.

Não é essa. O > não impede a escrita.

Correto. O > sobrescreve o arquivo.

Não é essa. Não há movimento; há substituição do conteúdo.

Para refletir

  1. Descreva um pipeline que conte quantas linhas de um arquivo contêm a palavra "erro".
  2. Por que o redirecionamento de erros (2>) é útil ao processar a saída de um comando automaticamente?

Continue estudando