Ubuntu sort, uniq, cut, wc, tr

Estes cinco comandos são peças pequenas: cada um faz uma coisa só com texto. Sozinhos parecem simples demais. Encaixados com o | (pipe), respondem perguntas como "qual IP mais acessou meu site?" ou "quais palavras se repetem nesta lista?", sem planilha e sem programar.

Você vai aprender

wc para contar linhas, palavras e bytes.
sort para ordenar, inclusive números e tamanhos como "1,5G".
uniq para remover ou contar repetições, e por que ele precisa do sort antes.
cut para recortar colunas e tr para trocar caracteres.
A receita mais famosa do terminal: sort | uniq -c | sort -nr.

Vamos usar o arquivo frutas.txt, que tem uma fruta por linha:

$ cat frutas.txt
banana
maçã
laranja
banana
uva
maçã
banana

wc: contar

wc vem de word count, "contagem de palavras", mas conta mais que isso.

wc: O programa que conta.
frutas.txt: O arquivo a contar.

$ wc frutas.txt
 7  7 47 frutas.txt
 « linhas · palavras · bytes · nome

A resposta tem quatro colunas: 7 linhas, 7 palavras, 47 bytes e o nome do arquivo. Quase sempre você quer só uma delas:

Opção	Conta	Exemplo	Saída
`-l`	Linhas (lines)	`wc -l frutas.txt`	`7 frutas.txt`
`-w`	Palavras (words)	`wc -w frutas.txt`	`7 frutas.txt`
`-c`	Bytes	`wc -c frutas.txt`	`47 frutas.txt`
`-m`	Caracteres	`wc -m frutas.txt`	`43 frutas.txt`

Por que bytes e caracteres dão números diferentes?

Letras com acento ocupam 2 bytes. "maçã" tem 4 caracteres, mas 6 bytes (o ç e o ã valem 2 cada). Para contar letras, use -m.

Só o número, sem o nome

Se o texto chega pela entrada (com < ou por um pipe), o wc não sabe o nome do arquivo e mostra só o número. Isso é ótimo em scripts:

$ wc -l < frutas.txt
7
$ ls Downloads | wc -l
5                                    « 5 itens na pasta Downloads

Missão: descubra quantas linhas tem o arquivo Documentos/acesso.log e quantos itens há dentro da pasta Downloads.

sort: ordenar

sort: O programa que ordena linhas.
frutas.txt: O arquivo. O original não muda: o resultado só aparece na tela.

$ sort frutas.txt
banana
banana
banana
laranja
maçã
maçã
uva

O sort segue a ordem do dicionário em português: ele entende acentos e trata maiúsculas e minúsculas juntas. Para salvar o resultado, use sort frutas.txt > ordenado.txt, ou -o para gravar no próprio arquivo: sort -o frutas.txt frutas.txt.

Uma opção por vez

-r (reverse) inverte a ordem:

$ sort -r frutas.txt
uva
maçã
maçã
laranja
banana
banana
banana

-u (unique) mostra cada linha uma vez só:

$ sort -u frutas.txt
banana
laranja
maçã
uva

-n (numeric) ordena pelo valor do número. Sem ele, o sort compara caractere por caractere, e "10" vem antes de "2" porque "1" vem antes de "2":

$ cat notas-prova.txt
3
10
2
$ sort notas-prova.txt
10                                   « errado para números
2
3
$ sort -n notas-prova.txt
2
3
10

-h (human) entende tamanhos como 12K, 200M, 1,5G. Combina perfeitamente com du -h (veja lsblk, df, du):

$ du -sh Downloads/* | sort -h
48K     Downloads/foto.jpg
2,4M    Downloads/manual.pdf
5,1M    Downloads/musica.mp3
101M    Downloads/fotos-viagem.zip
5,9G    Downloads/ubuntu-26.04-desktop-amd64.iso

Ordenar por uma coluna: `-t` e `-k`

O arquivo /etc/passwd tem uma conta por linha, com campos separados por :. O terceiro campo é o número do usuário (UID). Para ordenar por ele:

sort: O programa.
-t:: O separador de colunas é : (de field separator).
-k3: Ordene pela coluna 3 (de key, "chave").
-n: Como número.
/etc/passwd: O arquivo.

$ sort -t: -k3 -n /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin
ana:x:1000:1000:Ana:/home/ana:/bin/bash

Sem -t, as colunas são separadas por espaços. O seu /etc/passwd real tem bem mais linhas; aqui mostramos só algumas.

uniq: repetições

uniq (de unique, "único") junta linhas repetidas. Mas há um detalhe que pega todo mundo: ele só compara cada linha com a anterior. Repetições separadas não são vistas:

$ uniq frutas.txt
banana
maçã
laranja
banana                               « continua repetida: não estava colada na outra
uva
maçã
banana

Por isso o uniq quase sempre vem depois do sort: ordenado, tudo o que é igual fica junto.

$ sort frutas.txt | uniq
banana
laranja
maçã
uva

Contar, só repetidas, só únicas

Opção	O que mostra	Resultado com as frutas
`-c`	Cada linha com a quantidade na frente (count)	`3 banana`, `1 laranja`, `2 maçã`, `1 uva`
`-d`	Só as que se repetem (duplicated)	`banana`, `maçã`
`-u`	Só as que aparecem uma vez (unique)	`laranja`, `uva`

$ sort frutas.txt | uniq -c
      3 banana
      1 laranja
      2 maçã
      1 uva

A receita do ranking: `sort | uniq -c | sort -nr`

"O que aparece mais vezes?" Esta é provavelmente a combinação mais útil do terminal. Leia da esquerda para a direita, como uma linha de montagem:

sort frutas.txt: Ordena, para que as linhas iguais fiquem juntas.
| uniq -c: Junta as iguais e põe a quantidade na frente.
| sort -nr: Ordena pela quantidade (-n), da maior para a menor (-r).

$ sort frutas.txt | uniq -c | sort -nr
      3 banana                       « campeã
      2 maçã
      1 uva
      1 laranja

Acrescente | head -3 no fim para ver só o "top 3".

Na vida real: quem mais acessou o site?

No acesso.log, o IP é o primeiro pedaço de cada linha. O cut (próxima seção) extrai esse pedaço, e a receita faz o resto:

$ cut -d " " -f 1 Documentos/acesso.log | sort | uniq -c | sort -nr
      3 192.168.0.10
      2 192.168.0.23
      1 192.168.0.57

Missão: monte o ranking de IPs de Documentos/acesso.log e salve o resultado em ranking.txt. Dica: construa aos poucos. Rode só o cut, depois acrescente | sort, depois | uniq -c, e assim por diante, até o > ranking.txt.

cut: recortar colunas

cut ("cortar") pega só um pedaço de cada linha.

cut: O programa.
-d:: O delimitador, o caractere que separa os campos (de delimiter).
-f1: Qual campo pegar (de field). Pode ser -f1,3 ou -f2-4.
/etc/passwd: O arquivo.

$ cut -d: -f1 /etc/passwd
root
daemon
www-data
ana
$ cut -d: -f1,3 /etc/passwd
root:0
daemon:1
www-data:33
ana:1000

Com -c (de characters), ele recorta por posição em vez de campo:

$ cut -c 1-3 frutas.txt
ban
maç
lar
ban
uva
maç
ban

O cut não entende "vários espaços"

Para o cut -d " ", cada espaço separa um campo. Em textos alinhados com vários espaços (como a saída do ls -l ou do ps aux), os campos ficam vazios e o resultado sai errado. Nesses casos, use awk '{print $2}' (veja awk) ou espreme os espaços antes com tr -s " ".

tr: trocar caracteres

tr (de translate, "traduzir") troca um caractere por outro. Ele não lê arquivos pelo nome: o texto precisa chegar pela entrada, com | ou <.

tr: O programa.
a-z: Primeiro conjunto: o que procurar (todas as minúsculas).
A-Z: Segundo conjunto: pelo que trocar, posição por posição (a→A, b→B…).

$ echo "Olá Mundo" | tr a-z A-Z
OLá MUNDO                            « o á não mudou

A faixa a-z só tem as 26 letras sem acento. Letras acentuadas ficam como estão.

Apagar e espremer

Forma	O que faz	Exemplo	Saída
`tr X Y`	Troca X por Y	`echo "a-b-c" \| tr - _`	`a_b_c`
`tr -d X`	Apaga X (delete)	`echo banana \| tr -d a`	`bnn`
`tr -s X`	Espreme X repetido num só (squeeze)	`echo "a b" \| tr -s " "`	`a b`

Um truque útil: ver cada pasta do PATH numa linha, trocando : por quebra de linha (\n):

$ echo $PATH | tr ":" "\n"
/usr/local/sbin
/usr/local/bin
/usr/sbin
/usr/bin
/sbin
/bin
/usr/games
/usr/local/games
/snap/bin

Outros três que valem conhecer

Comando	O que faz	Exemplo
`paste`	Junta arquivos lado a lado, linha com linha	`paste -d, nomes.txt idades.txt`
`rev`	Inverte cada linha, caractere por caractere	`echo Ubuntu \| rev` → `utnubU`
`diff`	Mostra as diferenças entre dois arquivos	`diff -u antes.txt depois.txt`

$ paste -d, nomes.txt idades.txt
ana,25
beto,31
carla,19
$ diff -u lista-antiga.txt lista-nova.txt
--- lista-antiga.txt	2026-10-15 10:20:16.818430700 -0300
+++ lista-nova.txt	2026-10-15 10:25:02.104118300 -0300
@@ -1,3 +1,4 @@
 pão
-leite                               « "-" = só no arquivo antigo
+leite desnatado                     « "+" = só no arquivo novo
 ovos
+café

Formas diferentes de fazer

Remover linhas duplicadas

Forma	Diferença
`sort -u arquivo`	Mais curta. O resultado sai ordenado.
`sort arquivo \| uniq`	Mesmo resultado; permite trocar por `uniq -c`, `-d` ou `-u`.
`awk '!visto[$0]++' arquivo`	Remove duplicadas mantendo a ordem original. Veja awk.

Contar linhas

Forma	Quando
`wc -l arquivo`	O jeito padrão.
`wc -l < arquivo`	Quer só o número, sem o nome (scripts).
`grep -c padrão arquivo`	Quer contar só as linhas que contêm algo.

Pegar uma coluna

Forma	Quando
`cut -d: -f1`	Separador de um caractere só, sempre igual (CSV, `/etc/passwd`).
`awk '{print $1}'`	Colunas separadas por quantidade variável de espaços (`ps`, `ls -l`, `df`).

Missão: salve em unicas.txt só as frutas que aparecem uma única vez em frutas.txt. Dica: sort e depois uniq com a opção certa.

Quando não funciona

O uniq não removeu as repetidas

$ uniq frutas.txt | wc -l
7                                    « as mesmas 7 linhas

O que aconteceu: as linhas iguais não estavam coladas. O uniq só compara com a linha anterior.

Como resolver: ordene antes: sort frutas.txt | uniq, ou simplesmente sort -u frutas.txt.

O sort colocou 10 antes de 2

O que aconteceu: sem -n, os números são comparados como texto. Para tamanhos como 2,4M e 1,5G, a opção é -h.

O cut devolveu a linha inteira

$ cut -d, -f1 /etc/hostname
notebook

O que aconteceu: a linha não tem o delimitador (,). Quando não acha o separador, o cut devolve a linha inteira.

Como resolver: confira qual é o separador real do arquivo (:, ,, tabulação…). Com -s, o cut ignora as linhas sem delimitador.

"cut: uso inválido"

$ cut frutas.txt
cut: uso inválido: espera-se uma das opções --fields (-f), --chars (-c) ou --bytes (-b)

Como resolver: diga o que recortar: -f (campos), -c (caracteres) ou -b (bytes).

"tr: missing operand"

$ echo "teste" | tr a
tr: missing operand after 'a'
Two strings must be given when translating.
Try 'tr --help' for more information.

O que aconteceu: para trocar, o tr precisa de dois conjuntos: o que procurar e pelo que trocar. A mensagem sai em inglês no Ubuntu 26.04.

Como resolver: tr a b para trocar, ou tr -d a para apagar.

"No such file or directory"

$ sort lista.txt
sort: cannot read: lista.txt: No such file or directory
$ uniq -c lista.txt
uniq: Não foi possível abrir lista.txt: No such file or directory
$ wc -l lista.txt
wc: lista.txt: No such file or directory

O que aconteceu: o arquivo não está na pasta atual. Repare que cada comando escreve a mensagem de um jeito, misturando português e inglês: são do coreutils em Rust do Ubuntu 26.04.

Como resolver: confira o nome com ls e use Tab para completar.

Referência de opções

wc

Opção	Descrição
`-l`	Linhas
`-w`	Palavras
`-c`	Bytes
`-m`	Caracteres
`-L`	Tamanho da linha mais longa

sort

Opção	Descrição	Exemplo
`-r`	Ordem inversa	`sort -r`
`-n`	Numérica	`sort -n`
`-h`	Tamanhos legíveis (K, M, G)	`du -sh * \| sort -h`
`-u`	Remove duplicadas	`sort -u`
`-f`	Ignora maiúsculas	`sort -f`
`-t X`	Separador de colunas	`sort -t,`
`-k N`	Ordena pela coluna N	`sort -k2`
`-o arq`	Grava o resultado no arquivo	`sort -o a.txt a.txt`

uniq

Opção	Descrição
`-c`	Conta as repetições
`-d`	Só as linhas repetidas
`-u`	Só as linhas que aparecem uma vez
`-i`	Ignora maiúsculas

cut

Opção	Descrição	Exemplo
`-d X`	Delimitador (padrão: tabulação)	`-d:`
`-f`	Campos: `1`, `1,3`, `2-4`, `3-`	`-f1,3`
`-c`	Caracteres por posição	`-c 1-10`
`-s`	Ignora linhas sem delimitador	`-s`

tr

Forma	Descrição
`tr a-z A-Z`	Troca cada caractere do 1º conjunto pelo correspondente no 2º
`tr "[:lower:]" "[:upper:]"`	Mesma coisa, com classes nomeadas
`tr -d X`	Apaga os caracteres
`tr -s X`	Espreme repetições

Exercícios

1. Só o número de linhas

Complete para contar as linhas de notas.txt:

wc notas.txt

2. O ranking

Complete a receita que mostra o que mais se repete, do maior para o menor:

sort lista.txt | uniq | sort

3. Segundo campo de um CSV

O arquivo clientes.csv tem linhas como ana,ana@email.com,SP. Complete para pegar só os e-mails:

cut -d -f clientes.csv

4. Por que uniq geralmente vem depois de sort?

Porque o uniq só funciona com números. Porque o uniq só junta linhas iguais que estejam uma colada na outra. Porque o sort apaga as repetidas e o uniq as conta. Não há motivo; é só costume.

5. Qual comando transforma "ubuntu" em "UBUNTU"?

echo ubuntu | cut -c A-Z tr a-z A-Z ubuntu echo ubuntu | sort -u echo ubuntu | tr a-z A-Z

Resumo

wc -l conta linhas; com < ou pipe, mostra só o número.
sort ordena; -n para números, -h para tamanhos, -r inverte, -u remove duplicadas.
uniq só vê repetições coladas; use sort antes. -c conta.
Ranking: sort | uniq -c | sort -nr | head.
cut -d X -f N recorta colunas com separador fixo; para espaços variáveis, use awk.
tr troca (a-z A-Z), apaga (-d) e espreme (-s) caracteres, lendo da entrada.