Ubuntu cat, less, head, tail

Configurações, logs e anotações no Linux são arquivos de texto. Para lê-los sem abrir um editor (e sem correr o risco de alterar algo), existem quatro comandos. Cada um serve para um tamanho de arquivo e uma situação diferente.

Você vai aprender

Qual comando usar para cada situação: arquivo curto, longo, começo, fim.
Navegar e buscar dentro de um arquivo com o less.
Ver as primeiras e as últimas linhas com head e tail.
Acompanhar um log ao vivo com tail -f.
Entender as mensagens de erro, algumas em inglês no Ubuntu 26.04.

A ideia: escolha pelo tamanho

Situação	Comando	Por quê
Arquivo curto (cabe na tela)	`cat`	Mostra tudo de uma vez e volta ao prompt.
Arquivo longo	`less`	Mostra uma tela por vez, com rolagem e busca.
Só o começo	`head`	Primeiras linhas: cabeçalhos, primeiros registros.
Só o fim	`tail`	Últimas linhas: o que acabou de acontecer num log.
Acompanhar ao vivo	`tail -f`	Mostra as linhas novas assim que aparecem.

cat: mostrar o arquivo inteiro

cat vem de concatenate, "juntar em sequência". Ele foi feito para juntar vários arquivos, mas o uso mais comum é mostrar um só.

cat: O programa.
notas.txt: O arquivo a mostrar.

$ cat notas.txt
Comprar café
Ligar para o João
Estudar Ubuntu
Fazer backup das fotos

Numerar as linhas: `-n`

Útil quando uma mensagem de erro diz "linha 3" e você quer achá-la:

$ cat -n notas.txt
     1	Comprar café
     2	Ligar para o João
     3	Estudar Ubuntu
     4	Fazer backup das fotos

Juntar arquivos

Com vários arquivos, o cat mostra um depois do outro, sem separação. Com >, o resultado vira um arquivo novo (veja Redirecionamento):

$ cat notas.txt ../frutas.txt > tudo.txt
$ wc -l tudo.txt
11 tudo.txt                  « 4 linhas + 7 linhas

Atenção com arquivos grandes ou que não são texto

cat num log de milhares de linhas inunda a tela. Num arquivo que não é texto (uma imagem, um programa), ele mostra símbolos estranhos e pode bagunçar o terminal. Se isso acontecer, digite reset e aperte Enter, mesmo sem ver o que digita.

less: ler arquivos longos

O less mostra uma tela por vez. Você rola, busca e sai quando quiser. O nome é uma brincadeira com o programa antigo more ("mais"): less is more, "menos é mais".

$ less /etc/passwd

A tela fica ocupada pelo arquivo. Na última linha aparece : esperando teclas, ou (END) quando você chega ao fim. Nada é alterado no arquivo: o less só lê.

Tecla	O que faz
`Espaço` ou `PgDn`	Desce uma tela
`b` ou `PgUp`	Sobe uma tela
`↓` `↑` ou `j` `k`	Desce / sobe uma linha
`g` / `G`	Vai para o começo / para o fim
`/`palavra `Enter`	Procura "palavra" para a frente
`n` / `N`	Próxima / anterior ocorrência da busca
`F`	Segue o arquivo ao vivo, como `tail -f` (`Ctrl`+`C` para parar)
`h`	Ajuda
`q`	Sai

Você já usou o less

O man mostra os manuais dentro do less. As mesmas teclas valem lá (veja Obtendo Ajuda).

Opções úteis: less -N numera as linhas, less -S não quebra linhas compridas (role para os lados com →) e less +G já abre no fim.

O less é interativo e não funciona no terminal simulado. Experimente no seu Ubuntu: less /etc/services, procure /ssh e saia com q.

head: o começo

head ("cabeça") mostra as primeiras linhas. Sem opções, mostra 10.

head: O programa.
-n 3: Quantas linhas mostrar (number). -n 3 e -3 são equivalentes.
acesso.log: O arquivo.

$ head -n 3 acesso.log
192.168.0.10 - - [15/Oct/2026:09:01:12] "GET / HTTP/1.1" 200
192.168.0.23 - - [15/Oct/2026:09:01:40] "GET /contato HTTP/1.1" 200
192.168.0.10 - - [15/Oct/2026:09:02:03] "GET /admin HTTP/1.1" 403

tail: o fim

tail ("cauda") mostra as últimas linhas. Em logs, as linhas mais novas ficam no fim. Por isso, tail é o jeito de ver "o que acabou de acontecer".

$ tail -n 2 acesso.log
192.168.0.10 - - [15/Oct/2026:09:06:44] "POST /login HTTP/1.1" 200
192.168.0.23 - - [15/Oct/2026:09:07:02] "GET / HTTP/1.1" 200      « o acesso mais recente

A partir de uma linha: `-n +N`

Com o sinal de mais, o tail mostra da linha N até o fim. É o jeito de pular um cabeçalho:

$ cat frutas.txt
banana
maçã
laranja
banana
uva
maçã
banana
$ tail -n +5 frutas.txt
uva                       « começa na linha 5
maçã
banana

Missão: em acesso.log, mostre só o primeiro acesso do dia e depois só os dois últimos. Bônus: mostre o arquivo inteiro com as linhas numeradas.

tail -f: acompanhar um log ao vivo

-f (de follow, "seguir") mostra as últimas linhas e continua esperando. Cada linha nova que o programa escrever aparece na hora. É assim que se investiga um problema enquanto ele acontece.

$ tail -f /var/log/syslog
Oct 15 10:31:02 notebook systemd[1]: Started anacron.service - Run anacron jobs.
Oct 15 10:31:05 notebook NetworkManager[812]: <info>  [1760535065.1] device (wlp2s0): state change: activated
Oct 15 10:31:40 notebook kernel: usb 1-2: new high-speed USB device number 5 using xhci_hcd   « você plugou um pendrive

O terminal fica "preso" mostrando o log. Para sair, aperte Ctrl+C.

Use tail -F (maiúsculo) quando o log pode ser trocado durante a leitura, como acontece na rotação de logs: ele reabre o arquivo novo sozinho. As linhas do exemplo são ilustrativas; no seu sistema elas serão outras.

Logs do systemd

Muitos serviços escrevem no journal do systemd em vez de um arquivo. O equivalente do tail -f ali é journalctl -f (veja Logs).

Formas diferentes de ler o mesmo arquivo

Objetivo	Comando
Ver tudo, arquivo curto	`cat arquivo`
Ver tudo, arquivo longo	`less arquivo`
Contar as linhas antes de decidir	`wc -l arquivo` (veja wc)
Só as linhas com uma palavra	`grep erro arquivo` (veja grep)
Linhas 20 a 30	`head -n 30 arquivo \| tail -n 11`
Log compactado (`.gz`)	`zcat syslog.2.gz` ou `zless syslog.2.gz`
De trás para a frente	`tac arquivo` (é "cat" ao contrário)
Com interface gráfica	`gnome-text-editor arquivo` ou duplo clique no app Arquivos

$ wc -l acesso.log
6 acesso.log
$ head -n 4 acesso.log | tail -n 2
192.168.0.10 - - [15/Oct/2026:09:02:03] "GET /admin HTTP/1.1" 403    « linha 3
192.168.0.57 - - [15/Oct/2026:09:05:19] "GET /fotos HTTP/1.1" 404    « linha 4

O | (pipe) passa a saída de um comando para o próximo. Você vai aprender isso em Pipes e xargs.

Quando não funciona

"No such file or directory" (em inglês)

$ cat Notas.txt
cat: Notas.txt: No such file or directory
$ head relatorio
head: cannot open 'relatorio' for reading: No such file or directory

O que aconteceu: o arquivo não existe com esse nome exato (aqui, maiúscula errada e falta a extensão). No Ubuntu 26.04, cat, head e tail vêm do coreutils em Rust e mostram as mensagens em inglês.

Como resolver: ls e Tab.

"É um diretório"

$ cat projetos
cat: projetos: É um diretório

Como resolver: para ver o que tem numa pasta, use ls projetos.

"Permission denied"

$ tail /etc/shadow
tail: cannot open '/etc/shadow' for reading: Permission denied

O que aconteceu: o arquivo só pode ser lido pelo root (ou por um grupo do qual você não faz parte).

Como resolver: sudo tail /etc/shadow. Para logs, o usuário criado na instalação do Ubuntu já está no grupo adm, que pode ler a maioria dos arquivos de /var/log.

"Fiquei preso no less" ou "o terminal não volta"

O que aconteceu: o less espera teclas; o tail -f espera linhas novas.

Como resolver: no less, aperte q. No tail -f (ou se o cat ficou esperando porque você esqueceu o nome do arquivo), aperte Ctrl+C.

Referência de opções

Comando	Descrição
`cat -n arq`	Numera todas as linhas
`cat -A arq`	Mostra caracteres invisíveis (fim de linha `$`, tabs `^I`)
`less -N arq`	Numera as linhas
`less -S arq`	Não quebra linhas longas
`less +G arq`	Abre no fim
`head -n N arq`	Primeiras N linhas (padrão 10)
`head -c N arq`	Primeiros N bytes
`tail -n N arq`	Últimas N linhas (padrão 10)
`tail -n +N arq`	Da linha N até o fim
`tail -f arq`	Segue o arquivo ao vivo
`tail -F arq`	Segue mesmo se o arquivo for trocado (rotação)

Exercícios

1. As 20 últimas

Complete para ver as 20 últimas linhas do syslog:

-n 20 /var/log/syslog

2. Ao vivo

Complete para acompanhar o log enquanto ele cresce:

tail /var/log/syslog

3. Linhas numeradas

Complete para mostrar o arquivo com as linhas numeradas:

cat config.txt

4. Qual tecla sai do less?

Esc q x Ctrl+D

5. Um log tem 50 mil linhas e você quer saber o que aconteceu agora há pouco. Qual a melhor escolha?

cat log head log less log e rolar até o fim com a seta tail log

Resumo

cat para arquivos curtos; less para longos (/ busca, q sai).
head mostra o começo e tail o fim; -n escolhe quantas linhas.
tail -n +N começa na linha N; tail -f acompanha ao vivo (Ctrl+C para).
No Ubuntu 26.04, os erros de cat, head e tail aparecem em inglês.