Ubuntu Sintaxe dos Comandos

Quase todo comando do terminal segue a mesma gramática: o nome do programa, depois opções que mudam o comportamento e, por fim, argumentos que dizem sobre o que agir. Entender essa gramática uma vez vale para centenas de comandos.

Você vai aprender

As três partes de um comando e como reconhecer cada uma.
Opções curtas (-a), longas (--all), combinadas (-lah) e com valor (-n 5).
Quando usar aspas simples, aspas duplas ou nenhuma.
Encadear comandos com ;, && e ||, entendendo o código de saída.
Ler as mensagens de "opção inválida" e "falta operando".

A forma geral

comando [opções] [argumentos]

Os colchetes [ ] indicam que a parte é opcional. Você não digita os colchetes. Veja as três partes num comando real:

ls: Comando: o programa a executar. Aqui, o que lista arquivos.
-l: Opção (ou flag): muda o comportamento. -l pede o formato longo, com detalhes.
/etc/apt: Argumento: aquilo sobre o que o comando age. Aqui, a pasta a listar.

$ ls -l /etc/apt
total 24
drwxr-xr-x 2 root root 4096 Oct 13 12:55 apt.conf.d
drwxr-xr-x 2 root root 4096 Apr 22  2026 auth.conf.d
drwxr-xr-x 2 root root 4096 Apr 22  2026 keyrings
drwxr-xr-x 2 root root 4096 Apr 22  2026 preferences.d
drwxr-xr-x 2 root root 4096 Oct 15 09:11 sources.list.d
drwxr-xr-x 2 root root 4096 Apr 22  2026 trusted.gpg.d

Tire a opção e o resultado muda de forma; tire o argumento e muda de lugar. Compare:

$ ls /etc/apt
apt.conf.d  auth.conf.d  keyrings  preferences.d  sources.list.d  trusted.gpg.d
$ ls -l
total 36
drwxr-xr-x 3 ana ana 4096 Oct 12 08:03  Documentos
drwxr-xr-x 2 ana ana 4096 Oct 12 08:03  Downloads
...

Sem -l, só os nomes. Sem /etc/apt, o ls usa a pasta atual.

Opções curtas e longas

Muitas opções existem em duas formas que fazem a mesma coisa:

Forma	Como é	Exemplo	Vantagem
Curta	Um hífen e uma letra	`-a`	Rápida de digitar
Longa	Dois hífens e uma palavra em inglês	`--all`	Fácil de lembrar e de entender em scripts

$ ls -a
.  ..  acesso.log  notas.txt  projetos  relatorio.odt
$ ls --all
.  ..  acesso.log  notas.txt  projetos  relatorio.odt          « o mesmo resultado

Juntando opções curtas

Opções curtas podem dividir um único hífen. A ordem das letras não importa:

ls: O programa.
-lah: Três opções juntas: -l (detalhes), -a (ocultos) e -h (tamanhos legíveis).

$ ls -l -a -h
total 32K
drwxr-xr-x  3 ana ana 4,0K Oct 12 08:03 .
drwxr-x--- 10 ana ana 4,0K Oct 15 08:47 ..
-rw-rw-r--  1 ana ana  389 Oct 15 09:07 acesso.log
-rw-rw-r--  1 ana ana   71 Oct 14 17:40 notas.txt
drwxrwxr-x  3 ana ana 4,0K Oct 12 08:03 projetos
-rw-rw-r--  1 ana ana 8,2K Oct 14 17:40 relatorio.odt
$ ls -lah
total 32K                                       « idêntico ao anterior
...
$ ls -hal
total 32K                                       « idêntico também
...

Opções longas não se juntam

--all--human-readable não funciona. Cada opção longa vai separada: ls --all --human-readable.

Opções que recebem um valor

Algumas opções precisam de um valor logo depois. O head, que mostra o começo de um arquivo, recebe o número de linhas na opção -n:

head: Mostra o começo de um arquivo (veja cat, less, head, tail).
-n: A opção number of lines, "número de linhas".
3: O valor da opção. Pertence ao -n, não é um argumento.
/etc/passwd: O argumento: o arquivo a ler.

$ head -n 3 /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin

Há quatro formas de escrever a mesma coisa:

Forma	Exemplo
Curta com espaço	`head -n 3 /etc/passwd`
Curta grudada	`head -n3 /etc/passwd`
Longa com `=`	`head --lines=3 /etc/passwd`
Longa com espaço	`head --lines 3 /etc/passwd`

Nem todo comando segue as regras à risca

O find usa palavras inteiras com um hífen só (-name, -type). O dd usa chave=valor (if=, of=). Na dúvida, consulte a ajuda do comando (veja Obtendo Ajuda).

A ordem importa?

Na maioria dos comandos do Ubuntu, as opções podem vir antes ou depois dos argumentos:

$ ls -l /etc/hostname
-rw-r--r-- 1 root root 9 Mar 26  2026 /etc/hostname
$ ls /etc/hostname -l
-rw-r--r-- 1 root root 9 Mar 26  2026 /etc/hostname           « funciona igual

O costume, e o mais seguro, é colocar as opções logo depois do comando. Em scripts e em outros sistemas (como o macOS), a ordem pode importar.

Argumentos

Um comando pode receber nenhum, um ou vários argumentos, separados por espaço:

$ ls Documentos/projetos
backup.sh  site
$ ls Documentos/projetos Imagens
Documentos/projetos:
backup.sh  site

Imagens:
ferias.jpg  perfil.png

Com dois argumentos, o ls mostra um título com o nome de cada pasta antes do conteúdo.

Subcomandos

Alguns programas fazem muitas coisas diferentes e usam uma palavra logo depois do nome para escolher a ação. Essa palavra é o subcomando:

apt: O programa de pacotes.
list: O subcomando: a ação "listar".
--installed: Uma opção do subcomando: só os instalados.

Outros exemplos: snap install, systemctl status, git commit, multipass launch.

O separador `--`

Dois hífens sozinhos avisam: "acabaram as opções, o que vem depois é argumento". Serve para arquivos cujo nome começa com hífen, que o comando confundiria com uma opção:

$ rm -arquivo
rm: opção inválida -- “a”
Tente "rm ./-arquivo" para remover o arquivo '-arquivo'.
Tente "rm --help" para mais informações.
$ rm -- -arquivo

O próprio rm sugere a outra forma: rm ./-arquivo, que também funciona porque o nome passa a começar com ..

Maiúsculas e minúsculas

O Linux diferencia maiúsculas de minúsculas em tudo: comandos, opções, arquivos e pastas.

Isto	é diferente disto
`ls`	`LS` (não existe)
`ls -a` (todos, com `.` e `..`)	`ls -A` (todos, sem `.` e `..`)
`Documentos`	`documentos`
`foto.JPG`	`foto.jpg`

$ LS
LS: comando não encontrado
$ ls documentos
ls: não é possível acessar 'documentos': Arquivo ou diretório inexistente

Espaços em nomes

O espaço separa argumentos. Um nome com espaço vira vários argumentos, a não ser que você avise o shell. Veja o erro:

$ ls Área de trabalho
ls: não é possível acessar 'Área': Arquivo ou diretório inexistente
ls: não é possível acessar 'de': Arquivo ou diretório inexistente
ls: não é possível acessar 'trabalho': Arquivo ou diretório inexistente

O ls recebeu três argumentos e procurou três pastas. Há três formas de corrigir:

Forma	Exemplo	Quando usar
Aspas	`ls "Área de trabalho"`	A mais legível. Use sempre em scripts.
Barra invertida	`ls Área\ de\ trabalho`	A `\` "protege" o caractere seguinte.
`Tab`	`ls Ár` + `Tab`	O shell completa e coloca as `\` para você.

Aspas simples, duplas ou nenhuma

As aspas não só juntam palavras com espaço: elas também decidem se o shell vai trocar coisas especiais, como variáveis. Uma variável é um nome que guarda um valor; $USER guarda o nome do usuário.

$ echo Olá $USER
Olá ana                                         « sem aspas: $USER foi trocado
$ echo "Olá $USER"
Olá ana                                         « aspas duplas: $USER foi trocado
$ echo 'Olá $USER'
Olá $USER                                       « aspas simples: nada foi trocado

A diferença entre sem aspas e aspas duplas aparece com espaços repetidos:

$ echo muitos     espaços
muitos espaços                                  « sem aspas: viraram dois argumentos
$ echo "muitos     espaços"
muitos     espaços                              « com aspas: um argumento, espaços mantidos

Escrita	`$VAR` e `$(comando)`	Espaços	Use quando…
sem aspas	trocados	separam argumentos	A palavra é simples, sem espaços.
`"duplas"`	trocados	mantidos	Quer o valor das variáveis e proteger espaços. É o padrão mais seguro.
`'simples'`	mantidos como estão	mantidos	Quer o texto exatamente como digitou.

O mesmo vale para a substituição de comando, $(comando), que roda o comando e coloca o resultado no lugar:

$ echo "Hoje é $(date +%A)"
Hoje é quinta-feira
$ echo 'Hoje é $(date +%A)'
Hoje é $(date +%A)

Missão: crie o arquivo saudacao.txt contendo exatamente o texto Olá $USER, com o cifrão, e não Olá ana. Use echo, aspas e >. Confira com cat saudacao.txt.

Vários comandos numa linha: `;` `&&` `||`

Todo comando devolve um código de saída: 0 quando deu certo e outro número quando deu errado. Você vê o código do último comando com echo $?:

$ ls Documentos > /dev/null
$ echo $?
0                                               « deu certo
$ ls nada
ls: não é possível acessar 'nada': Arquivo ou diretório inexistente
$ echo $?
2                                               « deu errado (o ls usa 2 para isso)

O > /dev/null joga a saída fora, só para a tela ficar limpa (veja Redirecionamento). Os operadores abaixo usam esse código para decidir se o próximo comando roda:

Operador	Significa	O segundo comando roda…
`;`	"depois"	Sempre
`&&`	"e então"	Só se o primeiro deu certo (código 0)
`\|\|`	"ou então"	Só se o primeiro deu errado (código diferente de 0)

mkdir backup: Primeiro comando: cria a pasta.
&&: Só continua se a pasta foi criada.
cp frutas.txt backup/: Segundo comando: copia o arquivo para dentro dela.

$ mkdir backup && cp frutas.txt backup/
$ mkdir backup && cp frutas.txt backup/
mkdir: backup: Arquivo existe                   « falhou, então o cp não rodou
$ mkdir backup || echo "a pasta já existia"
mkdir: backup: Arquivo existe
a pasta já existia                              « rodou porque o mkdir falhou
$ mkdir backup ; echo "isto roda sempre"
mkdir: backup: Arquivo existe
isto roda sempre

Um uso muito comum é o da primeira atualização: sudo apt update && sudo apt upgrade. Se a lista de pacotes não baixar, não adianta tentar instalar.

Missão: numa linha só, crie a pasta projeto e, só se der certo, entre nela. Use &&. Depois confira com pwd.

Comentários: `#`

Tudo o que vem depois de um # (fora de aspas) é ignorado pelo shell. Serve para explicar comandos, principalmente em scripts:

$ echo "oi"   # isto é um comentário
oi

Repare que o # do comentário é diferente do # no fim do prompt do root: um é algo que você digita, o outro é o shell avisando que você é administrador.

Quando não funciona

"argumento inesperado" (opção que não existe)

$ ls -j
erro: argumento inesperado '-j' encontrado

  dica: to pass '-j' as a value, use '-- -j'

Uso: ls [OPÇÃO]... [ARQUIVO]...

Para obter mais informações, use '--help'.

O que aconteceu: o ls não tem a opção -j. No Ubuntu 26.04, comandos como ls e mkdir vêm do projeto em Rust (uutils) e usam esse formato de erro, parte em português e parte em inglês. Comandos do GNU, como o rm, dizem "opção inválida".

Como resolver: confira a opção com ls --help. O erro também diz qual opção é parecida, quando existe uma.

"falta o operando" ou "argumentos obrigatórios"

$ cp frutas.txt
cp: falta o operando arquivo de destino após 'frutas.txt'
Tente "cp --help" para mais informações.
$ mkdir
erro: os seguintes argumentos obrigatórios não foram fornecidos:
  <dirs>...

Usage: mkdir [OPÇÃO]... DIRETÓRIO...

Para obter mais informações, use '--help'.

O que aconteceu: faltou um argumento. O cp precisa de origem e destino; o mkdir precisa do nome da pasta.

Como resolver: leia a linha Uso:: ela mostra o que é obrigatório (o que não está entre colchetes).

Valor inválido numa opção

$ head -n três /etc/passwd
head: invalid number of lines: 'três'

O que aconteceu: o -n espera um número escrito com algarismos.

Como resolver: head -n 3 /etc/passwd.

A variável saiu vazia

$ echo "Arquivo: $ARQUIVO"
Arquivo:

O que aconteceu: a variável ARQUIVO não existe (ou foi escrita com outra combinação de maiúsculas). O shell troca variável inexistente por nada, sem dar erro.

Como resolver: confira o nome. Variáveis do sistema são em maiúsculas: $USER, $HOME, $SHELL.

Exercícios

1. Opção longa

Complete com a forma longa de -a:

2. Opção com valor

Complete para mostrar as 5 primeiras linhas de /etc/passwd:

head /etc/passwd

3. Só se der certo

Complete para entrar na pasta fotos só se o mkdir funcionar:

mkdir fotos cd fotos

4. O que aparece com echo 'Bem-vindo, $USER'?

Bem-vindo, ana Um erro de sintaxe Bem-vindo, $USER Bem-vindo,

5. Em ls -l /tmp, qual parte é o argumento?

ls /tmp -l Não há argumento.

6. Em comando1 || comando2, quando o comando2 roda?

Sempre. Só se o comando1 der certo. Ao mesmo tempo que o comando1. Só se o comando1 der errado.

Resumo

Forma geral: comando [opções] [argumentos]. Opções mudam o comportamento; argumentos dizem sobre o quê.
-a e --all são iguais; curtas se juntam (-lah); opções com valor: -n 3, --lines=3.
Nome com espaço: use aspas ou Tab. Aspas duplas trocam $VAR; simples, não.
; roda sempre, && roda se deu certo, || roda se deu errado. Veja o código com echo $?.
# começa um comentário.