Dominando_o_Terminal_do_Linux

Prévia do material em texto

1
Dominando o 
Terminal do 
Linux
Um Curso Rápido e 
Descomplicado para Iniciantes
Elcio Ferreira
 elcio@visie.com.br 
2
O que é o prompt e como 
funciona 
Se você abrir o terminal em seu Ubuntu agora, deve ver 
algo parecido com isso:
O texto "elcio@skywalker:~$" é o que aparece aqui para 
mim agora. Nesse texto, "elcio" é meu nome de usuário e 
"skywalker" é o nome do meu computador (todos os 
meus computadores e tem nomes de personagens de Star 
Wars.) Em seu computador, é claro, será exibido o seu 
nome de usuário e o nome do seu computador.
3
Depois disso há um sinal de
dois-pontos, seguido da
informação da pasta atual.
Nesse caso, "~", que é um
atalho para a pasta do
usuário.
Em seguida há o caractere
de dólar (ou cifrão),
terminando esse texto
especial. Logo depois o cursor está piscando, esperando 
que você digite um comando.
O nome desse texto especial é "prompt". Ele indica que o 
computador está pronto para receber comandos. É só 
você mandar que ele vai fazer.
Digite, por exemplo, o seguinte comando, que manda o 
terminal navegar para sua área de trabalho:
cd "Área de Trabalho"
Em seguida pressione
ENTER. Com isso,
trocamos de pasta e
estamos agora na área de
trabalho. O prompt deve
4
Pasta do Usuário: cada usuário
do Ubuntu tem sua própria 
pasta para armazenar seus 
arquivos. É aquela pasta que 
no gerenciador de arquivos é 
chamada de "Pasta pessoal". 
Ela geralmente fica dentro da 
pasta "/home". Minha pasta de 
usuário está em "/home/elcio" e
"~" é um atalho muito 
conveniente para ela.
Há um jeito simples de digitar 
comandos e caminhos no 
terminal, que é começar a 
digitar o que você quer e 
pressionar TAB para que seu 
computador os complete.
mudar, desse jeito:
Comando e resposta 
Com isso, você já deve ter percebido o funcionamento 
básico do terminal. Quando o terminal exibe o prompt, 
você deve digitar um comando. Após digitar o comando, 
pressione ENTER e o computador vai executar seu 
comando. 
Durante a execução do comando, até que o prompt 
apareça novamente, você não deve digitar novos 
comandos. Durante a execução o computador pode 
mostrar texto na tela sobre o que o comando está 
5
fazendo. 
Chamamos isso de saída
do comando. Saída é o
texto que um comando
mostra na tela. Ao final
da execução do comando,
o computador mostrará
novamente o prompt,
avisando que está pronto
para receber o próximo comando. Veja esse exemplo de 
terminal com a execução dos comandos date, cd e pwd:
6
A maioria dos comandos é 
executada de modo 
praticamente instantâneo. 
Assim, muitas vezes, ao 
pressionar ENTER você verá 
imediatamente a saída do 
comando e o prompt para 
digitação de um novo comando.
Argumentos de linha de comando 
Para a maioria das tarefas que você pode querer que um 
comando execute será necessário dizer ao computador 
mais do que o nome do comando. Pode ser necessário 
dizer onde e como aquele comando deve ser executado.
Por exemplo, o comando cd espera que você diga para 
que pasta deseja navegar. Assim, para entrar na pasta 
"pasta1", usamos:
cd pasta1
Chamamos essas informações que vão após o comando de
argumentos. Há comandos que podem receber um tipo 
especial de argumento. Por exemplo, o comando ls 
mostra os arquivos de uma pasta e pode receber um 
argumento especial para que mostre também os arquivos 
ocultos, assim:
ls -a
Nós chamamos esses argumentos, que começam com 
hífen, de opções. Assim, a opção -a faz com que o 
comando ls mostre também os arquivos ocultos.
7
Navegando entre pastas e 
operações básicas com 
arquivos
Se você quer de fato usar o terminal, a primeira coisa que 
precisa dominar são as operações básicas com arquivos. 
Elas podem ser feitas com os comandos a seguir.
cd 
Nós já vimos um pouquinho do que o comando cd faz. Ele
navega entre as pastas. Executar o comando cd sem 
argumentos navega para a pasta do usuário. O comando 
cd pode receber como argumento a pasta para a qual 
navegar. Assim:
cd pasta2
Para sair de uma pasta, navegando para a pasta pai, 
usamos dois pontos seguidos, assim:
cd ..
Para entrar em uma pasta dentro de outra, separamos as 
pastas por barra, assim:
cd pastapai/pastafilha
E podemos fazer isso para tantos níveis quantos houver 
8
no caminho da pasta desejada:
cd pastapai/pastafilha/neta/bisneta
Para navegar para uma pasta dentro de sua pasta de 
usuário, não importa em que pasta você esteja, você pode 
começar o caminho com til (~), assim:
cd ~/Documentos/Planilhas
Assim como em qualquer outro comando, sempre que 
você precisar indicar um caminho que contém espaços, 
pode usar aspas para envolver o argumento, assim:
cd "~/Área de Trabalho/Minhas Músicas"
ls
O comando ls lista os arquivos da pasta atual. Você pode 
indicar ao comando que pasta deseja listar, assim:
ls pasta
Você também pode usar a opção -a para exibir todos os 
arquivos, como já mostramos:
ls -a
A opção -l exibe uma listagem detalhada, veja a diferença 
de executar ls com e sem a opção -l na tela a seguir:
9
Nessa tela temos as permissões de cada arquivo, uma 
coluna mostrando quem é o dono do arquivo, outra 
mostrando a que grupo esse arquivo pertence. Temos 
então o tamanho de cada arquivo, seguido da data do 
arquivo.
A opção -h deve ser usada junto com -l, ela faz com que o 
ls exiba o tamanho de cada arquivo em um formato 
amigável para seres humanos. Veja:
10
As opções do comando ls podem ser combinadas. Assim, 
o comando a seguir:
ls -l -h -a
Pode ser escrito assim:
ls -lha
Isso pode ser feito no comando ls e em quase todos os 
comandos que recebem opções de uma única letra. O 
comando ls, assim como a maior parte dos comandos que
mostraremos aqui, tem muito mais opções além das que 
vamos mostrar. Mostraremos só as mais úteis, de uso 
11
mais comum. Se você quiser ler toda a documentação do 
comando ls você pode usar o comando man, assim:
man ls
Mas prepare-se. As documentações são bastante extensas
e a maioria está em inglês.
pwd 
Às vezes estamos dentro de uma pasta no terminal e não 
sabemos exatamente em que pasta estamos. Para isso 
existe o comando pwd, que mostra o caminho completo 
da pasta atual. Veja um exemplo do seu funcionamento:
12
cp 
O comando cp copia arquivos. Você pode copiar um 
arquivo para a mesma pasta, com um novo nome, assim:
cp arquivo.txt novonome.txt
Você também pode copiar um arquivo para dentro de 
uma pasta, desse jeito:
cp arquivo.txt pasta1
Você também pode copiar uma pasta inteira, usando a 
opção -r, assim:
cp -r ~/Documentos/planilhas "~/Área de Trabalho"
mv 
O comando mv move arquivos. Sua sintaxe é bem 
semelhante à do comando cp. Você pode mover um 
arquivo para uma pasta, assim:
mv arquivo.txt pasta1
Ou movê-lo de uma pasta para outra, desse jeito:
mv pasta1/arquivo.txt pasta2
O comando mv também pode ser usado para renomear 
arquivos, desse jeito:
13
mv nomeantigo.txt nomenovo.txt
mkdir 
O comando mkdir cria pastas. Sua sintaxe é bem simples:
mkdir pasta3
Você pode criar de uma única vez uma estrutura de 
pastas dentro de pastas, usando a opção -p, assim:
mkdir -p pastapai/pastafilha/pastaneta
rm 
O comando rm apaga
arquivos. Sua sintaxe
também é bastante
simples, assim:
rm arquivo.txt
Você pode apagar pastas
inteiras, usando a opção 
-r, desse jeito:
rm -r pasta3
14
Cuidado: o terminal confia em
você. Quando você manda ele 
mover, copiar ou apagar, ele 
executa a operação sem 
perguntar nada. Além disso, o 
comando rm apaga 
definitivamente os arquivos, 
não há Lixeira aqui. Por isso, 
todo cuidado é pouco ao usar o 
comando rm.
Entradas e saídas de texto 
O terminal é uma interface baseada em texto. Vamos 
tentar mostrar agora porque isso é bom.
a entrada padrão 
Há uma porção de comandos que esperam que o usuário 
digite alguma coisa. Por exemplo, abra o terminal e digite
o comando python, sem argumentos. Você deve obter 
uma telaassim:
O comando python está sendo executado, e mostrou seu 
próprio prompt:
15
>>>
Isso significa que o comando python está esperando que 
você digite alguma coisa. Em termos técnicos, nós 
dizemos que o comando python está "lendo" (ou 
"ouvindo") o seu teclado. Outra maneira de colocar isso é 
dizer que a entrada padrão para o comando python, nesse
caso, é o teclado. Vamos digitar alguma coisa para ver 
como o comando python se comporta. Digite:
print 2+2
Seguido de ENTER, e você deve ver o comando python 
imprimir para você o resultado da operação, assim:
16
Para encerrar a entrada
padrão, finalizando o
comando python, você
precisa inserir um
caractere de final de
arquivo. Você faz isso
pressionando CTRL+D em
seu teclado. A mesma
coisa vale para
praticamente qualquer comando que leia a entrada 
padrão.
Modificando a entrada padrão 
Vamos agora fazer o comando python ler a entrada 
padrão de outro lugar. Abra o gedit (ou seu editor de 
texto favorito) e crie um arquivo de texto simples cujo 
conteúdo é exatamente o que digitamos para o comando 
python, assim:
17
Python é uma linguagem de 
programação. O comando 
python abre o interpretador 
interativo da linguagem 
Python. Não se preocupe, você 
não precisa aprender Python 
para dominar o terminal, 
embora, se o fizer, não vai se 
arrepender.
Salve com o nome de "soma.txt". Em seguida abra um 
terminal, navegue até a pasta onde você salvou o arquivo 
e execute o seguinte comando:
python < soma.txt
Se você fizer certinho todos os passos, vai ver que o 
comando python imprime o resultado da soma, assim:
O que estamos fazendo aqui é indicando ao comando 
python, através do caractere "<", que ele deve ler a 
entrada padrão do arquivo soma.txt ao invés de ler do 
teclado. Essa técnica é muito, muito útil, como veremos a 
seguir.
18
A saída padrão 
Muitos comandos devolvem informação ao usuário. Um 
exemplo é o comando ls que, como já vimos, exibe na tela 
a listagem da pasta atual. Você se lembra:
A saída do comando ls, assim como a maioria dos 
comandos do terminal, é um texto. 
Esse texto é exibido no terminal, que chamamos aqui de 
"saída padrão". 
Modificando a saída padrão 
Da mesma forma que fizemos com a entrada padrão, é 
19
possível redirecionar a saída padrão de um comando, 
usando o caractere ">", assim:
ls -l > listagem.txt
Assim, indicamos ao comando ls que, ao invés de mostrar
no terminal, ele deve enviar a listagem de pasta para o 
arquivo listagem.txt. Se você seguir corretamente os 
passos acima, vai criar na pasta listada um arquivo assim:
20
Pipes 
Além de fazer com que comandos leiam a entrada padrão 
a partir de arquivos e fazer com que salvem a saída 
padrão em arquivos, é possível conectar comandos. Isso 
significa que um comando lerá a entrada padrão a partir 
da saída padrão de outro comando. Isso é feito através do 
caractere "|", chamado pipe.
Vamos construir um exemplo bem simples disso. Não se 
preocupe se o exemplo parecer muito simples, ou pouco 
útil, é preciso que você entenda bem os conceitos básicos 
para acompanhar o que vem a seguir. Para isso, vamos 
entender primeiro o comando echo. O comando echo 
imprime na tela os argumentos que receber, assim:
21
Assim, você pode fazer com que a saída do comando echo 
seja algo que possa ser lido pelo comando python:
echo print 1+1
E pode concatenar os dois comandos, dessa maneira:
echo print 1+1 | python
Isso vai fazer com que a saída padrão do comando echo 
seja a entrada padrão do comando python. Veja:
Talvez você não enxergue agora o quanto isso pode ser 
útil. Continue lendo, vamos ver isso logo.
22
A saída de erro 
Os comandos em Linux tem uma entrada, a entrada 
padrão, mas duas saídas. A saída padrão, que já vimos, 
onde o comando exibe as coisas que você espera que ele 
exiba, e a saída de erro, onde ele exibe erros e avisa de 
situações inesperadas. Vamos ver um exemplo com o 
comando ls. O comando a seguir salva a listagem da pasta
"pasta existente" no arquivo listagem.txt, veja:
ls "pasta existente" > listagem.txt
Mas o que acontece se você errar ao digitar o nome da 
pasta, mandando o ls exibir a listagem de uma pasta que 
na verdade não existe? Assim, por exemplo:
23
Essa mensagem de erro não foi exibida na saída padrão, 
mas numa outra saída, a saída de erro. 
Você pode perceber isso com facilidade redirecionando a 
saída padrão do comando, assim:
O resultado: como o comando ls não conseguiu listar a 
pasta, o arquivo listagem.txt está vazio. 
E como a mensagem de erro não foi enviada para a saída 
padrão, mas para a saída de erro, ela foi exibida na tela e 
não enviada para o arquivo. 
24
Isso é muito útil. Se a mensagem de erro fosse enviada 
para a saída padrão, você executaria o comando acima e 
acharia que está tudo bem. Só descobriria que houve um 
erro quando precisasse usar o arquivo listagem.txt e 
descobrisse que, ao invés do conteúdo que você esperava, 
ele contém um erro.
Modificando a saída de erro 
Pode haver situações em que, por qualquer motivo, você 
não quer que um comando exiba erros na tela, mas 
prefere salvar esses erros num arquivo para conferir 
depois. 
Você pode fazer isso através dos caracteres "2>". Por 
exemplo:
ls "talvez exista" > listagem.txt 2> erro.txt
Se existir uma pasta chamada "talvez exista", a listagem 
dessa pasta será salva no arquivo listagem.txt. Se a pasta 
não existir, ou houver algum outro erro em obter a 
listagem de arquivos dentro dela, os erros serão salvos no 
arquivo erro.txt.
Concatenando
Os caracteres ">" e "2>" redirecionam a saída padrão e de
erro para arquivos, reescrevendo totalmente os arquivos. 
25
Você pode querer manter o conteúdo do arquivo, 
escrevendo ao final dele.
Isso é realmente muito útil. Você pode querer manter um 
histórico de todas as vezes que um comando foi 
executado, por exemplo.
Para fazer isso, você usa os caracteres ">>" e "2>>". 
Observe o comando a seguir:
ls "talvez exista" >> listagem.txt 2>> erro.txt
Ele faz a mesma coisa que o anterior, com uma diferença:
ele não reescreve os arquivos listagem.txt e erro.txt, ele 
escreve as saídas ao final deles.
26
Comandos para lidar com texto
A interface do terminal é baseada em texto. E isso é 
incrível. Texto é um formato de dados padronizado, 
simples de ler e trabalhar, e universal. 
Por isso, se você deseja dominar o terminal, a primeira 
coisa que você precisa aprender bem é trabalhar com 
texto. Vamos ver agora alguns comandos simples para 
trabalhar com texto. São fáceis de aprender e simples de 
usar, mas quando usados juntos permitem fazer coisas 
muito poderosas.
cat 
O comando cat lê a entrada padrão e despesa o conteúdo 
na saída padrão. Experimente executar o comando cat 
sem argumentos, assim:
cat
O comando cat vai ficar esperando que você digite texto. 
Ele vai então repetir na saída padrão cada linha que você 
digitar. Experimente. Para terminar a entrada padrão, 
encerrando o comando cat, pressione CTRL+D.
Bom, isso não é muito útil, certo?
Mas como você já sabe redirecionar a entrada e saída 
27
padrão, o comando cat pode ser bastante útil. Por 
exemplo, você pode redirecionar a saída do comando cat 
para um arquivo, assim:
cat > texto.txt
E em seguida o comando cat vai esperar que você digite 
texto mas, ao invés de repetir na tela o texto que você 
digitar, ele vai salvá-lo no arquivo texto.txt.
Para ver o conteúdo de um arquivo, você pode 
redirecionar a entrada padrão do comando cat. Por 
exemplo:
cat < texto.txt
Isso vai mostrar na tela o conteúdo do arquivo texto.txt. 
Essa é uma situação tão comum que o comando cat tem 
uma maneira própria para fazer isso. Se você passar um 
arquivo como argumento ao comando cat ele vai ler a 
entrada desse arquivo. Assim, o caractere "<" é 
dispensável:
cat texto.txt
Isso vai funcionar para o comando cat e para a maioria 
dos comandos para lidar com texto.28
grep 
O comando grep funciona de maneira semelhante ao 
comando cat, mas ele espera um argumento. Esse 
argumento é um padrão de busca. Em seguida o grep 
começa a ler a entrada padrão, mas só vai repetir na saída
padrão as linhas que contiverem o padrão de busca. Veja 
o exemplo:
Você pode usar o comando grep para encontrar texto 
dentro de um arquivo. Da mesma forma que com o 
comando cat, você pode redirecionar a entrada padrão ou
pode simplesmente passar um arquivo como argumento 
para o comando grep, assim:
29
Se você passar a opção -n o comando grep vai exibir 
também o número da linha encontrada. Veja:
30
Se você quiser salvar os resultados do comando grep, 
como você já deve ter deduzido, pode redirecionar a saída
do comando grep para um arquivo. Assim:
grep Antônio listagem.txt > encontrados.txt
Isso vai procurar no arquivo listagem.txt todas as linhas 
que contenham o texto "Antônio", salvando os resultados 
num novo arquivo, encontrados.txt
Uma última dica útil do comando grep é que você pode 
usá-lo para inverter a busca, através da opção -v. Assim, 
ele vai exibir apenas as linhas que não contém o termo 
buscado. Veja como exibir o arquivo soneto.txt, excluindo
todas as linhas que tem o texto "ente":
31
less 
Muitas vezes você quer ver o conteúdo de um arquivo, 
mas ele é muito extenso para a sua janela do terminal. 
Uma maneira prática de exibi-lo é através do comando 
less. Execute:
less arquivo.txt
E o comando less vai exibir o início do arquivo e deixar 
você navegar usando as setas do teclado ou as teclas Page 
Up e Page Down. Outra jeito de usar o comando less é 
redirecionando a saída longa de outro comando para ele. 
Por exemplo, para examinar uma listagem de pasta com 
muitos arquivos você pode fazer:
ls -lh | less
tee 
Em outras situações você pode querer salvar a saída de 
um comando em um arquivo e, ao mesmo tempo, 
examiná-la na tela ou redirecioná-la para outro comando.
Por exemplo, digamos que você queira salvar uma longa 
listagem de pasta num arquivo e, em seguida, examinar 
essa listagem. Você poderia executar dois comandos em 
sequência, assim:
ls -lh > listagem.txt
less listagem.txt
32
É possível fazer isso de uma vez só, usando o comando 
tee. O comando tee lê a entrada padrão e faz duas coisas 
com ela. Ao mesmo tempo em que ele a salva num 
arquivo, também a exibe na saída padrão. Assim, se você 
fizer:
ls -lh | tee listagem.txt
A saída do comando ls será salva no arquivo listagem.txt 
e também exibida na tela. Você também pode 
redirecionar a saída padrão do comando tee, 
concatenando através de pipe em outro comando, assim:
ls -lh | tee listagem.txt | less
O comando ls vai listar a pasta e enviar a saída para o 
comando tee, que vai salvar a saída no arquivo 
listagem.txt e, ao mesmo tempo, enviá-la para o comando
less, que vai exibi-la na tela e permitir você navegar pela 
listagem.
Tudo isso num comando só.
33
wc 
O comando wc é um contador de palavras. Veja:
O arquivo soneto.txt tem 20 linhas, 98 palavras e 546 
caracteres. Você também pode redirecionar a saída de 
outro comando para o comando wc. Se você quer contar 
apenas linhas, você pode usar a opção -l do comando wc. 
Por exemplo, para contar quantos arquivos há numa 
pasta, você pode fazer:
ls | wc -l
34
sort 
O comando sort lê a entrada padrão e exibe as linhas em 
ordem na saída padrão. Digamos que você tenha um 
arquivo com a lista de presença de alunos de uma 
determinada turma. Você pode exibir a lista em ordem 
alfabética, assim:
sort chamada.txt
O comando sort pode receber a opção -u, que faz com que
a lista de resultados seja única, isso é, a opção -u remove 
as linhas duplicadas. Além disso, o comando sort pode 
receber a opção -n, que faz ordenação numérica e não 
alfabética. Se você precisa ordenar números, a opção -n é 
o que você precisa.
Digamos que você tenha um diretório de arquivos de 
chamada e você precisa de uma lista de alunos que 
vieram em qualquer uma das aulas. Você pode fazer:
cat *.txt | sort -u
O comando cat vai enviar para o comando sort o 
conteúdo de todos os arquivos txt da pasta. O comando 
sort vai então ordenar os resultados, removendo os 
duplicados.
35
Caracteres coringa
Você deve ter notado, no exemplo acima, o uso do 
caractere "*". Ele é um caractere coringa. Há alguns 
caracteres coringa que você pode usar ao escrever nomes 
de arquivos ou pastas. Os dois mais úteis são "*" e "?".
O caractere coringa "*" significa "qualquer coisa". Veja 
esse comando:
rm *
Isso vai excluir todos os arquivos da pasta atual. Veja esse
outro:
rm a*.txt
Isso vai excluir todos os arquivos cujo nome começa com 
"a" e termina com ".txt". 
O caractere coringa "?" significa "qualquer caractere". 
Veja esse outro comando:
rm lista?.txt
Isso vai apagar os arquivos lista1.txt, lista5.txt, listab.txt, 
mas não o arquivo lista10.txt ou listachamada.txt.
36
Donos e Permissões 
Uma das coisas mais legais no Linux é a maneira como 
ele controla as permissões de arquivos. Cada arquivo ou 
pasta no Linux tem um dono, um grupo e um conjunto de
permissões. Você pode conferir isso com a saída do 
comando ls, veja:
A primeira coisa em vamos nos concentrar é em como ler 
aquela coluna de permissões. Ela tem dez caracteres. O 
primeiro caractere é o tipo de arquivo. 
Um sinal de menos ("-") significa que essa linha da lista é 
apenas um arquivo comum. Um caractere "d" significa 
37
permissões usuário grupo
que essa linha se trata de uma pasta. Para um caractere 
"l" temos um link (uma espécie de atalho). Um caractere 
"p" mostra um arquivo especial, do tipo pipe. Um 
caractere "c" mostra um dispositivo como, por exemplo, 
seu cdrom.
Os outros nove caracteres estão divididos em blocos de 
três.
O primeiro bloco são as permissões para o usuário dono 
do arquivo, o segundo bloco as permissões para o grupo e
o último bloco são as permissões para todos os usuários.
Cada bloco pode ter as permissões:
r - leitura
w - escrita
x - execução
Veja:
 tipo user grupo outros
 - rwx r-x r--
Assim, uma linha de permissões "-rwxrw-r--" significa 
que temos um arquivo comum ("-"), cujo dono pode ler, 
escrever e executar ("rwx"), o grupo pode ler e executar 
("r-x") e os outros usuários podem apenas ler ("r--").
38
chown e chgroup 
Você pode mudar o usuário dono ou o grupo a que um 
arquivo pertence usando os comandos chown e chgroup. 
Para mudar o usuário, faça:
chown joaquim texto.txt
Isso vai fazer com que o arquivo texto.txt pertença ao 
usuário joaquim. Para mudar o grupo, faça:
chgroup financeiro texto.txt
Isso vai fazer com que o arquivo texto.txt pertença ao 
grupo financeiro. Você também pode mudar, num único 
comando, o usuário e grupo de um arquivo, usando o 
comando chown, assim:
chown joaquim:financeiro texto.txt
chmod 
Para mudar as permissões de um arquivo, você pode usar 
o comando chmod. Para dar permissão de execução a um 
arquivo, use:
chmod +x texto.txt
Para dar permissão de leitura e escrita, e remover a 
permissão de execução, use:
39
chmod +rw-x texto.txt
Você pode definir um alvo para o comando chmod. Por 
exemplo, para dar permissão de execução apenas para o 
usuário dono, faça:
chmod u+x texto.txt
Ou para o grupo:
chmod g+x texto.txt
Ou para o grupo e o usuário dono, de uma vez só:
chmod ug+x texto.txt
Os alvos possíveis são:
u - usuário dono
g - grupo
o - os outros usuários
a - todos os alvos (equivalente a "ugo")
40
Trabalhando com listas 
Uma das coisas mais legais para se fazer em seguida é 
aprender a trabalhar com listas de arquivos. Isso torna o 
terminal uma ferramenta poderosíssima de automação.
find 
O comando find serve para encontrar arquivos dentro de 
uma estrutura de pastas. Veja um exemplo da saída do 
comando find:
O comando find pode receber uma série de argumentos. 
O primeiro deles é uma pasta. Assim, comando a seguir 
listatodos os arquivos e pastas dentro da pasta "Pasta 1":
41
find "Pasta 1"
O argumento -type, seguido de uma letra, filtra a lista por
tipo. O comando a seguir lista apenas arquivos:
find -type f
E esse lista apenas pastas:
find -type d
Há uma peculiaridade no comando find. Se você quer 
procurar dentro de uma pasta, a pasta alvo deve sempre 
ser o primeiro argumento. Assim, o comando a seguir não
funciona:
find -type f "Pasta 1"
O correto é:
find "Pasta 1" -type f
O argumento -atime filtra os arquivos pela última vez que
foram acessados. O comando a seguir lista os arquivos 
que foram acessados pela última vez há três dias:
find -atime 3
Você pode usar os sinais de + e - para modificar o 
comportamento do -atime. O comando a seguir mostra os
arquivos acessados a mais de dez dias:
42
find -atime +10
E os acessados a menos de cinco dias:
find -atime -5
O argumento -name procura por arquivos cujo nome casa
com determinado padrão. Por exemplo, para encontrar 
todos os arquivos cujo nome termina com .bak, você pode
fazer:
find -name "*.bak"
find -exec 
Uma das coisas mais legais que você pode fazer com o 
comando find é mandá-lo executar um comando para 
cada arquivo encontrado. Fazemos isso através do 
argumento -exec. O argumento -exec deve ser seguido do 
comando a ser executado. No lugar onde você deseja 
incluir o nome do arquivo, coloque os caracteres {}, e 
termine o comando a ser executado com os caracteres ";".
Assim:
find -name "*.bak" -exec rm {} ";"
O comando acima executa o comando rm para cada 
arquivo encontrado. Assim, digamos que o find encontre 
cinco arquivos com extensão bak na pasta, assim:
43
o.bak
x.bak
pasta/y.bak
pasta/k.bak
pasta2/pasta3/w.bak
O comando find vai executar o comando rm para cada um
dos arquivos acima, assim:
rm o.bak
rm x.bak
rm pasta/y.bak
rm pasta/k.bak
rm pasta2/pasta3/w.bak
xargs
Um outro jeito de fazer com que o comando find execute 
um comando para cada um dos resultados encontrados é 
através do comando xargs. O comando xargs lê a entrada
padrão e transforma em argumentos para um outro 
comando. Você pode usá-lo com o find, por exemplo, 
assim:
find -name "*.bak" | xargs rm
A principal diferença entre usar o comando xargs ou o 
argumento -exec do comando find é que o comando 
xargs vai executar o comando alvo uma única vez.
44
Assim, ao invés de executar:
rm o.bak
rm x.bak
rm pasta/y.bak
rm pasta/k.bak
rm pasta2/pasta3/w.bak
O comando xargs vai executar:
rm o.bak x.bak pasta/y.bak pasta/k.bak pasta2/p...
Se a lista de arquivos encontrados é muito grande, isso 
tem um grande impacto na performance de execução.
for 
Vamos agora aprender a trabalhar com o for, que não é 
um comando, mas uma estrutura de controle. As 
estruturas de controle são um recurso poderosíssimo do 
terminal, e um assunto um pouco mais avançado. Mas 
aprender o básico sobre a estrutura for vai permitir, 
imediatamente, que você faça algumas coisas que 
realmente valem a pena.
A estrutura for serve para executar um ou mais 
comandos. Esses comandos formam um bloco de 
comandos.
Digamos que você queira, por exemplo, para cada arquivo
com a extensão txt numa pasta exibir os detalhes do 
45
arquivo, seguido da contagem de linhas e palavras desse 
mesmo arquivo, você pode fazer:
for arquivo in *.txt; do
 ls -lh $arquivo
 wc $arquivo
done
Esse trecho, que fica entre as palavras chave do e done, é 
o bloco de comandos:
for arquivo in *.txt; do
 ls -lh $arquivo
 wc $arquivo
done
A estrutura for vai, para cada um dos arquivos em *.txt, 
executar o bloco de comandos. No bloco de comandos o 
texto $arquivo será substituído pelo nome do arquivo. O 
nome disso é variável. Assim, essa estrutura for trabalha 
com a variável $arquivo.
46
Automatizando 
A grande vantagem de se usar o terminal em relação à 
interface gráfica é o fato de você poder automatizar 
tarefas. É disso que vamos falar agora.
Criando scripts 
Digamos que você, todos os dias, entre numa pasta, 
apague todos os arquivos de backup (com a extensão 
.bak.) Em seguida você salva a data e hora atual no 
arquivo resultados.txt. Em seguida, conta quantas linhas 
tem o arquivo matriculas.txt e salve o resultado no 
arquivo resultados.txt. Com isso, o arquivo resultados.txt 
tem um relatório dos resultados dia a dia.
Os comandos que você executa todo dia são:
cd ~/curso
find -name "*.bak" | xargs rm
data >> resultados.txt
wc -l matriculas.txt >> resultados.txt
Você pode salvar esses comandos num arquivo. O nome 
que a gente dá a um arquivo com uma sequência de 
comandos é script.
Para criar nosso primeiro script, vamos criar um arquivo 
de texto com os comandos acima, desse jeito:
47
Salve o arquivo como "rotina_diaria". Em seguida, entre 
na pasta onde você salvou o arquivo e dê permissão de 
execução nele, assim:
chmod +x rotina_diaria
Pronto. Agora nosso arquivo é um script, e pode ser 
executado. Todos os dias, para executar a rotina diária, 
entre na pasta onde o script está salvo execute:
./rotina_diaria
E pronto, sua sequência de comandos será executada.
48
Argumentos para scripts 
Agora, digamos que você precise executar essa sequência 
de comandos acima em pastas diferentes. Em algumas 
você precisa executar essa sequência todo dia, em outras, 
só de vez em quando.
Como você vai fazer? Criar um script para cada pasta?
Nós podemos fazer com que nosso script receba 
argumentos. É fácil. Vamos alterar nosso código para 
ficar assim:
cd $1
find -name "*.bak" | xargs rm
data >> resultados.txt
wc -l matriculas.txt >> resultados.txt
Note que trocamos o nome da pasta por $1. Os 
argumentos que você passar para seu script ao executá-lo 
estarão disponíveis dentro do script nas variáveis 
especiais $1, $2, $3, $4 e assim por diante. Alterando 
nosso código como acima, para executar a rotina diária 
para a pasta ~/curso, digite:
./rotina_diaria ~/curso
Para executar para a pasta ~/curso2/matriculas/ digite:
./rotina_diaria ~/curso2/matriculas/
49
Bônus: Exemplos 
Seguem alguns exemplos de comandos úteis que você 
pode usar para automatizar tarefas, além de pacotes que 
você pode instalar em seu Ubuntu para ter novos 
comandos disponíveis.
Pacote Ubuntu: random faux Latin text 
generator 
O pacote libtext-lorem-perl contém um gerador de Lorem
Ipsum para o seu terminal. Eu tinha até feito um script 
para isso antes de saber da existência desse pacote. Para 
instalar: 
sudo apt-get install libtext-lorem-perl 
E para usar: 
lorem 
Para gerar vários parágrafos, use a opção -p informando 
quantos parágrafos você quer: 
lorem -p12 
Pacote Ubuntu: cclive 
O pacote cclive, para download de vídeos do YouTube na 
linha de comando, é uma reescrita do clive mais eficiente,
com menor consumo de memória e menos dependências. 
50
Para instalar: 
sudo apt-get install cclive 
E para usar: 
cclive http://www.youtube.com/watch?v=8fvTxv46ano 
Isso vai baixar o vídeo na pasta atual. Simples e indolor. 
Mas qual a vantagem de usar a linha de comando em 
relação a uma extensão no navegador, onde você não 
precisa digitar comandos? Com a linha de comando é 
possível automatizar as tarefas. Criei um script que 
recebe um nome de usuário do YouTube e baixa os 
últimos 15 vídeos publicados. Chamei o arquivo de 
massclive. Veja o código fonte: 
mkdir -p $1 
lynx --dump http://www.youtube.com/user/$1/feed | \
 grep youtube.com/watch | \ 
 sed -e "s/.* //" | \ 
 sed -e "s/&.*//" | \ 
 sort -u | \ 
 while read url 
 do 
 cclive -c --output-dir $1 $url 
 done 
E você pode usar assim: 
./massclive maninthearenatv 
51
Cowsay: a vaquinha falante do Linux 
Teste aí: 
sudo apt-get install cowsay 
Depois rode: 
cowsay Funciona... 
O cowsay também pode receber texto na entrada padrão: 
date|cowsay 
Isso permite usos razoavelmente criativos: 
lynx --dump http://news.google.com.br \
 | grep "^\[" | grep -v "»" \ 
 | sed -e "s/.*\]//g" | sort -R | head-n 1|cowsay
Você pode colocar seu Ubuntu para te dar uma dica de 
Linux toda vez que você abre o terminal, assim: 
sudo apt-get install fortunes-ubuntu-server 
Depois edite o arquivo ~/.bashrc e inclua no final: 
fortune|cowsay 
E pronto! Cada vez que você abrir um terminal vai 
receber uma dica de Ubuntu. 
52
Fazendo o comando rm enviar arquivos para 
a Lixeira 
Talvez você tenha um pouco de medo de usar o comando 
rm, porque ele exclui definitivamente os arquivos. Não há
“lixeira”, e todos os métodos disponíveis para desfazer a 
deleção, como o ext2undel, não passam de boas tentativas
com uma razoável chance de insucesso. 
Você sabia que pode enviar um arquivo para a lixeira a 
partir do terminal, ao invés de apagá-lo? Para isso, você 
precisa instalar o pacote trash-cli. No Ubuntu, faça: 
sudo apt-get install trash-cli 
Em seguida você pode usar, no lugar do comando rm, o 
comando trash: 
trash arquivo_a_apagar.txt 
Você também pode manipular a lixeira com os comandos 
trash-list, restore-trash e trash-empty. 
Substituindo o comando rm 
E se quiser você evitar usar o comando rm por engano, 
insira no final de seu .bashrc: 
53
alias rm=trash 
Assim, cada vez que você digitar o comando rm, será na 
verdade executado o comando trash. E se você 
deliberadamente quiser excluir um arquivo, sempre 
poderá chamar o comando rm digitando uma 
contrabarra, assim: 
\rm arquivo_a_apagar.txt 
Mas você tem certeza que vai substituir o 
comando rm? 
Na página do trash-cli o autor trata dessa questão. Ele diz
que, embora você possa substituir o comando rm pelo 
trash, você não deveria, porque os argumentos dos dois 
comandos são diferentes. Por exemplo, o comando rm 
exige o argumento -R para remover diretórios, o trash 
não. Então ele sugere que não o faça. 
Mas, se você tem medo de apagar arquivos por engano, 
ele sugere uma outra abordagem. Crie um alias para o 
comando rm em seu .bashrc assim: 
alias rm='echo "Você não quer fazer isso."; false' 
E pronto, você não vai mais executar o comando rm por 
engano, mas, do mesmo modo que no primeiro exemplo, 
sempre poderá executá-lo deliberadamente, começando 
54
com uma contrabarra. 
 
Extraindo o áudio MP3 de um vídeo
Para extrair apenas o áudio, em MP3, de um vídeo, faça: 
ffmpeg -i entrada_video.mp4 -vn saida_audio.mp3 
Simples e rápido. E fácil de automatizar. 
Configurando o locale no Ubuntu 
É um problema comum ao configurar um novo servidor 
com Ubuntu, descobrir que não há um locale válido 
configurado, ou descobrir que o locale padrão não é o que
você desejava. Os sintomas comuns de um sistema sem 
um locale válido são as seguintes mensagens: 
locale: Cannot set LC_CTYPE to default locale: No 
such file or directory 
locale: Cannot set LC_ALL to default locale: No 
such file or directory 
Ou essa outra, bem mais assustadora: 
perl: warning: Setting locale failed. 
perl: warning: Please check that your locale 
settings: 
 LANGUAGE = (unset), 
 LC_ALL = (unset), 
 LC_CTYPE = "pt_BR.UTF-8", 
 LANG = "en_US.UTF-8" 
 are supported and installed on your system. 
55
perl: warning: Falling back to the standard locale 
("C"). 
Os sintomas de um locale diferente do que você gostaria 
são mensagens em algum idioma estranho. 
Como corrigir? Vou explicar aqui, porque esse arquivo 
fica num local muito inusitado, em minha opinião. Não 
está em /etc. Edite, como root, o arquivo: 
/var/lib/locales/supported.d/local 
E coloque os locales que você quer que o sistema suporte. 
A maioria dos usuários brasileiros vai se dar bem com 
esse conteúdo: 
pt_BR ISO-8859-1 
pt_BR.UTF-8 UTF-8 
No meu caso, como faço questão de trabalhar 
exclusivamente com Unicode, eu deixo esse arquivo 
assim: 
pt_BR.UTF-8 UTF-8 
Em seguida rode: 
sudo dpkg-reconfigure locales 
Isso deve resolver o problema. 
56
O Linux também fala 
Há um tempo eu ensinei aqui como fazer o Mac falar. O 
Linux também faz. Instala aí: 
sudo apt-get install espeak 
Daí é só mandar: 
espeak "Luke, I am your father." 
E fala português também: 
espeak -v pt "Luke, eu sou seu pai." 
Com -f arquivo.txt, ele lê o texto de um arquivo. Com -w 
arquivo.wav, ele salva o áudio num arquivo. E pode ser 
comandado via ssh. 
Consegue imaginar utilidades para isso? 
Streamming e download ao mesmo tempo. 
Há um vídeo enoooorme na internet em que você tem 
muito interesse. Você quer baixar e guardar o vídeo, mas 
ao mesmo tempo quer assistí-lo logo. Se você iniciar o 
download e tentar assistir via streamming ao mesmo 
57
tempo, vai consumir o dobro da banda necessária, o 
streamming vai ficar pausando a cada dois segundos e o 
download vai levar muito tempo. O que fazer? Não sei se 
há no Windows algum player que faça download e toque 
ao mesmo tempo. No linux eu resolvo assim, numa janela
de terminal: 
wget -c http://servidor.com.br/video.wmv 
Em outra: 
tail -c 10000000000 -f video.wmv |mplayer - 
Explicando, o primeiro comando, o wget, faz o download 
do vídeo. O parâmetro -c faz com que, se o arquivo 
existir, o download seja continuado de onde parou. Isso é 
útil porque se o download for interrompido, depois você 
pode continuá-lo com o mesmo comando. 
O segundo é uma concatenação de comandos Unix. A 
parte “tail -c 10000000000 -f tableless.wmv” é um 
comando e “mplayer -” é outro. O primeiro usa o tail, que 
imprime o final de um arquivo. Experimente, por 
exemplo: 
tail /var/log/syslog 
Você vai ver as últimas linhas do log do sistema. O 
parâmetro -c recebe um número, o número de bytes a 
58
imprimir a partir do fim do arquivo. Você pode colocar 
qualquer número que seja maior que o arquivo inteiro. O 
parâmetro -f faz o tail ficar esperando por conteúdo novo 
no fim do arquivo. Experimente rodar num terminal, por 
exemplo: 
tail -f /var/log/syslog 
Você vai ver as últimas linhas do syslog e o tail vai ficar 
esperando por conteúdo novo. Abra programas, execute 
ações no sistema, pare e inicie daemons e você vai ver as 
novas linhas aparecendo ali. A mesma coisa acontece 
como vídeo. O tail vai despejar na tela todo o conteúdo do
arquivo, e vai ficar esperando. A medida que o wget baixa 
mais dados, o tail vai imprimindo o que chega. 
O pipe depois do tail envia os dados do vídeo para o 
comando mplayer, um player de vídeo muito poderoso e 
flexível.
59
Fique por dentro:
http://visie.com.br/treinamento/ 
Aprenda Javascript:
http://js.visie.com.br/ 
60
http://js.visie.com.br/
http://visie.com.br/treinamento/
	O que é o prompt e como funciona
	Comando e resposta
	Argumentos de linha de comando
	Navegando entre pastas e operações básicas com arquivos
	cd
	ls
	pwd
	cp
	mv
	mkdir
	rm
	Entradas e saídas de texto
	a entrada padrão
	Modificando a entrada padrão
	A saída padrão
	Modificando a saída padrão
	Pipes
	A saída de erro
	Modificando a saída de erro
	Concatenando
	Comandos para lidar com texto
	cat
	grep
	less
	tee
	wc
	sort
	Caracteres coringa
	Donos e Permissões
	chown e chgroup
	chmod
	Trabalhando com listas
	find
	find -exec
	xargs
	for
	Automatizando
	Criando scripts
	Argumentos para scripts
	Bônus: Exemplos
	Pacote Ubuntu: random faux Latin text generator
	Pacote Ubuntu: cclive
	Cowsay: a vaquinha falante do Linux
	Fazendo o comando rm enviar arquivos para a Lixeira
	Extraindo o áudio MP3 de um vídeo
	Configurando o locale no Ubuntu
	O Linux também fala
	Streamming e download ao mesmo tempo.
	Fique por dentro:
	http://visie.com.br/treinamento/
	Aprenda Javascript:
	http://js.visie.com.br/