O Acervo da Rádio — 33 Passos

Objetivos de Aprendizagem

Este é o segundo treino com os mesmos nove comandos do Exercício 01 — pwd, ls, mkdir, cd, touch, cat, echo, rm e mv. O cenário é outro, a árvore de diretórios é outra e algumas opções novas aparecem (ls -F, ls -t, ls -1, mkdir -pv, echo -e, echo -n, cat -b, mv -v). A repetição é proposital: fluência se constrói repetindo em contextos diferentes. Ao final, você será capaz de:

  • Executar os nove comandos sem consultar o roteiro, prevendo a saída antes de apertar Enter
  • Escolher entre ls -l, -a, -h, -t, -F, -1 e -R conforme a pergunta que você quer responder
  • Montar árvores de vários níveis com um único mkdir -p e conferir com ls -R
  • Navegar com caminhos absolutos, relativos, .., ~ e - sem se perder
  • Escrever arquivos inteiros com echo, dominando >, >>, -n e -e
  • Entender a diferença prática entre aspas simples e aspas duplas
  • Concatenar arquivos com cat e numerar linhas com -n e -b
  • Mover e renomear arquivos e diretórios com mv, inclusive vários de uma vez
  • Apagar com rm de forma consciente, validando curingas com ls antes
  • Diagnosticar sozinho as mensagens de erro mais comuns do terminal

Antes de Começar

Ambiente necessário

  • Acesso à sua VM Ubuntu via SSH ou terminal local
  • Usuário comum (nenhum passo precisa de root)
  • Shell Bash — confirme com echo $SHELL
  • Nada a instalar: os 9 comandos existem em qualquer Linux
  • Recomendado: ter feito o Exercício 01 antes

Regras do jogo

  • Digite os comandos — não copie e cole. A memória é muscular.
  • Nada de editores (nano, vim): todo conteúdo vem de echo
  • Antes do Enter, diga em voz alta o que espera ver na tela
  • Saída diferente do esperado? Pare e descubra o motivo antes de seguir
  • Tab autocompleta e ↑ repete o comando anterior
Sobre o ambiente do laboratório: todos os 33 passos rodam normalmente na sua VM Ubuntu, sem sudo em nenhum momento. Todo o trabalho acontece dentro do seu diretório pessoal ($HOME) — nada aqui pode quebrar o sistema.
Aviso de segurança — leia antes do primeiro rm: o terminal não tem lixeira. O que rm apaga, some. Neste exercício você só apagará arquivos que você mesmo criou, dentro de ~/radio-onda-livre. Nunca execute rm -rf em um caminho que você não digitou por inteiro e conferiu com ls.

Cronograma do Exercício

Horário Parte Passos Comandos em foco Duração
00:00 – 00:10 A — Chegando ao estúdio 1 – 5 pwd, ls 10 min
00:10 – 00:24 B — Montando o acervo 6 – 12 mkdir, cd 14 min
00:24 – 00:36 C — Abrindo as fichas 13 – 17 touch, ls 12 min
00:36 – 00:52 D — Gravando o conteúdo 18 – 24 echo, cat 16 min
00:52 – 01:06 E — Arrumando a discoteca 25 – 29 mv 14 min
01:06 – 01:18 F — Tirando o lixo do ar 30 – 33 rm, rmdir 12 min
01:18 – 01:25 Conferência final — ls -R 7 min
01:25 – 01:30 Desafio individual — todos os 9 5 min (+ casa)

Mapa da Estrutura Final

Você é o novo operador de estúdio da Rádio Comunitária "Onda Livre". O acervo digital da rádio está espalhado e sem organização nenhuma. Sua missão é criar, preencher, reorganizar e limpar a pasta de trabalho da emissora — usando apenas a linha de comando. Este é o destino final: 

/home/aluno/radio-onda-livre/
├── acervo/
│   ├── musicas/
│   │   ├── 2026-09-01-playlist.txt
│   │   ├── 2026-09-02-playlist.txt
│   │   └── 2026-09-03-playlist.txt
│   └── vinhetas/
│       └── vinhetas.txt
├── equipe/
│   └── operadores.txt
├── programacao/
│   ├── grade-do-dia.txt
│   ├── grade-manha.txt
│   └── grade-tarde.txt
└── roteiros/
    ├── roteiro-abertura.txt
    └── roteiro-encerramento.txt
No meio do caminho existirá um diretório rascunhos/ com arquivos descartáveis — ele será apagado na Parte F. Se ele ainda existir na conferência final, algum passo foi pulado. Ao final devem restar 4 diretórios na raiz e 10 arquivos no total.

Roteiro Passo a Passo

00:00 – 00:10 Parte A — Chegando ao estúdio (passos 1 a 5) 10 min

Todo turno de trabalho no terminal começa com as mesmas duas perguntas: onde eu estou? e o que existe aqui?. No Exercício 01 você respondeu isso com pwd e ls. Aqui você vai repetir — e conhecer quatro opções novas do ls que resolvem perguntas diferentes.

Passo 1 — Onde você está (pwd)

pwd = print working directory
$ pwd
/home/aluno

# O shell guarda esse caminho na variável PWD — veja com echo
$ echo $PWD
/home/aluno

O terminal sempre abre no seu diretório pessoal (home). É o único lugar do sistema onde você, como usuário comum, cria e apaga o que quiser. Todo o exercício acontece a partir daqui.

Passo 2 — O que existe aqui (ls e ls -F)

$ ls
(se você fez o Exercício 01, verá estacao-ares e desafio01; se não, talvez nada)

# -F acrescenta um marcador de tipo no final de cada nome
$ ls -F /etc
apt/  hostname  hosts  passwd  rc0.d/  resolv.conf@  ssh/
Os marcadores do -F: / diretório, @ link simbólico, * executável, nada = arquivo comum. É a forma mais rápida de saber "isso é pasta ou arquivo?" sem pedir a listagem longa.

Passo 3 — Listagem longa: leia cada coluna (ls -l)

$ ls -l /etc/hosts
-rw-r--r-- 1 root root 221 Sep  1 08:12 /etc/hosts

#  -rw-r--r--   1   root  root  221   Sep  1 08:12    /etc/hosts
#  │            │    │     │     │         │              │
#  │            │    │     │     │         │              └── nome
#  │            │    │     │     │         └───────────────── data/hora da última modificação
#  │            │    │     │     └───────────────────────────  tamanho em bytes
#  │            │    │     └───────────────────────────────── grupo dono
#  │            │    └─────────────────────────────────────── usuário dono
#  │            └──────────────────────────────────────────── nº de links
#  └───────────────────────────────────────────────────────── tipo + permissões

O primeiro caractere é o tipo: - arquivo comum, d diretório, l link simbólico. Os nove caracteres seguintes são as permissões (dono, grupo, outros) — assunto do módulo de permissões, mas você já pode ir reparando nelas.

Passo 4 — Arquivos ocultos e os diretórios . e ..

$ ls -a
.  ..  .bash_logout  .bashrc  .profile

$ ls -la
total 20
drwxr-x--- 2 aluno aluno 4096 Sep  1 08:02 .
drwxr-xr-x 3 root  root  4096 Sep  1 07:14 ..
-rw-r--r-- 1 aluno aluno  220 Sep  1 07:14 .bash_logout
-rw-r--r-- 1 aluno aluno 3771 Sep  1 07:14 .bashrc
-rw-r--r-- 1 aluno aluno  807 Sep  1 07:14 .profile

Nome que começa com ponto é oculto — não existe "atributo escondido" no Linux, é apenas uma convenção do nome. E note as duas primeiras linhas: . é o próprio diretório atual, .. é o pai. Eles existem em toda pasta do sistema e são a base da navegação relativa.

Passo 5 — Quatro perguntas, quatro opções do ls

# "Quanto ocupa?" → -lh deixa os tamanhos legíveis (K, M, G)
$ ls -lh /var/log | head -4
total 340K
-rw-r--r-- 1 root root   32K Sep  1 08:00 alternatives.log
drwxr-xr-x 2 root root  4.0K Sep  1 07:14 apt
-rw-rw---- 1 root utmp     0 Sep  1 07:14 btmp

# "O que mudou por último?" → -t ordena por data, do mais novo ao mais velho
$ ls -lt /etc | head -4
total 512
-rw-r--r-- 1 root root  221 Sep  1 08:12 hosts
-rw-r--r-- 1 root root   12 Sep  1 07:14 hostname
drwxr-xr-x 7 root root 4096 Sep  1 07:14 apt

# "Só os nomes, um por linha" → -1 (o número um, não a letra L)
$ ls -1 /etc | head -3
adduser.conf
alternatives
apt

# Você olhou para vários lugares, mas continua no mesmo
$ pwd
/home/aluno
Opções se combinam: ls -lah é o mesmo que ls -l -a -h. E ls -ltr (-r inverte a ordem) coloca o arquivo mais recente por último — o truque preferido de quem lê logs.
✔ Ponto de verificação A — responda sem olhar: (1) qual o caminho completo do seu home? (2) o que o marcador / do ls -F significa? (3) qual opção usar para achar o arquivo modificado mais recentemente? (4) por que ls às vezes não imprime nada?
00:10 – 00:24 Parte B — Montando o acervo (passos 6 a 12) 14 min

Passo 6 — Crie o diretório da rádio (mkdir)

# Sempre confirme onde você está ANTES de criar qualquer coisa
$ pwd
/home/aluno

$ mkdir radio-onda-livre
$ ls -ld radio-onda-livre
drwxr-xr-x 2 aluno aluno 4096 Sep  1 08:10 radio-onda-livre
ls -d mostra o próprio diretório em vez de listar o conteúdo dele — útil justamente para conferir permissões e tipo de uma pasta recém-criada. Repare no d inicial e no tamanho 4096: um diretório vazio já ocupa um bloco, porque ele é um arquivo especial que guarda a lista de nomes de dentro dele.

Passo 7 — Entre e confirme (cd + pwd)

$ cd radio-onda-livre
$ pwd
/home/aluno/radio-onda-livre

$ ls -a
.  ..   # pasta nova: só ela mesma e o pai

cd não imprime nada quando dá certo. Por isso o par cd + pwd é um hábito que vale ouro no começo — e continua valendo depois, antes de qualquer comando destrutivo.

Passo 8 — Vários diretórios em um comando só

# mkdir aceita quantos nomes você quiser, separados por espaço
$ mkdir programacao roteiros equipe
$ ls
equipe  programacao  roteiros
O ls lista em ordem alfabética, não na ordem de criação. Nomes no Linux são sensíveis a maiúsculas: Equipe e equipe seriam duas pastas distintas. Evite espaços nos nomes — use - ou _.

Passo 9 — Provoque um erro de propósito

# Criar uma pasta DENTRO de outra que ainda não existe
$ mkdir acervo/musicas
mkdir: cannot create directory 'acervo/musicas': No such file or directory

Erro no terminal é informação, não bronca. Leia devagar: a mensagem diz que o caminho intermediário (acervo) não existe. Saber ler mensagens de erro é metade do trabalho de um administrador.

Passo 10 — Resolva com mkdir -p (e veja o que ele fez com -v)

# -p = "parents": cria todos os diretórios que faltarem no caminho
# -v = "verbose": diz em voz alta o que criou
$ mkdir -pv acervo/musicas acervo/vinhetas
mkdir: created directory 'acervo'
mkdir: created directory 'acervo/musicas'
mkdir: created directory 'acervo/vinhetas'

# A pasta de trabalho descartável, com dois níveis
$ mkdir -p rascunhos/testes
$ ls rascunhos
testes

# Bônus do -p: rodar de novo NÃO dá erro (por isso ele vive em scripts)
$ mkdir -p acervo/musicas
$ mkdir acervo/musicas
mkdir: cannot create directory 'acervo/musicas': File exists
Repare que mkdir -pv só anunciou acervo uma vez: no segundo argumento a pasta já existia e ele seguiu em silêncio. Idempotência — "rodar de novo não muda o resultado" — é uma propriedade valiosíssima em automação.

Passo 11 — Veja a árvore inteira (ls -R)

$ ls -R
.:
acervo  equipe  programacao  rascunhos  roteiros

./acervo:
musicas  vinhetas

./acervo/musicas:

./acervo/vinhetas:

./equipe:

./programacao:

./rascunhos:
testes

./rascunhos/testes:

./roteiros:

-R significa recursivo: desce em todas as subpastas. Guarde essa letra — ela reaparece, muito mais perigosa, no rm -r da Parte F.

Passo 12 — Navegação: absoluto, relativo, .., ~ e -

Os cinco jeitos de se mover que você precisa dominar
# 1) Relativo: a partir de onde você está agora
$ cd acervo/musicas
$ pwd
/home/aluno/radio-onda-livre/acervo/musicas

# 2) .. sobe um nível; pode ser encadeado
$ cd ..
$ pwd
/home/aluno/radio-onda-livre/acervo

$ cd ../..
$ pwd
/home/aluno

# 3) Absoluto: começa com / e funciona de qualquer lugar
$ cd /home/aluno/radio-onda-livre/programacao
$ pwd
/home/aluno/radio-onda-livre/programacao

# 4) ~ é atalho para o SEU home (mesmo dentro de um caminho maior)
$ cd ~/radio-onda-livre/roteiros
$ pwd
/home/aluno/radio-onda-livre/roteiros

# 5) cd - volta ao diretório ANTERIOR (e imprime o destino)
$ cd -
/home/aluno/radio-onda-livre/programacao

# cd sem argumento nenhum volta para o home
$ cd
$ pwd
/home/aluno

# Volte para o projeto — todos os próximos passos partem daqui
$ cd ~/radio-onda-livre
$ pwd
/home/aluno/radio-onda-livre
✔ Ponto de verificação B — sua árvore deve ter acervo/musicas, acervo/vinhetas, equipe, programacao, roteiros e rascunhos/testes. Confirme com ls -R e termine com pwd mostrando /home/aluno/radio-onda-livre.
00:24 – 00:36 Parte C — Abrindo as fichas (passos 13 a 17) 12 min

Passo 13 — Crie arquivos vazios (touch)

# touch cria arquivos VAZIOS — vários de uma vez, como o mkdir
$ touch programacao/grade-manha.txt programacao/grade-tarde.txt
$ ls programacao
grade-manha.txt  grade-tarde.txt

Passo 14 — Confirme que estão mesmo vazios

$ ls -l programacao
total 0
-rw-r--r-- 1 aluno aluno 0 Sep  1 08:24 grade-manha.txt
-rw-r--r-- 1 aluno aluno 0 Sep  1 08:24 grade-tarde.txt

Tamanho 0 bytes e total 0: os arquivos existem, têm nome, dono, permissões e data — mas nenhum conteúdo. Arquivo vazio é perfeitamente normal no Linux e muito usado como marcador ("já processei este dia") ou placeholder.

Passo 15 — A outra função do touch: atualizar o horário

# Veja o horário atual do arquivo, com segundos
$ ls -l --time-style=+%H:%M:%S programacao/grade-manha.txt
-rw-r--r-- 1 aluno aluno 0 08:24:11 programacao/grade-manha.txt

# Espere 5 segundos e "toque" no arquivo de novo
$ sleep 5
$ touch programacao/grade-manha.txt
$ ls -l --time-style=+%H:%M:%S programacao/grade-manha.txt
-rw-r--r-- 1 aluno aluno 0 08:24:16 programacao/grade-manha.txt

# Agora o -t da Parte A faz sentido: o mais recente aparece primeiro
$ ls -t programacao
grade-manha.txt  grade-tarde.txt
O nome faz sentido: touch = "tocar". Se o arquivo não existe, ele é criado; se já existe, só a data de modificação muda e o conteúdo é preservado. Por isso touch nunca destrói dados — ao contrário do > que você verá no passo 19.

Passo 16 — As fichas de playlist dos três dias

$ touch acervo/musicas/2026-09-01-playlist.txt acervo/musicas/2026-09-02-playlist.txt acervo/musicas/2026-09-03-playlist.txt
$ ls -l acervo/musicas
total 0
-rw-r--r-- 1 aluno aluno 0 Sep  1 08:26 2026-09-01-playlist.txt
-rw-r--r-- 1 aluno aluno 0 Sep  1 08:26 2026-09-02-playlist.txt
-rw-r--r-- 1 aluno aluno 0 Sep  1 08:26 2026-09-03-playlist.txt
Datas no formato AAAA-MM-DD no começo do nome não são capricho: como o ls ordena alfabeticamente, esse formato faz a ordem alfabética coincidir com a ordem cronológica. É a convenção padrão (ISO 8601) para nomear arquivos.

Passo 17 — Dois arquivos, um deles no lugar errado (de propósito)

# A ficha da equipe vai para o lugar certo
$ touch equipe/operadores.txt

# Confirme que você está na RAIZ do projeto
$ pwd
/home/aluno/radio-onda-livre

# E a lista de vinhetas nasce aqui na raiz — consertamos na Parte E
$ touch vinhetas.txt
$ ls -F
acervo/  equipe/  programacao/  rascunhos/  roteiros/  vinhetas.txt

# O curinga * lista tudo que casa com o padrão
$ ls acervo/musicas/*.txt
acervo/musicas/2026-09-01-playlist.txt  acervo/musicas/2026-09-02-playlist.txt  acervo/musicas/2026-09-03-playlist.txt
✔ Ponto de verificação C — você deve ter 7 arquivos: 2 em programacao/, 3 em acervo/musicas/, 1 em equipe/ e 1 solto na raiz do projeto. Todos com 0 bytes. Confira com ls -lR | grep -c '^-' (deve responder 7).
00:36 – 00:52 Parte D — Gravando o conteúdo (passos 18 a 24) 16 min

Passo 18 — echo: o comando que só sabe falar

# echo imprime na tela o texto que você der a ele
$ echo Radio Onda Livre
Radio Onda Livre

# Sem aspas o shell colapsa os espaços múltiplos
$ echo Radio      Onda      Livre
Radio Onda Livre

# Com aspas, o texto vai exatamente como está
$ echo "Radio      Onda      Livre"
Radio      Onda      Livre

# Aspas DUPLAS expandem variáveis; aspas SIMPLES não expandem nada
$ echo "Operador: $USER — Estudio: $HOME"
Operador: aluno — Estudio: /home/aluno

$ echo 'Operador: $USER'
Operador: $USER

# -n não pula a linha no final; -e interpreta \n, \t e afins
$ echo -n "sem quebra de linha"
sem quebra de linha$   # o prompt cola no texto

$ echo -e "coluna1\tcoluna2\nvalor1\tvalor2"
coluna1	coluna2
valor1	valor2

Passo 19 — Redirecione a fala para dentro de um arquivo (>)

# > pega a saída do comando e joga DENTRO do arquivo, em vez da tela
$ echo "operador01=Ana" > equipe/operadores.txt

# Nenhuma saída na tela — o texto foi para o arquivo
$ ls -l equipe/operadores.txt
-rw-r--r-- 1 aluno aluno 15 Sep  1 08:37 equipe/operadores.txt

O arquivo saiu de 0 para 15 bytes: os 14 caracteres do texto mais o caractere de fim de linha (\n) que o echo acrescenta sozinho. Se o arquivo não existisse, > o criaria; como já existia, o conteúdo anterior (vazio) foi descartado sem aviso.

Passo 20 — Leia o arquivo (cat)

$ cat equipe/operadores.txt
operador01=Ana

# cat em arquivo inexistente: mais uma mensagem para aprender a ler
$ cat equipe/tecnicos.txt
cat: equipe/tecnicos.txt: No such file or directory

# cat em um DIRETÓRIO também reclama — e a mensagem é bem clara
$ cat equipe
cat: equipe: Is a directory
cat vem de concatenate. Ele foi criado para juntar arquivos — mostrar um arquivo na tela é só o caso particular de "concatenar um arquivo só". Você usará a função original dele no passo 24.

Passo 21 — Acrescente sem apagar o que já existe (>>)

# >> ACRESCENTA no final; > SOBRESCREVE tudo
$ echo "operador02=Bruno" >> equipe/operadores.txt
$ echo "operador03=Carla" >> equipe/operadores.txt
$ echo "turno_madrugada=Carla" >> equipe/operadores.txt

$ cat equipe/operadores.txt
operador01=Ana
operador02=Bruno
operador03=Carla
turno_madrugada=Carla

# Agora a grade da manhã: primeira linha com >, o resto com >>
$ echo "06:00 Despertar Comunitario" > programacao/grade-manha.txt
$ echo "08:00 Jornal da Manha" >> programacao/grade-manha.txt
$ echo "10:00 Musica Brasileira" >> programacao/grade-manha.txt
$ cat programacao/grade-manha.txt
06:00 Despertar Comunitario
08:00 Jornal da Manha
10:00 Musica Brasileira

Passo 22 — Grade da tarde e leitura numerada (cat -n e -b)

$ echo "12:00 Almoco com Forro" > programacao/grade-tarde.txt
$ echo "" >> programacao/grade-tarde.txt
$ echo "14:00 Roda de Conversa" >> programacao/grade-tarde.txt
$ echo "17:00 Esportes da Cidade" >> programacao/grade-tarde.txt

# -n numera TODAS as linhas, inclusive as vazias
$ cat -n programacao/grade-tarde.txt
     1  12:00 Almoco com Forro
     2
     3  14:00 Roda de Conversa
     4  17:00 Esportes da Cidade

# -b numera só as linhas NÃO vazias
$ cat -b programacao/grade-tarde.txt
     1  12:00 Almoco com Forro

     2  14:00 Roda de Conversa
     3  17:00 Esportes da Cidade
echo "" >> arquivo acrescenta uma linha em branco — o texto é vazio, mas o \n continua sendo escrito. É assim que se separa blocos dentro de um arquivo usando só echo.

Passo 23 — A armadilha do > (experimento controlado)

# Um rascunho descartável só para o experimento
$ echo "roteiro importante linha 1" > rascunhos/testes/roteiro.txt
$ echo "roteiro importante linha 2" >> rascunhos/testes/roteiro.txt
$ cat rascunhos/testes/roteiro.txt
roteiro importante linha 1
roteiro importante linha 2

# Agora use > por engano, achando que era >>
$ echo "ops" > rascunhos/testes/roteiro.txt
$ cat rascunhos/testes/roteiro.txt
ops
As duas linhas anteriores foram destruídas — sem aviso, sem confirmação, sem volta. É o erro nº 1 de quem está começando, e ele não perdoa nem depois de dez anos de carreira. Regra prática: > só na primeira escrita de um arquivo; >> em todas as seguintes. Na dúvida, >>.

Passo 24 — cat na função original: juntar arquivos

# Vários arquivos de uma vez: a saída sai emendada, na ordem dada
$ cat programacao/grade-manha.txt programacao/grade-tarde.txt
06:00 Despertar Comunitario
08:00 Jornal da Manha
10:00 Musica Brasileira
12:00 Almoco com Forro

14:00 Roda de Conversa
17:00 Esportes da Cidade

# Junte as duas grades em UM arquivo novo
$ cat programacao/grade-manha.txt programacao/grade-tarde.txt > programacao/grade-completa.txt
$ cat -b programacao/grade-completa.txt | tail -3
     4  12:00 Almoco com Forro
     5  14:00 Roda de Conversa
     6  17:00 Esportes da Cidade

# Preencha as três playlists (nenhum arquivo pode ficar com 0 bytes)
$ echo "01 - Asa Branca" > acervo/musicas/2026-09-01-playlist.txt
$ echo "02 - Ponteio" >> acervo/musicas/2026-09-01-playlist.txt
$ echo "01 - Constelacao" > acervo/musicas/2026-09-02-playlist.txt
$ echo "01 - Trem das Onze" > acervo/musicas/2026-09-03-playlist.txt

# A lista de vinhetas (ainda na raiz — ela se muda na Parte E)
$ echo "vinheta-abertura 8s" > vinhetas.txt
$ echo "vinheta-hora-certa 4s" >> vinhetas.txt
$ echo "vinheta-encerramento 6s" >> vinhetas.txt

# E os dois roteiros, também na raiz de propósito
$ echo "Boa noite, voce esta na Onda Livre." > abertura.txt
$ echo "Ate amanha, obrigado por ouvir." > encerramento.txt

$ ls -F
abertura.txt  acervo/  encerramento.txt  equipe/  programacao/  rascunhos/  roteiros/  vinhetas.txt
Repare que cat a b > c emenda bytes, sem nenhuma inteligência: se os dois arquivos tivessem cabeçalho, o cabeçalho apareceria duas vezes. Filtrar isso é trabalho de grep, head e tail, que você verá no próximo módulo.
✔ Ponto de verificação D — explique com suas palavras: (1) a diferença entre > e >>; (2) por que echo 'turno: $USER' não mostra seu nome de usuário; (3) o que cat a b > c faz exatamente; (4) a diferença entre cat -n e cat -b.
00:52 – 01:06 Parte E — Arrumando a discoteca (passos 25 a 29) 14 min
A grande sacada do mv: renomear e mover são a mesma operação. Um arquivo é um nome dentro de um diretório; mudar o nome ou mudar o diretório é sempre "apagar a entrada antiga e escrever uma nova". Por isso o Linux nem precisa de um comando rename separado.

Passo 25 — Renomear um arquivo

# Sintaxe: mv ORIGEM DESTINO — mesmo diretório = renomear
$ mv -v programacao/grade-completa.txt programacao/grade-do-dia.txt
renamed 'programacao/grade-completa.txt' -> 'programacao/grade-do-dia.txt'

$ ls programacao
grade-do-dia.txt  grade-manha.txt  grade-tarde.txt

O -v do mv usa a palavra renamed justamente porque, para o sistema, mover e renomear são a mesma coisa. Adote o -v como hábito: ele é gratuito e transforma um comando silencioso em um comando auditável.

Passo 26 — Mover o arquivo que ficou no lugar errado

# Lembra do vinhetas.txt criado na raiz no passo 17? Hora de arrumar.
$ ls
abertura.txt  acervo  encerramento.txt  equipe  programacao  rascunhos  roteiros  vinhetas.txt

# Quando o DESTINO é um diretório existente, o arquivo entra nele com o mesmo nome
$ mv -v vinhetas.txt acervo/vinhetas/
renamed 'vinhetas.txt' -> 'acervo/vinhetas/vinhetas.txt'

$ ls acervo/vinhetas
vinhetas.txt
A barra final em acervo/vinhetas/ não é obrigatória, mas é um hábito excelente: ela deixa explícito "o destino é um diretório". Sem a barra, se você errar o nome do diretório, o mv silenciosamente renomeia o arquivo em vez de movê-lo — e você fica procurando um arquivo que "sumiu".

Passo 27 — Mover vários de uma vez e depois padronizar os nomes

# Com vários arquivos, o ÚLTIMO argumento TEM que ser um diretório
$ mv -v abertura.txt encerramento.txt roteiros/
renamed 'abertura.txt' -> 'roteiros/abertura.txt'
renamed 'encerramento.txt' -> 'roteiros/encerramento.txt'

$ ls
acervo  equipe  programacao  rascunhos  roteiros

# Agora padronize o nome dos dois, com o prefixo "roteiro-"
$ mv roteiros/abertura.txt roteiros/roteiro-abertura.txt
$ mv roteiros/encerramento.txt roteiros/roteiro-encerramento.txt
$ ls roteiros
roteiro-abertura.txt  roteiro-encerramento.txt

# O curinga também funciona no mv — mas teste SEMPRE com ls antes
$ ls roteiros/*.txt
roteiros/roteiro-abertura.txt  roteiros/roteiro-encerramento.txt

Passo 28 — Renomear um diretório inteiro

# mv funciona igual com diretórios — leva todo o conteúdo junto
$ mv acervo acervo-2026
$ ls
acervo-2026  equipe  programacao  rascunhos  roteiros

$ ls -R acervo-2026
acervo-2026:
musicas  vinhetas

acervo-2026/musicas:
2026-09-01-playlist.txt  2026-09-02-playlist.txt  2026-09-03-playlist.txt

acervo-2026/vinhetas:
vinhetas.txt   # nada se perdeu

# Desfaça: volte ao nome original (a operação é simétrica)
$ mv acervo-2026 acervo
$ ls
acervo  equipe  programacao  rascunhos  roteiros
Renomear um diretório com 10 mil arquivos dentro é instantâneo: nada é copiado, só a entrada do nome muda. Isso vale enquanto origem e destino estão no mesmo sistema de arquivos — entre discos diferentes, o mv copia e apaga, e aí demora.

Passo 29 — O perigo silencioso do mv

# Dois arquivos de teste, com conteúdos diferentes
$ echo "SOU O ARQUIVO A" > rascunhos/a.txt
$ echo "SOU O ARQUIVO B" > rascunhos/b.txt
$ cat rascunhos/a.txt rascunhos/b.txt
SOU O ARQUIVO A
SOU O ARQUIVO B

# mv sobre um arquivo EXISTENTE sobrescreve sem perguntar nada
$ mv rascunhos/a.txt rascunhos/b.txt
$ ls rascunhos
b.txt  testes   # a.txt sumiu...

$ cat rascunhos/b.txt
SOU O ARQUIVO A   # ...e o conteúdo original de B foi destruído

# As duas proteções que você deve adotar como hábito:
$ echo "novo A" > rascunhos/a.txt
$ mv -i rascunhos/a.txt rascunhos/b.txt
mv: overwrite 'rascunhos/b.txt'? n   # -i pergunta antes (responda n)

$ mv -n rascunhos/a.txt rascunhos/b.txt
$ ls rascunhos
a.txt  b.txt  testes   # -n simplesmente não sobrescreve, sem perguntar
✔ Ponto de verificação E — a raiz do projeto deve conter apenas acervo, equipe, programacao, rascunhos e roteiros; acervo/musicas deve ter 3 playlists, programacao 3 grades e roteiros 2 roteiros com prefixo. Confirme com ls -R.
01:06 – 01:18 Parte F — Tirando o lixo do ar (passos 30 a 33) 12 min
Leia antes de digitar: rm não manda para a lixeira. Ele remove o nome do arquivo do diretório e o espaço volta para o sistema. Não existe "desfazer". Confira o caminho duas vezes antes do Enter — sempre.

Passo 30 — Apagar um arquivo (rm, rm -i, rm -v)

# Material descartável para a faxina
$ touch rascunhos/corte1.log rascunhos/corte2.log rascunhos/corte3.log
$ ls rascunhos
a.txt  b.txt  corte1.log  corte2.log  corte3.log  testes

# rm simples: apaga e não diz nada
$ rm rascunhos/corte1.log
$ ls rascunhos
a.txt  b.txt  corte2.log  corte3.log  testes

# -i pergunta antes de cada arquivo (responda y)
$ rm -i rascunhos/corte2.log
rm: remove regular empty file 'rascunhos/corte2.log'? y

# -v mostra o que foi apagado — ótimo para auditoria
$ rm -v rascunhos/corte3.log
removed 'rascunhos/corte3.log'

Passo 31 — Vários arquivos e o cuidado com o curinga

# Vários nomes de uma vez
$ rm -v rascunhos/a.txt rascunhos/b.txt
removed 'rascunhos/a.txt'
removed 'rascunhos/b.txt'

# REGRA DE OURO: antes de rm com curinga, teste o padrão com ls
$ touch rascunhos/x1.tmp rascunhos/x2.tmp rascunhos/manter.txt
$ ls rascunhos/*.tmp
rascunhos/x1.tmp  rascunhos/x2.tmp   # confirmado: só o que eu quero apagar

$ rm -v rascunhos/*.tmp
removed 'rascunhos/x1.tmp'
removed 'rascunhos/x2.tmp'

$ ls rascunhos
manter.txt  testes   # o que não casava com o padrão sobreviveu
Os três comandos que já destruíram sistemas inteiros: rm -rf / (apaga a raiz), rm -rf * executado no diretório errado (por isso pwd antes!) e rm -rf / home/aluno/x — um espaço a mais depois da barra transforma o comando em "apague a raiz e a pasta x".

Passo 32 — Diretórios: rmdir vs. rm -r

# rm comum se recusa a apagar diretório — é uma proteção
$ rm rascunhos
rm: cannot remove 'rascunhos': Is a directory

# rmdir só funciona em diretório VAZIO — é a forma mais segura
$ rmdir rascunhos/testes
rmdir: failed to remove 'rascunhos/testes': Directory not empty

# Por quê? O roteiro.txt do passo 23 ainda está lá dentro
$ ls rascunhos/testes
roteiro.txt

$ rm rascunhos/testes/roteiro.txt
$ rmdir rascunhos/testes        # agora sim: o diretório está vazio
$ ls rascunhos
manter.txt

# Em diretório com conteúdo, rmdir se recusa (e ainda bem)
$ rmdir rascunhos
rmdir: failed to remove 'rascunhos': Directory not empty

$ rmdir acervo
rmdir: failed to remove 'acervo': Directory not empty   # seu acervo está a salvo
Pense no rmdir como um cinto de segurança: ele só funciona quando não há nada a perder. Sempre que você acha que um diretório está vazio, use rmdir — se ele reclamar, você acabou de evitar um acidente.

Passo 33 — A faxina final com rm -r

# SEMPRE confira onde você está e o que exatamente vai apagar
$ pwd
/home/aluno/radio-onda-livre
$ ls -R rascunhos
rascunhos:
manter.txt

# -r = recursivo: apaga o diretório e TUDO que houver dentro
$ rm -rv rascunhos
removed 'rascunhos/manter.txt'
removed directory 'rascunhos'

$ ls -F
acervo/  equipe/  programacao/  roteiros/   # rascunhos/ não existe mais
✔ Ponto de verificação F — explique a diferença entre rmdir, rm -r e rm -rf, e diga quais dois comandos você digita antes de qualquer rm com curinga.

Conferência Final

Rode os comandos abaixo e compare com a saída esperada:

$ cd ~/radio-onda-livre
$ pwd
/home/aluno/radio-onda-livre

$ ls -R
.:
acervo  equipe  programacao  roteiros

./acervo:
musicas  vinhetas

./acervo/musicas:
2026-09-01-playlist.txt  2026-09-02-playlist.txt  2026-09-03-playlist.txt

./acervo/vinhetas:
vinhetas.txt

./equipe:
operadores.txt

./programacao:
grade-do-dia.txt  grade-manha.txt  grade-tarde.txt

./roteiros:
roteiro-abertura.txt  roteiro-encerramento.txt

# Contagem rápida: 4 diretórios na raiz e 10 arquivos no total
$ ls -lR | grep -c '^-'
10

# Nenhum arquivo pode estar com 0 bytes — esta busca não deve achar nada
$ ls -lR | grep ' 0 '
(nenhuma saída = tudo tem conteúdo)

Autoavaliação — marque o que você concluiu

  • Fiz o exercício inteiro sem consultar o Exercício 01
  • Sei escolher entre ls -l, -a, -h, -t, -F, -1, -d e -R conforme a pergunta
  • Criei uma árvore de dois níveis com um único mkdir -p e entendi por que ele é idempotente
  • Navego entre caminho absoluto, relativo, .., ~ e - sem me perder
  • Usei touch tanto para criar quanto para atualizar a data de um arquivo
  • Escrevi arquivos inteiros só com echo, incluindo linha em branco e -e com \t
  • Perdi conteúdo de propósito com > e sei exatamente por quê
  • Concatenei arquivos com cat a b > c e sei a diferença entre -n e -b
  • Movi, renomeei e padronizei nomes com mv, usando -v por hábito
  • Vi o mv sobrescrever sem avisar e conheço -i e -n
  • Testei o curinga com ls antes de usá-lo com rm
  • Sei quando usar rmdir e quando usar rm -r
  • A estrutura final bate exatamente com a saída de ls -R acima

Desafio Individual

⚡ Desafio — "Plantão de Madrugada"

Duração: 20 minutos  |  Formato: Individual, sem consultar o roteiro acima  |  Entregável: ~/desafio02/prova.txt

Missão

A rádio vai estrear um programa de madrugada e precisa de uma pasta própria. Monte a estrutura abaixo em ~/desafio02 usando apenas os nove comandos deste exercício (pwd, ls, mkdir, cd, touch, cat, echo, rm, mv) e os redirecionamentos > e >>. Nada de editores de texto. 

~/desafio02/
├── audio/
│   ├── trilhas/
│   │   └── trilha-madrugada.txt   (3 linhas: 3 faixas)
│   └── locucoes/
│       └── locucao-01.txt         (2 linhas)
├── grade/
│   ├── grade-madrugada.txt        (4 linhas: 00:00, 01:00, 02:00, 03:00)
│   └── grade-final.txt            (trilha + locução + grade, via cat)
├── docs/
│   └── LEIA-ME.txt                (4 linhas: seu nome, data, nome do programa e objetivo)
└── prova.txt                      (gerado no último passo)

Regras adicionais

  • Crie audio/trilhas, audio/locucoes, grade e docs com um único mkdir -p
  • trilha-madrugada.txt deve nascer na raiz de ~/desafio02 e chegar a audio/trilhas/ via mv
  • locucao-01.txt deve nascer com outro nome (ex.: loc1.txt) e ser renomeado com mv
  • grade-final.txt tem que ser produzido por um único cat ... > ...
  • Crie um diretório temp/ com pelo menos 2 arquivos e apague-o por completo antes do final
  • Use aspas duplas para incluir a data via $(date +%F) no LEIA-ME.txt
  • Nenhum arquivo pode ficar com 0 bytes ao final (confira com ls -lR)

Passo final — gerar a prova

$ cd ~/desafio02
$ echo "Aluno: SEU NOME AQUI" > prova.txt
$ echo "Exercicio: 02 — O Acervo da Radio" >> prova.txt
$ echo "Data: $(date '+%Y-%m-%d %H:%M')" >> prova.txt
$ echo "Diretorio: $(pwd)" >> prova.txt
$ echo "--- estrutura ---" >> prova.txt
$ ls -lR >> prova.txt
$ echo "--- conteudos ---" >> prova.txt
$ cat audio/trilhas/trilha-madrugada.txt audio/locucoes/locucao-01.txt grade/grade-madrugada.txt docs/LEIA-ME.txt >> prova.txt

# Confira o resultado antes de entregar
$ cat prova.txt

Bônus (opcional)

  • Monte a estrutura inteira sem nunca usar cd — só com caminhos relativos e absolutos
  • Descubra com ls -l quantos bytes tem cada arquivo e explique de onde vem cada byte (dica: o \n final conta)
  • Use echo -e para escrever grade-madrugada.txt inteiro com um único echo
  • Refaça o desafio do zero em menos de 5 minutos, apagando tudo antes com um único rm -r ~/desafio02

Erros Comuns e Como Sair Deles

Mensagem / sintoma O que realmente aconteceu Como resolver
No such file or directory O caminho digitado não existe a partir de onde você está pwd para se localizar e ls no diretório pai; use Tab para autocompletar
mkdir: ... No such file or directory Você pediu uma pasta dentro de outra que ainda não existe Use mkdir -p
File exists O diretório já tinha sido criado antes Ignore, ou use mkdir -p que não reclama
Is a directory rm ou cat recebeu uma pasta em vez de um arquivo rm -r para apagar a pasta; ls para ver o conteúdo
Directory not empty rmdir só remove diretórios vazios Esvazie antes, ou use rm -r com atenção
Permission denied Você tentou escrever fora do seu $HOME Volte para ~; neste exercício nada exige sudo
mv: target ... is not a directory Você passou vários arquivos, mas o último argumento não é uma pasta Confirme o destino com ls -ld destino e termine com /
O arquivo ficou vazio "do nada" Você usou > onde queria >> Não tem desfazer — reescreva. Adote >> como padrão
O mv renomeou em vez de mover O diretório de destino estava com o nome errado ou não existia Termine o destino com / e confirme com ls antes
O echo -e imprimiu -e na tela Você está em um shell cujo echo não aceita essa opção Confirme com echo $SHELL que está no Bash; em outros shells use printf
O terminal "travou" e não volta o $ Um comando aguarda entrada (aspas abertas, cat sem arquivo) Ctrl+C cancela; Ctrl+D encerra a entrada
O nome do arquivo virou dois arquivos Havia espaço no nome sem aspas Use "nome com espaco" ou, melhor, nome-com-hifen

Referência Rápida dos 9 Comandos

pwd — onde estou

pwd        → caminho atual completo
echo $PWD  → o mesmo, via variável

ls — o que existe

ls         → nomes
ls -l      → detalhes (tipo, dono, tamanho)
ls -a      → inclui ocultos (.arquivo)
ls -lh     → tamanhos legíveis (K, M, G)
ls -F      → marca tipo (/ @ *)
ls -t      → ordena por data (-r inverte)
ls -1      → um nome por linha
ls -d DIR  → a pasta, não o conteúdo
ls -R      → desce nas subpastas

cd — mudar de lugar

cd dir     → entra (relativo)
cd /a/b    → caminho absoluto
cd ..      → sobe um nível
cd ~  ou cd → vai para o home
cd -       → volta ao anterior

mkdir — criar pastas

mkdir a          → uma pasta
mkdir a b c      → várias
mkdir -p a/b/c   → árvore inteira
mkdir -pv a/b    → e diz o que criou
mkdir -p (2ª vez)→ não reclama

touch — criar / tocar

touch f          → cria vazio
touch f1 f2 f3   → vários
touch f (existe) → só atualiza a data

echo — falar / escrever

echo texto       → imprime na tela
echo "$USER"     → expande variável
echo 'x'         → literal, sem expansão
echo -n x        → sem quebra de linha
echo -e "a\tb"   → interpreta \t \n
echo x >  f      → cria/SOBRESCREVE
echo x >> f      → ACRESCENTA no fim
echo "" >> f     → linha em branco

cat — ler / juntar

cat f            → mostra o conteúdo
cat -n f         → numera todas as linhas
cat -b f         → numera só as não vazias
cat a b          → emenda na tela
cat a b > c      → emenda em arquivo

mv — mover / renomear

mv a b           → renomeia
mv a dir/        → move
mv a b c dir/    → move vários
mv -v            → mostra o que fez
mv -i            → pergunta antes
mv -n            → nunca sobrescreve

rm — apagar (sem volta)

rm f             → apaga arquivo
rm -i f          → pergunta antes
rm -v f          → mostra o que apagou
rm -r dir        → apaga pasta e conteúdo
rmdir dir        → só se estiver vazia

Checklist de Avaliação

Critério Iniciante Intermediário Avançado
Localização e navegação Usa pwd e cd com caminhos simples Alterna entre absoluto e relativo com .. e ~ Navega sem hesitar, usa cd - e trabalha com caminhos longos sem se perder
Listagem Executa ls e ls -l Combina opções (-lah) e lista outros diretórios sem entrar Escolhe -t, -F, -1 ou -R conforme a pergunta a responder
Criação de estrutura Cria uma pasta por vez Cria várias pastas e usa mkdir -p Monta a árvore inteira em um comando e explica por que -p é idempotente
Arquivos e conteúdo Cria arquivos com touch e lê com cat Escreve arquivos completos com echo, > e >> Usa -n/-e, concatena arquivos e explica aspas simples × duplas
Reorganização Renomeia um arquivo com mv Move vários arquivos e renomeia diretórios Explica por que mover e renomear são a mesma operação e usa -v/-i/-n por hábito
Remoção segura Apaga um arquivo com rm Distingue rmdir de rm -r e usa -i Valida curingas com ls antes de apagar e explica os riscos do rm -rf
Leitura de erros Percebe que houve erro Identifica a causa a partir da mensagem Corrige sozinho e antecipa o erro antes de apertar Enter
Autonomia (vs. Exercício 01) Precisa consultar o Exercício 01 com frequência Consulta apenas em pontos específicos Executa os 33 passos sem consultar nada e prevê cada saída

Pontuação Sugerida

Iniciante — 0 a 5 pts

Completa os 33 passos seguindo o roteiro, mas ainda depende dele para navegar; não conclui o desafio sem ajuda.

Intermediário — 6 a 8 pts

Estrutura final correta, conclui o desafio consultando pouco, sabe explicar > vs. >> e rmdir vs. rm -r.

Avançado — 9 a 10 pts

Conclui o desafio e o bônus, prevê a saída antes de rodar e corrige qualquer erro lendo apenas a mensagem do terminal.

Entrega

O que enviar

  • O conteúdo de ~/desafio02/prova.txt (copie e cole no formulário da disciplina)
  • A saída de ls -R ~/radio-onda-livre mostrando a estrutura final do roteiro
  • Uma resposta em 3 linhas: o que ficou mais fácil em relação ao Exercício 01 e o que ainda não ficou
Comando único que gera tudo o que deve ser entregue
$ echo "=== ENTREGA — Exercicio 02 — SEU NOME ===" > ~/entrega02.txt
$ echo "Data: $(date '+%F %H:%M')" >> ~/entrega02.txt
$ echo "--- radio-onda-livre ---" >> ~/entrega02.txt
$ ls -R ~/radio-onda-livre >> ~/entrega02.txt
$ echo "--- desafio02 ---" >> ~/entrega02.txt
$ cat ~/desafio02/prova.txt >> ~/entrega02.txt
$ cat ~/entrega02.txt

Recursos e Referências

LPI (referência principal)

Documentação no próprio sistema

  • 📖 man ls · man mv · man rm · man touch
  • 📖 ls --help — resumo rápido das opções
  • 📖 help cd · help pwd · help echo (são builtins do Bash)

Leitura complementar

Orientações Gerais

Como aproveitar melhor este exercício

  • Preveja antes de rodar. Diga em voz alta o que espera ver e só então aperte Enter — o aprendizado mora na diferença entre a previsão e o resultado
  • Se você fez o Exercício 01, tente cada passo antes de ler a solução: o roteiro vira gabarito, não receita
  • Use Tab obsessivamente: além de poupar digitação, ele prova que o caminho existe
  • Rode pwd sempre que sentir a menor dúvida — é gratuito e evita 90% dos acidentes
  • Quando um comando falhar, leia a mensagem inteira antes de tentar outra coisa
  • Refaça o roteiro do zero (apague ~/radio-onda-livre com rm -r) até conseguir sem olhar

Erros conceituais a evitar

  • Achar que "nenhuma saída" é erro — no Unix, silêncio é sinal de sucesso
  • Confundir / (raiz do sistema) com ~ (seu home)
  • Usar > quando queria >> — a causa nº 1 de conteúdo perdido
  • Digitar rm com curinga sem antes testar o padrão com ls
  • Esquecer a barra final no destino do mv e acabar renomeando em vez de mover
  • Colocar espaços em nomes de arquivos: tecnicamente permitido, praticamente uma dor de cabeça
  • Esquecer que nomes são sensíveis a maiúsculas: Acervo ≠ acervo
‹ Exercício 01 — Sobrevivência no Terminal Exercício Prático 02 · 33 passos · 90 min Exercício 03 — Cópias, Backup e Restauração ›