⬅ Voltar ao Dashboard 1º Bimestre — Linux Básico
Aula 1.9

⚙️ Metacaracteres do Shell

pipe, redirecionamento, controle de fluxo e execução em segundo plano

🤔 O que são metacaracteres do shell?

Os metacaracteres principais

|
Pipe
Passa a saída de um comando para a entrada do próximo
ls | grep ".conf"
>
Redirecionar (criar/sobrescrever)
Salva a saída em um arquivo. Apaga o conteúdo anterior.
ls > lista.txt
>>
Redirecionar (acrescentar)
Adiciona a saída ao final do arquivo sem apagar o conteúdo
echo "ok" >> log.txt
<
Entrada de arquivo
Faz o comando ler de um arquivo em vez do teclado
sort < nomes.txt
;
Ponto e vírgula
Executa comandos em sequência, um após o outro
cd /tmp ; ls ; pwd
&&
E lógico (AND)
Executa o próximo só se o anterior tiver sucesso (exit 0)
mkdir pasta && cd pasta
||
OU lógico (OR)
Executa o próximo só se o anterior falhar
ping host || echo "fora do ar"
&
Background
Executa o comando em segundo plano, liberando o terminal
sleep 60 &

🔗 Pipe e redirecionamento em detalhes

O pipe | — linha de montagem

O pipe conecta comandos em série: a saída de um vira a entrada do próximo. É como uma esteira de fábrica onde cada máquina processa e passa adiante.

bash — pipe
# Listar só pastas (linhas começando com d) usuario@linux:~$ ls -la | grep "^d" # Contar quantos arquivos existem na pasta usuario@linux:~$ ls | wc -l 12 # Ver processos bash rodando agora usuario@linux:~$ ps aux | grep bash # Top 5 arquivos maiores na pasta atual usuario@linux:~$ du -sh * | sort -rh | head -5

Redirecionamento > e >>

Cuidado com o >: ele apaga o arquivo antes de escrever. Se errar o nome do arquivo, pode perder dados. O >> é mais seguro — ele só adiciona ao final.

bash — redirecionamento
# Salvar a lista de arquivos num arquivo usuario@linux:~$ ls -la > lista.txt # Adicionar uma linha ao final do log (não apaga) usuario@linux:~$ echo "Serviço iniciado" >> servico.log # Jogar os erros fora (redirecionar stderr para /dev/null) usuario@linux:~$ find / -name "*.conf" 2>/dev/null # Salvar saída normal E erros juntos usuario@linux:~$ make > build.log 2>&1

Dica: 2> redireciona a saída de erro (stderr). 1> ou apenas > redireciona a saída normal (stdout). 2>&1 significa "redirecione o stderr para onde o stdout está indo".

🔀 Controle de fluxo: ;, && e ||

Esses três metacaracteres determinam quando um comando será executado em relação ao anterior.

Ponto e vírgula ; — sequência simples

Executa os comandos um após o outro, independente de sucesso ou falha. É como uma lista de tarefas sem condição.

bash — ponto e vírgula
# Executa os três, um por um usuario@linux:~$ cd /tmp ; ls ; pwd /tmp /tmp # Cria pasta, entra, confirma onde está usuario@linux:~$ mkdir teste ; cd teste ; pwd /home/usuario/teste

E lógico && — só se deu certo

Executa o próximo comando somente se o anterior teve sucesso (código de saída 0). Ótimo para encadeamentos dependentes.

bash — AND lógico
# Só entra na pasta se ela foi criada com sucesso usuario@linux:~$ mkdir /backup && cd /backup # Atualiza e instala só se a atualização funcionar usuario@linux:~$ apt update && apt upgrade -y # Compila e executa só se não houver erro usuario@linux:~$ gcc programa.c -o programa && ./programa

OU lógico || — plano B

Executa o próximo comando somente se o anterior falhou. Perfeito para mensagens de erro ou ações alternativas.

bash — OR lógico
# Se o ping falhar, avisa usuario@linux:~$ ping -c1 8.8.8.8 || echo "Sem conexão com a internet" # Tenta criar pasta; se falhar, avisa usuario@linux:~$ mkdir /root/teste || echo "Sem permissão!" Sem permissão!
OperadorExecuta o próximo quando…Analogia
;Sempre"Faça isso, depois aquilo."
&&O anterior teve sucesso"Se deu certo, continue."
||O anterior falhou"Se não funcionou, tente outro jeito."

Execução em segundo plano: &

O & no final de um comando o executa em segundo plano (background), devolvendo o controle do terminal imediatamente.

Analogia: é como colocar uma roupa na máquina de lavar e sair para fazer outra coisa. A máquina continua trabalhando, você não precisa ficar parado esperando.

bash — background e jobs
# Executar em background (terminal fica livre) usuario@linux:~$ sleep 60 & [1] 4532 # [nº do job] PID do processo # Ver quais jobs estão rodando usuario@linux:~$ jobs [1]+ Running sleep 60 & # Trazer o job 1 de volta para o primeiro plano usuario@linux:~$ fg %1 # Pausar um comando em execução e mandar pro background # (pressione Ctrl+Z enquanto o comando está rodando) usuario@linux:~$ top ^Z [1]+ Stopped top usuario@linux:~$ bg %1 # retoma em background # Encerrar um job pelo número usuario@linux:~$ kill %1

Atenção: processos em background ainda imprimem saída no terminal, o que pode misturar com o que você está digitando. Para evitar isso, redirecione a saída: comando > saida.log 2>&1 &

🎯 Exercício — Arraste e Conecte

Arraste cada descrição para o comando ou símbolo correspondente.

Descrição
Executa o próximo comando só se o anterior teve sucesso
Adiciona saída ao final de um arquivo sem apagar
Passa a saída de um comando para a entrada do próximo
Executa comandos em sequência, independente do resultado
Roda o comando em segundo plano
Executa o próximo só se o anterior falhou
Comando / símbolo
|
>>
&&
;
||
&

🛠️ Atividade Prática — Metacaracteres no Terminal

⏱ ~30 min 💻 Ubuntu Server / Terminal 📸 Tirar screenshot da saída
  1. 1
    Explorar o pipe

    Use pipes para encadear comandos e filtrar informações do sistema.

    bash — passo 1
    # Liste só as pastas do seu diretório home usuario@linux:~$ ls -la ~ | grep "^d" # Conte quantos usuários existem no sistema usuario@linux:~$ cat /etc/passwd | wc -l # Veja os 5 processos que mais usam memória usuario@linux:~$ ps aux | sort -k4 -rn | head -5
  2. 2
    Praticar redirecionamento

    Crie arquivos com > e adicione conteúdo com >>. Observe a diferença.

    bash — passo 2
    # Cria (ou sobrescreve) o arquivo com a lista usuario@linux:~$ ls /etc > ~/lista-etc.txt usuario@linux:~$ wc -l ~/lista-etc.txt # Adiciona uma linha sem apagar o arquivo usuario@linux:~$ echo "--- fim da lista ---" >> ~/lista-etc.txt usuario@linux:~$ tail -3 ~/lista-etc.txt # Experimento: rode duas vezes e compare o tamanho usuario@linux:~$ date > ~/teste.txt ; wc -l ~/teste.txt usuario@linux:~$ date >> ~/teste.txt ; wc -l ~/teste.txt
  3. 3
    Controle de fluxo com && e ||

    Observe como o shell decide executar ou não o próximo comando.

    bash — passo 3
    # Cria uma pasta e entra nela em um único comando usuario@linux:~$ mkdir ~/lab-shell && cd ~/lab-shell && pwd # Tenta criar em /root (vai falhar) e exibe mensagem usuario@linux:~$ mkdir /root/proibido || echo "Sem permissão para criar aqui" # Sequência com ; (roda tudo, com ou sem erro) usuario@linux:~$ cd /tmp ; ls ; echo "Estou em: $(pwd)"
  4. 4
    Execução em background

    Execute um processo demorado em background e gerencie com jobs, fg e kill.

    bash — passo 4
    # Inicia um sleep longo em background usuario@linux:~$ sleep 120 & [1] 4532 # Veja que o terminal ficou livre — liste os jobs usuario@linux:~$ jobs [1]+ Running sleep 120 & # Encerra o job sem precisar esperar usuario@linux:~$ kill %1 [1]+ Terminated sleep 120
  5. 5
    Pipeline completo

    Monte um pipeline que combine vários metacaracteres para gerar um relatório.

    bash — passo 5
    # Lista os shells disponíveis no sistema e salva em arquivo usuario@linux:~$ cat /etc/shells | grep -v "^#" | sort > ~/shells.txt && echo "Salvo com sucesso!" || echo "Algo deu errado" # Exibe o relatório formatado usuario@linux:~$ echo "=== Shells disponíveis ===" ; cat ~/shells.txt ; echo "Total: $(wc -l < ~/shells.txt)"

📌 Para refletir: os metacaracteres do shell são a "cola" que une comandos simples em soluções poderosas. Um administrador Linux experiente raramente digita um único comando por vez — ele encadeia vários com pipes e operadores lógicos para fazer em segundos o que levaria minutos manualmente.