Introdução Ao Linux

Introdução
à linha de comando
do Linux
Uma abordagem prática
1a edição
David da Silva Pires

Centro de Bioinformática e Biologia Computacional
Instituto Butantan
RASCUNHO
São Paulo
8 de fevereiro de 2024
RASCUNHO
Sumário
prefácio v
1 introdução 1
2 comandos básicos 3
§2.1 Sistema de arquivos, 3. §2.2 Histórico de comandos , 13. §2.3 Diretórios do sis-
tema operacional, 14. §2.4 Permissões de acesso, 14. §2.5 Estatística de arquivos e
diretórios, 16. §2.6 Caracteres especiais, 17. §2.7 Teclas de atalho, 18.
3 redirecionamento 21
§3.1 Redirecionamento da saída padrão , 21. §3.2 Operador de anexação, 21. §3.3 Redi-
recionamento da entrada padrão, 22. §3.4 Redirecionamento da saída de erro padrão, 22.
§3.5 Redirecionamentos simultâneos, 23. §3.6 Combinando ferramentas de linha de comando, 23.
§3.7 Executando um comando após o outro: o conceito de pipeline, 24.
RASCUNHO
processos
§4.1 Executando processos em segundo plano, 27. §4.2 Sendo legal com outros usuários:
o comando nice, 28. §4.3 Medindo o tempo de execução: o comando
/usr/bin/time, 29. §4.4 Execução condicional de um processo, 31. §4.5 Listando
processos, 31. §4.6 Matando processos, 32. §4.7 Parando processos, 32. §4.8 Substi-
27
tuição de comandos , 33. §4.9 Subshells , 33. §4.10 Deixando seus processos rodando...
mesmo sem estar logado!, 33. §4.11 Agendando seus comandos para serem executados
em outro momento, 34.
5 tratamento de arquivos 35
§5.1 Visualizando o conteúdo de arquivos, 35. §5.2 Contando linhas, palavras e caracteres, 36.
§5.3 Gerando sequências numéricas, 36. §5.4 Sobre cabeças e rabos, 37. §5.5 Ordenação
de linhas, 38. §5.6 Trabalhando com colunas, 38. §5.7 Busca de expressões: o comando
grep, 40. §5.8 Substituição de expressões, 40. §5.9 Busca por arquivos, 41. §5.10 Com-
pactação e descompactação de arquivos, 42.
6 informações do sistema 45
§6.1 Uso de apelidos para comandos, 46. §6.2 Carga do sistema, 46. §6.3 Memória, 46.
§6.4 Processos, 47.
iii
7 acesso remoto 49
§7.1 ssh, 49. §7.2 scp, 49. §7.3 sshfs, 49.
8 scripts em bash 51
§8.1 Os cinco tipos de ferramentas de linha de comando, 51. §8.2 O shabang, 51. §8.3
Variáveis de ambiente, 51. §8.4 A estrutura de repetição for, 52.
9 outros tópicos 53
§9.1 Buscando ajuda, 53. §9.2 Configuração do Bash, 55. §9.3 Jogos em modo texto, 55.
RASCUNHO
Prefácio
Esta apostila é voltada para o ensino da linha de comando do Linux a partir de concei-
tos iniciais básicos, ideal para quem nunca teve contato com o assunto. O conteúdo
é mostrado de forma prática, por meio de exemplos completos que podem ser execu-
tados diretamente em um console. Os comandos usados, por serem essenciais, estão
presentes em praticamente qualquer distribuição Linux, geralmente não exigindo a
instalação de pacotes adicionais além dos que já vêm instalados por padrão. O shell
usado será o bash (Bourne again shell), que geralmente é o shell padrão na maioria
das distribuições Linux.
RASCUNHO
v
RASCUNHO
Introdução
1
sistema operacional é o componente de software que faz a interface básica entre
O os programas de usuário e o hardware. Os principais sistemas operacionais em
uso atualmente são o Linux, o Windows e o MAC/OS. O Linux foi desenvolvido pelo
finlandês Linus Torvalds e seu código-fonte pode ser usado, modificado e distribuído
livremente.
Existem diversos tipos de distribuições Linux, algumas mais amigáveis (voltadas
para usuários domésticos), outras mais estáveis (voltadas para servidores) e ainda ou-
tras voltadas para áreas específicas, como educação, design gráfico, bioinformática ou
que facilitem a transição de um usuário que está acostumado com o Windows. Uma
das distribuições mais conhecidas é o Ubuntu, a qual também é usada para gerar ou-
tras distribuições, como o Kubuntu, que contém o mesmo conjunto de programas do
Ubuntu mas que usa o KDE para gerenciamento de janelas em vez do Gnome, que
RASCUNHO
vem por padrão.
O Linux é o componente central (núcleo, kernel) do sistema operacional. A parte
com que o usuário geralmente lida mais diretamente são os programas, tais como
editores de texto, planilhas eletrônicas, navegadores da internet, tocadores de música
e jogos. Todos esses programas usam o sistema operacional como um intermediário
para ter acesso ao hardware e executar suas funções.
O programa que serve de interface entre o usuário e o Linux é chamado de shell
(concha, em inglês). É como se o shell escondesse a complexidade do kernel por
meio de abstrações que possam facilmente ser gerenciadas pelos usuários, assim como
uma concha esconde uma pérola em seu interior. O shell pode se mostrar como uma
interface gráfica (graphical user interface, GUI), que usa imagens, ícones e janelas, ou
como uma interface de linha de comando (command line interface, CLI), que fornece
apenas o modo texto para interação, a chamada tela preta.
A interface gráfica é uma maneira confortável e agradável de se usar um computa-
dor com Linux. Porém, o verdadeiro poder deste sistema operacional está na linha de
comando. Há um ditado que diz “interfaces gráficas tornam tarefas fáceis mais fáceis
ainda enquanto que interfaces por linha de comando fazem com que tarefas difíceis se
tornem possíveis de serem realizadas”.
Não obstante, quando se tem acesso a um servidor Linux, a chance de que a inter-
face de linha de comando seja a única disponível é enorme. Essa é uma realidade para
a área de Bioinformática, por exemplo, para a qual saber operar um computador com
Linux instalado passa a ser um pré-requisito.
1
2 INTRODUÇÃO À LINHA DE COMANDO DO LINUX
Exercícios
① Escreva o nome de todos os sistemas operacionais de que você já ouviu falar.
② Escreva o nome de todas as linguagens de programação de que você já ouviu falar.
③ Por que você quer aprender sobre a linha de comando do Linux?

④ Você
( ) já trabalha ou trabalhou com bioinformática.
( ) nunca trabalhou com bioinformática mas pretende em um futuro próximo.
( ) nunca trabalhou com bioinformática nem pretende em um futuro próximo.
⑤ Você gostaria de ter o Linux instalado em sua máquina (seja laptop ou desktop,
seja em conjunto com o Windows ou sozinho)?
( ) Sim ( ) Não
RASCUNHO
Comandos básicos
2
sinal de cifrão ($) que aparece na linha em que digitamos os comandos é cha-
O mado de prompt. Ele sinaliza que o sistema está “pronto” para receber coman-
dos. Geralmente, a linha do prompt contém outros dados, tais como o nome do usuá-
rio, o nome da máquina, o diretório atual de trabalho e, às vezes, o horário atual. Pelo
fato de tais dados serem irrelevantes para o aprendizado dos comandos e poderem
variar, adotamos a exibição apenas do cifrão seguido do sinal de maior.
$>
Todo usuário é identificado no sistema através de seu nome de usuário (username
ou login name). Para certificar-se de seu nome de usuário use o comando whoami
(do inglês who am I?, “quem sou eu?"). Entenda por usar um comando digitá-lo no
prompt da linha de comando e finalizar com <ENTER>. O comando whoami devolverá
o nome do usuário que está executando o comando.
RASCUNHO
$> whoami
pires
A qualquer momento em que você achar necessário “limpar” a tela, faça uso do
comando clear.
$> clear
Se por algum motivo seu terminal ficar confuso e estranho, todo bagunçado, mos-
trando caracteres de símbolos em vez das letras que você digita, ou até não mostrando
nada do que é digitado, reinicialize-o com o comando reset.
$> reset
Esse comportamento do terminal pode ocorrer após se ter tentado visualizar um ar-
quivo binário, por exemplo.
2.1 Sistema de arquivos

O sistema operacional (SO) emprega diversas abstrações para que possamos fazer um
uso eficiente do hardware que compõe um sistema computacional. Um exemplo é
o sistema de arquivos: em vez de lidarmos com bits, bytes, setores e trilhas, lidamos
com arquivos e diretórios que, por possuírem semelhança com documentos e materiais
usados para armazenamento, são muito mais fáceis de lidar.
3
2.1.1 Diretórios: criação, listagem, navegação, renomeação e re-

moção
Para saber o diretório em que você se encontra, use o comando pwd (abreviatura de
print working directory, “imprima o diretório de trabalho”, ou de present working
directory, “diretório de trabalho atual”). Ele devolverá o seu atual local de trabalho.
$> pwd
/home/pires
Geralmente, após o login, o diretório padrão é o chamado “home” do próprio usuário.

Uma atividade básica e que frequentemente é exigida é a listagem dos arquivos e
subdiretórios que estão no diretório atual. Isso pode ser obtido a partir do comando ls
(do inglês list, “listar”):
$> ls
Para armazenar todo o conteúdo de um determinado assunto em um mesmo lugar

deve-se criar um diretório (também chamado de pasta). Para tanto, use o comando
mkdir (do inglês make directory, “criar diretório”). Para criar um diretório chamado
“curso”, você deve digitar:
$> mkdir curso
O comando mkdir exige a passagem de pelo menos uma palavra, que é o nome do
diretório a ser criado. Não se pode usá-lo sozinho como fizemos com os comandos
whoami e pwd. Dizemos que o comando mkdir exige a passagem de um parâmetro e
RASCUNHO
que sua sintaxe é:
mkdir <DIRETÓRIO>
À palavra que é passada como parâmetro para um comando chamamos de argumento.

No exemplo acima, o argumento que é passado como valor do parâmetro “DIRETÓ-
RIO” é “curso”.
Já para fazer com que o seu diretório atual de trabalho passe a ser o diretório
recém-criado, você deve “mudar” para ele (ou “entrar” nele) por meio do comando cd
(do inglês change directory, “mudar de diretório”).
$> cd curso
Pode-se ver que após a execução deste comando o diretório de trabalho atual passa
a ser /home/pires/curso. Note como cada diretório é separado por um caractere
‘/’.
$> pwd
/home/pires/curso
É bastante comum a necessidade de alterar para o diretório recém-criado.
$> mkdir culinária

$> cd culinária
CAPÍTULO 2. COMANDOS BÁSICOS 5
No lugar de executar cada comando em uma linha, é possível executar os dois coman-
dos em uma mesma linha. Para tanto, usa-se o ponto-e-vírgula (“;”) para separar os
comandos.
$> mkdir vegana; cd vegana
Nomes de arquivos e diretórios no Linux são considerados diferentes quando escri-

tos com letras maiúsculas ou minúsculas. O termo em inglês é case sensitive. Assim,
“curso” , “Curso” , “CURSO”. Esse é o motivo do erro obtido a seguir:
$> ls
curso
$> cd Curso
bash: cd: Curso: No such file or directory
Além dos nomes de arquivos e diretórios, os comandos também são sensíveis a

letras maiúsculas e minúsculas. Desta forma, cd é diferente de CD. Caso se tente
executar este último comando, um erro será obtido como resposta.
$> CD /home/pires
CD: command not found
Dizemos que o diretório /home/pires contém e é o diretório pai do diretório

/home/pires/curso. Para voltarmos para o diretório pai podemos usar o apelido
que todo diretório pai ganha: “..”.
$> cd ..
/home/pires
RASCUNHO
É possível criar mais de um diretório com um único comando mkdir. Para isso,
basta passar os nomes dos diretórios como argumentos adicionais.
$> cd curso
$> mkdir linux libras arabe
Às vezes uma linha de comando possui tantos caracteres que fica muito comprida
para caber em apenas uma linha. Geralmente os terminais lidam bem com isso, mo-
vendo o ponto de inserção para a linha seguinte e voltando para a primeira coluna.
No entanto, você mesmo pode escrever um comando que continua por várias linhas,
bastando para isso terminar cada linha a ser continuada com o caractere \, chamado
de barra invertida.
$> mkdir literatura

$> cd literatura
$> mkdir brasileira portuguesa inglesa norte-americana \
> espanhola peruana cubana francesa italiana alema grega russa
O sinal “maior que” (>) é chamado de prompt secundário e indica que a linha é uma
continuação da anterior. É importante garantir que o sinal ‘\’ não esteja incluído em
uma string, certificando-se de “fechar” todas as aspas, simples ou duplas (' ou ") para
só então usar o símbolo ‘\’.
$ echo "Esta frase tem" \

> "30 caracteres." |
> wc -c
Para remover um diretório vazio, use o comando rmdir, passando o nome do
diretório vazio como argumento.
$> rmdir linux
Digamos que queiramos criar um diretório dentro de outro ainda inexistente. Nós
poderíamos fazer isso em dois passos:
$> mkdir linux
$> cd linux
$> mkdir capitulo1
$> cd capitulo1
$> mkdir exercicio
ou, de forma mais concisa:
$> mkdir linux
$> mkdir linux/capitulo1
$> mkdir linux/capitulo1/exercicio
É possível criar diretórios aninhados usando apenas um comando mkdir: para isso,
precisaremos fazer uso de uma opção do comando. As opções permitem execuções
alternativas do comando e são muito úteis em diversos casos. No exemplo dado, o uso
da opção -p, do inglês parent, indica ao comando mkdir que, caso os diretórios-pai
ainda não existam, eles também devem ser criados.
RASCUNHO
$> mkdir -p linux/capitulo1/exercicio
Note que se tentássemos executar este comando sem a opção -p obteríamos um erro,
pois o diretório-pai “capitulo1” ainda não existe.
$> rmdir linux/capitulo1/exercicio
$> rmdir linux/capitulo1
$> mkdir linux/capitulo1/exercicio
mkdir: cannot create directory ‘linux/capitulo1/exercicio’: No
such file or directory
As opções de um comando, também chamadas de “flags” ou “switches”, podem
ter duas formas:
curta Geralmente indicada pelo uso de apenas um hífen, usa somente um caractere
para indicar a opção usada. Exemplo: a opção -p do comando mkdir vista
anteriormente.
longa Geralmente indicada pelo uso de dois hífens, descreve com palavras inteiras a
opção usada. Exemplo: a opção --parents do comando mkdir, que é a versão
longa da opção -p.
É comum usarmos duas ou mais opções ao mesmo tempo para um comando. A
opção --verbose (ou -v) do comando mkdir, por exemplo, ativa o modo verboso,
que envia mensagens ao terminal a cada ação executada.
$> mkdir --parents --verbose linux/capitulo2/exercicio

$> mkdir -p -v linux/capitulo3/exercicio
A versão longa das opções é útil para deixar claro o significado de cada uma.
Porém, quando já se conhece bem o significado de cada opção, torna-se enfadonho (e
até parece perda de tempo) ter de digitar tudo. Assim, é comum fazer um uso mais
constante das variações curtas das opções. Seguindo na linha de “quanto menos se
digitar melhor”, diversos comandos permitem o agrupamento de versões curtas das
opções, de modo a se usar apenas um hífen.
$> mkdir -pv linux/capitulo4/exercicio
Outros comandos, como é o caso de ps e tar, que veremos mais adiante, dispen-
sam inclusive o uso do hífen, aceitando opções em suas versões curtas diretamente.
Se quisermos visualizar a árvore de diretórios recém-criada, um mero ls não será
útil.
$> ls
linux
O comando ls lista, por padrão, apenas o diretório corrente. Para obter uma visão
geral de todo o conteúdo de um galho da árvore de diretórios, como os diretórios que
foram criados dentro do diretório linux, sem que seja necessário ficar navegando pelo
sistema de arquivos, podemos usar a opção -R (ou sua forma longa, --recursive)
do comando ls, de modo a listar os diretórios recursivamente.
$> ls -R
De forma equivalente, porém com uma visualização mais interessante, podemos usar
RASCUNHO
o comando tree.
$> tree
Caso você queira visualizar apenas os diretórios, suprimindo os arquivos, use a opção
-d do comando tree.
$> tree -d
Para remover um diretório não-vazio juntamente com todo o conteúdo existente

nele, use o comando rm com as opções -rf. A opção -r indica recursividade, para
que a remoção ocorra a cada subdiretório que é encontrado. A opção -f indica re-
moção forçada, sem interatividade com perguntas confirmando se realmente se deseja
remover cada arquivo.
$> rm -rf <DIRETORIO>
Embora o comando rm -rf seja uma forma rápida e fácil de remover toda a árvore
de um sistema de arquivos recursivamente, trata-se de um comando extremamente
perigoso e, portanto, deve ser usado com o máximo de cautela, principalmente quando
o usuário for root.
Como iremos armazenar o conteúdo deste curso no diretório recém-criado, seja-
mos mais específicos: vamos chamá-lo de introducaoAoLinux. Para renomear um
diretório usamos o comando mv:
$> mv linux introducaoAoLinux
Caso se esteja em um nível bem profundo de subdiretórios como, por exemplo:

/home/usuario/projeto/genoma/versao5/indice/mapeador/saida/
pode-se perguntar como fazer para voltar para o diretório home. Uma vez que o dire-
tório em que se está é um subdiretório em um mesmo ramo da árvore que o diretório
home, pode-se usar várias vezes o comando cd .. até chegar lá.
$> cd ..
$> cd ..
$> cd ..
$> cd ..
$> cd ..
$> cd ..
Também pode-se fazer uso do caminho relativo, que é aquele que começa a partir do
diretório de trabalho atual.
$> cd ../../../../../..
Outra forma é ir diretamente ao diretório home passando o caminho absoluto como
argumento para o comando cd. Caminho absoluto é aquele que começa com o símbolo
"/"e segue a árvore de diretórios, ramo a ramo, desde o início até atingir o diretório
ou arquivo desejado. O diretório “/” também é conhecido como diretório raiz pois,
fazendo analogia com uma árvore, é como se ele fosse a raiz da árvore. A partir
do diretório raiz saem todos os “galhos” que permitem chegar a qualquer diretório
RASCUNHO
do sistema de arquivos. Em nosso caso, para mudar para o diretório home usando o
caminho absoluto, deve-se digitar:
$> cd /home/usuario
Um modo mais rápido é fazer uso do símbolo ~, que é um sinônimo para seu home:
$> cd ~
Um modo mais rápido ainda é usar o comando cd sem argumento algum:
$> cd
Se, no entanto, o diretório de interesse não for o do próprio usuário que executa o
comando, então ainda assim se pode fazer uso de um outro apelido, que consiste no
sinal til (~) seguido do nome do usuário no sistema (username).
$> cd ~pires
Em outras palavras, o comando acima é equivalente ao comando cd /home/pires no
caso de o diretório home do usuário pires corresponder ao caminho /home/pires.
Importante observar que o comando abaixo não altera o diretório atual para o home
do usuário pires, mas sim para o subdiretório pires dentro do diretório do usuário
que está executando o comando:
$> cd ~/pires
Note que múltiplas barras consecutivas são permitidas, porém todas são reduzidas
a apenas uma. Desta forma, ////home//usuario é visto como /home/usuario
pelo sistema.
Vamos considerar agora que o diretório atual de trabalho é tão profundo quanto
/home/usuario/projeto/genoma/versao5/indice/mapeador/saida/
e que nos movemos para o diretório home com o comando cd. Após terminar a tarefa
que deveria ser feita no home, como fazermos para voltar para o diretório anterior?
Nós podemos usar o caminho absoluto:
$> cd /home/usuario/projeto/genoma/versao5/indice/mapeador/saida/
ou o caminho relativo:
$> cd projeto/genoma/versao5/indice/mapeador/saida/
ou simplesmente passar o argumento - como parâmetro para o comando cd:
$> cd -
O comando cd - sempre irá alterar seu diretório de trabalho para o que você estava
anteriormente.
Certamente a estratégia acima é útil quando, no decorrer de seu trabalho, você sai
de um diretório para outro completamente diferente e deseja voltar para o diretório
inicial. Mas, e no caso de se ter de resolver vários problemas em diversos diferentes
diretórios e depois ter de ir voltando um a um para continuar resolvendo os problemas?
Aqui, o comando cd - não será muito útil, não é mesmo? É quando, então, podemos
fazer uso de dois comandos que não são muito conhecidos: pushd e popd.
RASCUNHO
$>
$>
$>
$>
cd ~/Downloads
pushd /tmp
pushd ~/private/project/bioinformatics
popd
$> popd
A cada vez que se usa o comando pushd, o diretório atual é colocado em uma pilha
(ficando, portanto, no fundo dela) e é alterado para o diretório dado como argumento
para o comando. A pilha cresce de tamanho a cada execução do pushd. Na sequência,
cada execução do comando popd remove o último diretório inserido na pilha com o
comando pushd e altera o diretório corrente para este mesmo diretório desempilhado.
Assim, conseguimos manter um histórico dos diretórios visitados e fazer o caminho
reverso sem muito esforço.
2.1.2 Arquivos: criação, cópia, movimentação, renomeação e re-

moção
Deixemos um pouco de lado os diretórios e passemos a trabalhar com arquivos. O
arquivo mais simples que você pode criar é um arquivo vazio. Há diversas formas de
se fazer isso. Talvez a mais simples seja com o comando touch:
$> touch arquivo

O arquivo de nome “arquivo” será criado no seu atual diretório de trabalho.

Para mover um arquivo de um diretório a outro use o comando mv, o mesmo que
já usamos para renomear um diretório.
$> mv arquivo cursoLinux
Você não necessariamente precisa estar no mesmo diretório de origem do arquivo a
ser movido.
$> mv cursoLinux/arquivo libras
Para renomear arquivos também usamos o comando mv, da mesma forma que para
a renomeação de diretórios.
$> mv libras/arquivo libras/notasDeAula.txt
Note que a renomeação de arquivo acima introduz uma extensão: .txt. Em ou-
tros sistemas operacionais, a extensão é necessária para que o sistema saiba qual é o
tipo do arquivo (texto, neste caso). Já para o Linux, o uso de extensões é completa-
mente irrelevante: o sistema descobre por si só qual é o tipo do arquivo, independente
de seu nome. O uso de extensões passa a ser, portanto, apenas uma ajuda para iden-
tificação por parte do próprio usuário. Sendo assim, você pode ter um arquivo com
o nome “programa.exe” que seja simplesmente um texto, bem como outro chamado
“documento.txt” que seja executável. No entanto, é boa prática tentar manter nomes e
extensões condizentes com o conteúdo e tipo do arquivo, respectivamente.
Para copiar um arquivo usamos o comando cp.
$> cp libras/notasDeAula.txt ~/Documentos/estudarParaAProva.txt
RASCUNHO
Se o item a ser copiado é um diretório, devemos fazer uso da opção -r, de “re-
cursivo”, de modo que o comando faça a cópia de todos os arquivos do diretório e de
todos os subdiretórios (e seus respectivos arquivos) recursivamente.
$> cp -r libras /media/pires/hdBackup/
Para remover um arquivo também usamos o comando rm, porém não é necessária
a opção -r (de recursivo).
$> rm libras/notasDeAula.txt
Caso o seu sistema esteja configurado de modo que sempre é exigida uma confir-
mação da remoção, você pode “forçosamente” remover um arquivo usando a opção
-f.
$> rm -f arquivo
Se, pelo contrário, você quiser sempre ter de confirmar que realmente quer remover
um arquivo, use a opção -i, de modo a executar o comando rm interativamente.
$> rm -i arquivo
No caso de se querer sobrescrever o conteúdo de um arquivo e logo depois removê-
lo, pode-se usar o comando shred.
$> shred arquivo
Remover arquivos é perigoso por si só. Tradicionalmente, o terminal do Linux

não possui uma lixeira tal como se encontra normalmente em um desktop, de modo
que usuários de terminal adquirem o hábito ruim de remover dados permanentemente
quando eles acreditam que não precisarão mais deles. No entanto, não há um comando
para recuperar arquivos removidos, tornando esse hábito problemático caso você aci-
dentalmente remova um diretório contendo dados importantes. Contudo, é muito mais
seguro usar um comando que envie o arquivo para uma lixeira antes de removê-lo para
sempre. É isso o que o comando trash faz:
$> trash arquivo
2.1.3 Arquivos e diretórios ocultos

Arquivos e diretórios ocultos são aqueles que não aparecem em uma listagem normal,
ou seja, como saída de um comando ls. Para que um arquivo ou diretório seja oculto,
basta que seu nome inicie com o caráter ‘.’.
$> ls
arquivo.txt segredo.txt
$> mv segredo.txt .segredo.txt
$> ls
arquivo.txt
Ainda assim, arquivos e diretórios ocultos também precisam ser gerenciados (edi-
tados, movidos, criados, apagados, renomeados, ter suas permissões de acesso alte-
radas), de modo que também é preciso visualizá-los em listagens de diretórios. Para
tanto, use a opção -a do comando ls.
RASCUNHO
$> ls -a
arquivo.txt .segredo.txt
2.1.4 Listagem em ordem alfanumérica e numérica

A listagem de diretórios e arquivos fornecida pelo comando ls é, por padrão, em
ordem alfanumérica. Veja o exemplo:
$> touch arquivo1 file1 arquivo2 file2
$> ls
A ordem alfanumérica dos arquivos criados é:
arquivo1 arquivo2 file1 file2
Pois, na comparação caractere a caractere, a letra a antecede a letra f e o número 1
antecede o número 2. Essa parece ser uma ordenação natural, mas nem sempre o é.
Veja por exemplo o caso a seguir:
$> touch file1 file2 file3 file4 file5 file6 file7 file8 file9 file10
$> ls
Como se pode observar, a ordem alfanumérica dos nomes dos arquivos criados é:
file1 file10 file2 file3 file4 file5 file6 file7 file8 file9
No entanto, para casos assim, geralmente é esperada uma ordenação baseada na sequên-
cia de números, evidenciando uma provável anotação de números de versão dos ar-
quivos:
file1 file2 file3 file4 file5 file6 file7 file8 file9 file10
Essa é a chamada ordem numérica, que pode ser obtida com a opção -v do comando
ls.
$> ls -v
2.1.5 Espaços em nomes de arquivos e diretórios

Definitivamente não se deve usar espaços em nomes de diretórios e arquivos. A esta
altura você já deve ter percebido a importância do caractere ‘ ’ (espaço) na linha
de comando: ele serve para separar comandos de opções e argumentos, inclusive os
argumentos entre si quando há mais de um. Desta forma, se o nome de um arquivo ou
diretório contém espaço, você deve “escapá-lo”, evidenciando que o nome do arquivo
ou diretório continua e que o espaço faz parte dele. O caractere usado para escapar o
espaço é \.
$> cd Minhas\ Imagens
2.1.6 Link simbólico

É possível obter uma cópia de um arquivo (ou de um diretório) que não faça uso de
espaço adicional e de modo que se ocorre uma modificação em um dos dois arquivos
RASCUNHO
(ou do conteúdo dos diretórios), ela também ocorre na outra cópia. Para tanto, você
precisa criar um link simbólico com o comando ln e a opção -s.
$> pwd
/home/pires/Documents
$> ln -s /project/pires/tese.tex
Após o comando acima, o diretório /home/pires/Documents conterá um link sim-

bólico para o arquivo /project/pires/tese.tex. É importante notar que esse
link simbólico não é um arquivo regular. Dizemos que ele “aponta” para o arquivo
tese.tex. Links simbólicos não ocupam espaço extra no sistema de arquivos (a
menos que seus nomes sejam muito longos, quando ocuparão apenas alguns bytes a
mais). O arquivo tese.tex pode possuir o tamanho que for, o link simbólico que
aponta para ele sempre terá apenas alguns bytes. Um link que aponta para um objeto
inexistente é chamado de “link quebrado”. O nome do link simbólico é, por padrão,
o mesmo do arquivo (ou diretório) para o qual ele aponta. Para alterar o nome de um
link simbólico no momento de sua criação é preciso passar um segundo argumento
para o comando ln.
$> ln -s /project/pires/tese.tex doutorado.tex
Assim, o link doutorado.tex criado no diretório corrente apontará para o arquivo

/project/pires/tese.tex.
Com relação a links simbólicos é possível usar o comando pwd de duas formas:
opção -L: mostra sua localização atual levando em conta todos os links simbólicos
(mnemônico: logical).
opção -P: mostra sua localização atual resolvendo todos os links simbólicos (mnemô-
nico: physical).
Observe, como exemplo, a sequência de comandos abaixo:
$> mkdir dir

$> ln -s dir linkToDir
$> cd linkToDir
$> pwd
$> pwd -L
$> pwd -P
Nota-se que o padrão, executado quando se chama o comando pwd sem opção alguma,
é a opção -L.
2.2 Histórico de comandos

Todos os comandos que você executa ficam armazenados em um arquivo. Para ter
acesso a esta lista, digite history.
$> history
Essa lista de comandos permite que relembremos tudo o que foi feito e em que or-
RASCUNHO
dem foi feito. Um uso muito prático dela é a reexecução de comandos ou o uso
de um comando anterior como exemplo para o comando que se quer executar. Para
tanto, usa-se as teclas de direção “seta para cima” (↑) e “seta para baixo” (↓) para
navegar no histórico de comandos e acessar rapidamente os mais recentemente usa-
dos. Por exemplo, para entrar no diretório recém renomeado, em vez de digitar o
comando “cd cursoLinux” desde o início, podemos “resgatar” o comando já usado
“cd curso” e completar digitando apenas “Linux”.
Este é um exemplo bem inocente e que dificilmente seria usado de verdade. No
entanto, é bem comum fazer uso de comandos bastante complexos e compridos repe-
tidas vezes com apenas algumas poucas modificações. Nestes momentos, navegar no
histórico de comandos proporciona uma eficiência enorme no trabalho, seja na eco-
nomia de tempo para digitação, seja na ajuda à memória para lembrar de todos os
detalhes do comando.
Para repetir o último comando usado, tecle !!.
Se logo após executar um comando você quiser executar um outro comando muito
parecido, use o caractere ^ para fazer substituição no histórico de comandos.
$> ls *.png
$> ^png^jpeg^
$> ls -l *.jpeg
$> ^ -l^
Às vezes queremos fazer várias coisas com um mesmo arquivo. Se for o caso de
o nome do arquivo sempre ter que aparecer como último argumento dos comandos,
você pode fazer uso do comando !$.
$> cat arquivo.txt
$> vim !$
2.3 Diretórios do sistema operacional

2.3.1 O diretório /home
É neste diretório que ficam armazenados os arquivos de todos os usuários mortais do
sistema. Entenda como usuário mortal aquele que não possui acesso root, ou seja, não
é um administrador. ;-)
Como exemplo, suponha que um sistema possua dois usuários, João e Maria, com
logins joao e maria, respectivamente. Cada um deles possuirá um subdiretório no
diretório /home:
$> ls /home
joao maria
Todos os arquivos pessoais, configurações e diretórios da usuária Maria ficarão arma-
zenados no diretório /home/maria. Dizemos que esse é o diretório home da usuária
Maria.
2.3.2 O diretório / (barra)
RASCUNHO
O diretório / é conhecido como diretório raiz (root em inglês) e ele é a base de toda
a árvore de diretórios do sistema de arquivos do Linux. Por base podemos entender
que é a partir dele que todos os outros diretórios e subdiretórios são criados. O dire-
tório home, por exemplo, é criado diretamente no diretório raiz e é por isso que nos
referimos a ele como /home.
2.3.3 Outros diretórios do sistema

O diretório /tmp armazena arquivos temporários, geralmente criados por programas
que estão rodando. O usuário também pode criar arquivos no /tmp, porém deve aten-
tar ao fato de que, na maioria dos sistemas, o conteúdo deste diretório é totalmente
removido após uma reinicialização do computador.
2.4 Permissões de acesso

Para visualizar as permissões de acesso de um arquivo ou de um diretório, a pode-se
usar a opção -l do comando ls, a qual irá imprimir uma listagem longa do conteúdo
do diretório.
$> ls -l
total 4
-rw-rw---- 1 pires pires 0 dez 9 11:45 arquivo
drwxrwx--- 2 pires pires 4096 dez 9 11:45 diretorio

lrwxrwxrwx 1 pires pires 7 dez 9 11:50 link -> arquivo
Note os dez primeiros caracteres que aparecem na linha de cada item (arquivo, di-
retório ou link ) listado. Eles informam o tipo de permissão de acesso para cada um
desses itens em relação ao usuário dono do item, ao grupo ao qual o item pertence e
aos outros usuários do sistema. O primeiro caractere indica o tipo do arquivo:
- arquivo comum;
d diretório;
l link.
Os nove caracteres seguintes são divididos em três conjuntos com três caracteres
cada um: usuário, grupo e outros. Na ordem, esses caracteres possuem o seguinte
significado:
r permissão de leitura;
w permissão de escrita;
x permissão de execução.
No caso de não haver permissão para alguma dessas ações, o caractere exibido é
‘-’.
No exemplo mostrado acima, o usuário e o grupo possuem permissão de leitura e
gravação no arquivo e de leitura, gravação e execução no diretório. Os outros usuários
do sistema não possuem nenhum tipo de acesso a esses dois itens.
2.4.1 Alteração das permissões de acesso
RASCUNHO
As permissões de acesso podem ser alteradas para as três categorias já citadas.
u usuário dono do item;

g grupo de usuários;
o outros usuários.
Também é possível usar um atalho para representar todas as três categorias ao mesmo
tempo.
a todos (do inglês all).
O comando usado para alterar permissões de acesso é o chmod (do inglês change
mode). Sua sintaxe é:
$> chmod <ALTERAÇÃO> <ARQUIVO>
A alteração envolve um conjunto de caracteres que representa as categorias para as

quais as permissões serão alteradas, o símbolo ’+’ (para inclusão da permissão) ou
o símbolo ’-’ (para exclusão da permissão) e mais um conjunto de caracteres que
representa as permissões a sofrerem alteração. Digamos, por exemplo, que queremos
dar permissão de leitura e gravação para o grupo a um arquivo chamado teste.txt.
O comando seria o seguinte:
$> chmod g+rw teste.txt

2.4.2 Alteração das permissões de acesso usando código binário

É possível usar o comando chmod de uma forma mais enxuta (mas nem por isso mais
simples) usando códigos binários para representar ao mesmo tempo as categorias para
as quais as permissões serão alteradas e as respectivas permissões. Para tanto, usa-se
a seguinte codificação binária para os acessos:
r 4
w 2
x 1
Deve-se construir um número formado por 3 dígitos. O dígito mais à esquerda refere-
se ao usuário, o do meio ao grupo e o mais à direita aos outros usuários. Cada um
desses dígitos pode variar de 0 a 7, correspondendo à soma das potências de 2 que
representam a codificação binária dos acessos. Sendo assim, temos que
$> chmod 640 teste.txt
fornece permissão de leitura e escrita para o usuário dono do arquivo, permissão de
leitura para o grupo e nenhuma permissão aos outros.
2.5 Estatística de arquivos e diretórios

O comando stat permite a consulta a alguma estatística de arquivos e diretórios.
$> stat sequencia.txt
Por hora, iremos observar apenas alguns campos do resultado do comando. Na pri-
meira linha temos o nome do arquivo. A segunda linha nos informa que se trata de um
RASCUNHO
arquivo regular com 8 bytes de tamanho. A quarta linha informa que o usuário dono
do arquivo e o grupo ao qual ele pertence possuem permissões de leitura e escrita,
enquanto os outros usuários possuem apenas permissão de leitura. Nas últimas linhas
encontramos três datas e horários:
Access Quando o arquivo foi acessado (lido) pela última vez.
Modify Quando o conteúdo do arquivo foi modificado (escrito) pela última vez.
Change Quando os metadados do arquivo foram alterados pela última vez, como por
exemplo as permissões de acesso.
Se nós “tocarmos” o arquivo com o comando touch, todas essas três datas e horá-
rios serão atualizados para a data e horário do momento de execução do touch. Esse
é um outro uso que se faz desse comando, além de criar arquivos vazios.
Caso seja de seu intuito alterar a data e o horário de um arquivo para outra data e
horário que não sejam os atuais, use a opção -t do comando touch, passando como
argumentos o mês, o dia do mês e o horário no seguinte formato: MMDDHHmm. Por
exemplo, para alterar a data e o horário de um arquivo para 20 de março às 16h00min,
faça:
$> touch -t 03201600 arquivo
Note que o comando stat aplicado a um diretório nos fornece informações se-
melhantes, valendo a pena notar que o número de blocos ocupados é 0 e que o tipo é
directory em vez de regular file.
2.6 Caracteres especiais

Há alguns caracteres que são especiais na linha de comando. Tais caracteres são in-
terpretados pelo shell antes de o comando ser executado. Tomemos como exemplo o
caractere ‘*’. Tão logo se tecla <ENTER> para executar um comando, o shell expan-
dirá todos os símbolos ‘*’ que encontrar no comando para zero ou mais caracteres
que correspondam a arquivos e diretórios presentes no diretório atual ou no diretório
indicado. Desta forma, o comando ls *.txt irá listar todos os arquivos do diretó-
rio corrente que possuem a extensão “.txt”. Em outras palavras, o comando ls não
recebe o símbolo ‘*’, a expansão ocorre antes de sua chamada. Para usar o símbolo
‘*’ como um caractere que faz parte do nome de um arquivo ou diretório, devemos
“escapá-lo” com o símbolo ‘\’.
$> ls estrela\*star.txt
A presença do caractere de escape ‘\’ impede o shell de interpretar o símbolo esca-
pado, passando-o de forma literal para o comando em questão, de modo que o nome
do arquivo a ser listado é estrela*star.txt. A barra invertida é usada inclusive
para escapar a si mesma, caso seja usada para nomear algum item.
O símbolo ? também é usado para a substituição de caracteres, porém cada ? é
substituído por apenas um caractere. Digamos, por exemplo, que se tenha um diretório
que contém 101 arquivos, nomeados como uma sequência numérica desde 0.txt
até 100.txt. Caso você queira listar apenas os arquivos que possuam o dígito das
dezenas igual a 8, basta fazer:
$> ls 8?.txt
Caso você queira ser mais específico e listar os caracteres que podem casar com o
RASCUNHO
padrão, coloque-os entre colchetes.
$> ls Carolin[ae].txt
Também é possível usar uma sintaxe que expresse o complemento de um conjunto,
ou seja, todos os elementos, exceto aqueles que possuem um determinado padrão. Para
isso, basta “negar” o conjunto de caracteres iniciando a sequência com um ponto de
exclamação (!).
$> ls Carolin[!ae].txt
É possível executar mais de um comando em uma mesma linha. Para tanto, é
necessário separar os comandos com ponto-e-vírgula:
$> echo -n "Olá! O SO que estou usando é:"; uname
O comando echo imprime na tela a mensagem que é passada como argumento. Por
padrão, após a impressão o prompt é exibido na linha seguinte. Como neste caso
queremos que o nome do SO seja exibido na mesma linha, usamos a opção -n.
É possível fazer comentários na linha de comando, os quais podem facilitar o
entendimento do que está sendo feito. Os comentários são completamente ignorados
pelo Bash e são iniciados com o caractere #.
$> # Criando uma cópia de segurança.
$> cp tese.tex ~/backup # A pasta backup armazena cópias de \
arquivos importantes.
2.7 Teclas de atalho

2.7.1 Completamento com a tecla <TAB>
Este atalho permite a economia de um tempo considerável durante a digitação. Caso
se queira, por exemplo, remover um arquivo com um nome muito longo, pode-se
digitar os primeiros caracteres do nome do arquivo e pressionar a tecla <TAB> para
que o nome seja completado automaticamente.
$> ls
curto.c
tamanhoMediano.txt
arquivoComUmNomeExtremamenteLongo.comUmaExtensaoTambemMuitoLonga
$> rm a<TAB>
Caso haja mais de uma possibilidade de completamento, o pressionamento da tecla

<TAB> irá completar o nome somente na parte que é comum a todas as entradas que
possuem o mesmo começo já digitado. O pressionamento da tecla <TAB> por uma
segunda vez irá produzir uma listagem de todas as possibilidades.
2.7.2 Navegação com o cursor

<Ctrl + u> Limpa tudo desde o início da linha de comando até a posição do cursor.
<Ctrl + w> Remove os caracteres do ponto de inserção até o início da palavra
anterior.
<Ctrl + k> Remove todos os caracteres do ponto de inserção até o fim da linha.
<Ctrl + a> Move o ponto de inserção para o início da linha.
RASCUNHO
<Ctrl + e> Move o ponto de inserção para o fim da linha.
<Ctrl + b> Volta o ponto de inserção uma letra.
<Ctrl + f> Avança o ponto de inserção uma letra.
<Ctrl + _> Volta a última ação realizada (= <Ctrl + -).
2.7.3 Rolamento de tela

Dependendo do comando que se executa, o conteúdo do resultado exibido em tela é
tão grande que acaba não cabendo, fazendo com que seja necessário “rolar” a tela
para cima de modo a ver o conteúdo que foi oculto por falta de espaço. Caso haja
um mouse instalado em seu sistema, você pode usar o botão do meio, rolando-o para
cima. Na ausência do mouse, ou para evitar o deslocamento da mão, você pode usar
teclas de atalho tanto para rolar para cima quanto para rolar para baixo.
<Shift + ↑> Rola a tela para cima, linha a linha.

<Shift + ↓> Rola a tela para baixo, linha a linha.
<Shift + Page Up> Rola meia tela para cima.
<Shift + Page Down> Rola meia tela para baixo.
2.7.4 Outros atalhos interessantes

<Ctrl + l> Limpa a tela, equivalente ao comando clear.
<Ctrl + r> Busca reversa.
Exercícios
① Crie um diretório para dados temporários chamado tmp. Dentro dele, crie os di-
retórios teste1 e teste2. Renomeie o diretório tmp para temp. Na sequência,
remova-o.
② Escreva os comandos necessários para executar as seguintes ações (use somente os

prompts fornecidos em cada item):
• Mova para o seu diretório home.

$>
• Crie um diretório chamado work.
$>
• Renomeie o diretório work para project.
$>
• Digamos que você vá trabalhar com uma ferramenta chamada FastQC. Você
organizará os dados da seguinte forma:
input dados de entrada.
output dados resultantes do processamento dos dados de entrada, podendo ser
resultados intermediários ou finais.
log relatórios de execução da ferramenta FastQC, informando códigos de erro
se for o caso.
RASCUNHO
script programas que você vai escrever para preparar os dados para a execução
do FastQC.
final resultado final.
Crie, dentro do diretório project, o diretório fastqc e, dentro dele, os diretó-
rios input, output, log, script e final.
$>
$>
③ Escreva os comandos necessários para executar as seguintes ações (use somente os

prompts fornecidos em cada item):
• Crie um arquivo vazio chamado passeio.txt.

$>
• Renomeie o arquivo de modo a deixá-lo oculto.
$>
• Mova o arquivo para o diretório /tmp e, no mesmo comando, renomeie-o para
nao use espacos.txt.
$>
• Faça um link simbólico para este arquivo no próprio diretório /tmp, chamando-
o de naoUseEspacos.txt.
$>
④ Um usuário executou a seguinte sequência de comandos:
$> history
$> !1990
$> ^fastq^fasta
Explique o que o usuário quis fazer.

⑤ Em que tipo de situação você usaria o diretório /tmp? Qual o cuidado que você
deve tomar ao usá-lo?
⑥ Um usuário, cujo login é egoista, deseja impedir qualquer tipo de acesso de

qualquer outro usuário (que não seja ele mesmo) ao seu diretório home. Quais
comandos ele deve executar? Dê as duas versões possíveis: usando caracteres
mnemônicos e usando a representação em potências de 2.
$>
$>
⑦ Dê o comando para listar os arquivos cujos nomes possuem a extensão txt, o pre-
fixo user- e o restante é composto por mais um caráter (exemplos: user-a.txt,
user-9.txt).
$>
RASCUNHO
Redirecionamento
3
3.1 Redirecionamento da saída padrão
Para escrever uma mensagem no próprio terminal pode-se usar o comando echo.
$> echo "Seja a mudança que você quer ver no mundo."
Se em vez de imprimir a mensagem na tela preferirmos armazená-la em um arquivo,

podemos fazer uso do símbolo ‘>’, que é usado para fazer um redirecionamento da
saída padrão.
$> echo "Seja a mudança que você quer ver no mundo." > \
mensagem.txt
RASCUNHO
Por padrão, a saída de todo comando é enviada para a tela. Usamos, portanto, o co-
mando de redirecionamento da saída padrão, que consiste no símbolo ‘>’, para fazer
com que tudo o que seria enviado para a tela seja enviado para um arquivo. É impor-
tante notar que, caso o arquivo não exista, ele será criado. Porém, caso o arquivo já
exista, ele será sobrescrito, de modo que é muito importante ser bastante cauteloso em
seu uso.
3.2 Operador de anexação

No caso de se desejar acrescentar texto ao final do arquivo, podemos usar o símbolo
“>>”.
$> echo " (Dalai Lama)" >> \

mensagem.txt
Confirme que o segundo texto foi anexado ao primeiro com o comando cat.
$> cat mensagem.txt

Seja a mudança que você quer ver no mundo.
(Dalai Lama)
21
3.3 Redirecionamento da entrada padrão

Vejamos agora como fazer o redirecionamento da entrada padrão. Alguns comandos,
como o comando cat acima, permitem que o nome de um arquivo de entrada seja es-
pecificado. Outros, porém, não possuem esta facilidade e necessitam que sua entrada
seja fornecida como entrada padrão. É o caso, por exemplo, do programa cowsay.
$> cat mensagem.txt | cowsay
No exemplo acima, o programa cowsay recebe sua entrada via pipeline como sendo
a saída do programa cat. A desvantagem dessa sintaxe é que se faz necessário um
processo a mais (o do comando cat) para que a execução do programa cowsay seja
concluída. Com o uso do redirecionamento da entrada padrão, dado pelo símbolo ‘<’,
nós eliminamos a necessidade deste processo adicional.
$> cowsay < mensagem.txt
Há ainda uma sintaxe alternativa muito interessante.
$> < mensagem.txt cowsay
A vantagem dessa sintaxe mostra-se quando temos que executar vários comandos em
sequência com uma mesma entrada, bastando alterar a parte final da linha de comando.
$> < mensagem.txt cat

$> < mensagem.txt wc
Compare essa estratégia com a que usa o histórico de comandos com o !$, apresentada
RASCUNHO
na Seção 2.2.
$> cat mensagem.txt

$> wc !$
3.4 Redirecionamento da saída de erro padrão

Além da saída padrão, todo processo também possui a saída de erro padrão, para onde
são enviadas as mensagens de erro. Quando nenhum redirecionamento é feito, tanto a
saída padrão quanto a saída de erro padrão são enviadas para a tela. Quando fazemos
o redirecionamento apenas da saída padrão para um arquivo, as mensagens de erro
continuam sendo enviadas para a tela. É uma boa prática armazenar as mensagens de
erro em um arquivo (separado das mensagens enviadas para a saída padrão), de modo
que você possa analisá-las posteriormente.
O redirecionamento da saída de erro padrão é feito pelo operador 2>.
$> ls /root 2> /tmp/ls.err
Note que também neste caso, se o arquivo para o qual a saída de erro padrão está
sendo redirecionada já existe, ele será sobrescrito. Para evitar a sobreposição e anexar
os erros a um arquivo já existente, deve-se usar o operador de anexação 2>>.
$> ls /root 2>> /tmp/ls.err

CAPÍTULO 3. REDIRECIONAMENTO 23
3.5 Redirecionamentos simultâneos

Para armazenar tanto a saída padrão quanto a saída de erro padrão em arquivos, deve-
mos fazer dois redirecionamentos em um mesmo comando.
$> ls ~ /root 2> /tmp/ls.err > /tmp/ls.out
A ordem aqui não é importante, de modo que também podemos redirecionar primei-
ramente a saída padrão e depois a saída de erro padrão.
$> ls ~ /root > /tmp/ls.out 2> /tmp/ls.err
3.5.1 Descritores de arquivo

O número 2 no operador 2> refere-se ao chamado descritor de arquivo da saída de
erro padrão. O número do descritor de arquivo da saída padrão é 1 e, como vimos na
Seção 3.1, pode ser omitido, usando-se apenas >, embora há quem prefira explicitá-lo.
$> ls ~ /root 2> /tmp/ls.err 1> /tmp/ls.out
Assim, é possível fazer com que tanto a saída de erro padrão quanto a saída padrão
sejam gravados em um mesmo arquivo.
$> ls ~ /root > /tmp/ls.out 2>&1
No comando acima nós primeiro fizemos o redirecionamento da saída de erro padrão

para o arquivo /tmp/ls.out e, na sequência, redirecionamos a saída de erro padrão
para o mesmo local para o qual está sendo enviada a saída padrão. Note que, neste
caso, a ordem dos redirecionamentos é importante.
RASCUNHO
$> ls ~ /root 2>&1 > /tmp/ls.out # Erros são enviados para a tela.
O comando acima primeiramente redireciona a saída de erro padrão para o mesmo

local da saída padrão, que é a tela (e que também já era o local da saída de erro antes do
redirecionamento). Só depois, então, é que ocorre o redirecionamento da saída padrão
para um arquivo. Como o redirecionamento do descritor de arquivo 2 ocorreu antes
do redirecionamento do descritor de arquivo 1, os erros continuarão sendo enviados
para a tela.
3.6 Combinando ferramentas de linha de comando

Há um conjunto de normas relativas ao desenvolvimento de programas que é conhe-
cido como filosofia Unix. As ferramentas que aderem a essa filosofia possuem algumas
características em comum, sendo as principais delas serem projetadas para fazer ape-
nas uma coisa e fazê-la muito bem. Diversas das ferramentas já estudadas são assim:
o wc pode conta linhas, o seq pode gerar uma sequência de números, o sort pode
ordenar linhas, o grep pode filtrar linhas, etc.
O verdadeiro poder da linha de comando vem de sua capacidade de combinar to-
das essas pequenas ferramentas simples, permitindo a criação de soluções poderosas.
A combinação das ferramentas ocorre por meio de uma estratégia muito simples: a
saída de uma é a entrada de outra. Uma das maneiras que podemos fazer isso é por
meio da gravação e leitura de arquivos. Uma vez que o resultado esperado é apenas
o final, tais arquivos contêm resultados intermediários e são usados apenas para a co-
municação entre ferramentas diferentes podendo, portanto, ser descartados tão logo a
comunicação tenha sido concluída.
Uma outra maneira de fazer com que a saída de uma ferramenta seja a entrada de
outra é através do que chamamos pipe. Podemos traduzir pipe para cano e a analogia
é perfeita: os dados de saída de uma ferramenta entram por um lado do cano e, ao
sair pelo outro lado do cano, servem de entrada para outra ferramenta. O conjunto
das duas ferramentas e do pipe é chamado de pipeline. Há casos, no entanto, que a
saída da segunda ferramenta ainda não é o resultado final, necessitando ser processada
novamente por uma terceira ferramenta. A extensão do pipeline é natural: basta fazer
com que a saída da segunda ferramenta seja a entrada da terceira. Tal arranjo pode se
repetir muitas vezes, até que o pipeline esteja completo.
Conectar duas ferramentas através de um pipe é muito simples: basta inserir o
símbolo |.
3.7 Executando um comando após o outro: o conceito

de pipeline
O símbolo “|”, chamado de pipe faz com que a saída de um programa possa ser usada
como entrada de outro. Sendo assim, para visualizar, por exemplo, as primeiras linhas
do manual do comando head você pode fazer:
$> man head | head
RASCUNHO
$> seq 100 > sequencia.txt
$> head sequencia.txt
$> seq 100 | head
$> fortune | cowsay
Outro exemplo interessante de uso de um pipeline é o comando tee. Ele possui

esse nome justamente por que sua função é parecida com a de um cano no formato da
letra maiúscula ’T’: o dado entra por um lado (a parte de baixo do ’T’) e é replicado em
duas saídas (os dois cantos da parte superior do ’T’). Uma das saídas é a própria tela,
como se você não tivesse usado nem o pipeline nem o comando tee. A outra saída é
gravada no arquivo cujo nome é passado como argumento para o comando tee.
$> echo "Pipeline com tee." | tee /tmp/tee.txt

$> cat /tmp/tee.txt
Lembra-se de que quando temos uma linha de comando muito comprida é possível
quebrá-la em várias linhas de comando usando o caractere \ ao final da linha? Pois o
caractere | também pode ser usado para o mesmo propósito:
$ seq 10 |
> cowsay |
> lolcat
CAPÍTULO 3. REDIRECIONAMENTO 25
Exercícios
① Use o comando echo para escrever o nome de uma comida que você gosta em um
arquivo chamado receitasAProcurar.txt.
$>
② Usando o comando cat, anexe ao arquivo receitasAProcurar.txt o nome

de uma sobremesa que você gosta. Indique o fim da entrada com a sequência
<Ctrl + d>.
$>
③ Redirecione a entrada padrão do comando cowsay para que seja impresso o con-
teúdo do arquivo receitasAProcurar.txt no balão de diálogo.
$>
④ Tente apagar todo o conteúdo do diretório /root mostrando os nomes dos arquivos
que estão sendo apagados. Para poder checar posteriormente o nome de todos os
arquivos e diretórios efetivamente apagados e os eventuais erros que ocorrerem,
redirecione a saída padrão e a saída de erro padrão para arquivos diferentes. Qual
dos arquivos é vazio? Por que razão ele tem tamanho nulo? Qual o conteúdo do
outro arquivo?
$>
⑤ Escreva uma combinação de comandos conectados via pipe que devolva a quanti-
dade de números de 1 a 100 que contêm o dígito 0. $>
⑥ Use os comandos seq e xargs para resolver os seguintes exercícios:
RASCUNHO
(a) Gere o arquivo ~/quinze.txt cujo conteúdo é uma listagem dos números de
1 a 15, um por linha.
(b) Sobrescreva o conteúdo do arquivo ~/quinze.txt, cujo conteúdo deve passar
a ser novamente uma listagem dos números de 1 a 15, porém com todos os
números em uma única linha, separados por um caractere de espaço.
(c) Acrescente ao final do atual arquivo ~/quinze.txt a mesma listagem solici-
tada no item (a).
RASCUNHO
Processos
4
Todo comando em execução no Linux recebe o nome de processo. Cada processo
possui um identificador único, ao qual chamaremos processID.
Para os exemplos a seguir, usaremos o comando sleep, que faz com que o prompt
de comando aguarde a quantidade de segundos solicitada até que esteja disponível para
a execução de um novo comando novamente. Para aguardar 3 segundos:
$> sleep 3
Ao executar o comando sleep com um valor bem alto, teremos que aguardar
muito tempo até que o terminal esteja disponível novamente.
$> sleep 10000
RASCUNHO
Bem, a informação dada no parágrafo anterior não é de todo verdade. Veremos
nas seções seguintes o motivo.
4.1 Executando processos em segundo plano

Quando um programa demorado é executado, ficamos impossibilitados de usar o ter-
minal que chamou o programa até que este termine sua execução. Uma alternativa,
caso se esteja usando um terminal modo texto (tipicamente acessado por meio da com-
binação de teclas <Ctrl> + <Alt> + <F1>) é alternar para um outro terminal modo
texto teclando <Alt> + <F2>, <Alt> + <F3>, ..., <Alt> + <F6>. Ainda assim, o
número de terminais fica limitado a no máximo seis e, eventualmente, você enfrentará
situações em que precisará executar mais de seis processos em paralelo.
Uma solução melhor, e que realmente tira vantagem do fato de o Linux ser um
sistema operacional multi-tarefas, é o uso do operador ‘&’. Quando ele é usado após
um comando, faz com que este rode em segundo plano (background, em inglês). As-
sim, o mesmo terminal que foi usado para iniciar o processo demorado fica livre para
a execução de outros processos.
$> sleep 10000 &
Se, no entanto, você já possui um comando que está sendo executado em primeiro
plano (foreground , em inglês), ainda assim você não está impedido de usar o mesmo
terminal normalmente. Você pode suspender o comando em execução por meio da
27
combinação de teclas <Ctrl + z>. Isto fará com que o processo fique parado no
ponto em que se encontrava e o terminal é liberado para a execução de outros proces-
sos. Dizemos que o processo original ficou “suspenso”.
Após usar o terminal, você pode colocar novamente o processo original em exe-
cução com o comando fg (de foreground ).
$> fg
Isso fará com que o terminal novamente deixe de aceitar novos comandos. Essa
estratégia é boa para ser usada quando o comando que está rodando emite mensagens
ao terminal. Se, porém, o comando é do tipo “silencioso” e envia todos os seus re-
sultados para arquivos em vez de para a tela, faz todo sentido você deixá-lo rodando
em segundo plano. Contudo, às vezes nos esquecemos de digitar o símbolo & após o
comando. Nestes casos, após parar a execução do comando com <Ctrl + z>, basta
usar o comando bg (de background ).
$> bg
Isso fará com que o comando que foi parado com o <Ctrl + z> volte à execução, só
que desta vez em segundo plano e, com isso, você tem o terminal livre para executar
outros comandos.
Eventualmente, você pode ter mais de um processo suspenso ou sendo executado
em segundo plano. Para facilitar o gerenciamento desses processos existe o comando
jobs.
$> jobs
Se você quiser listar além dos identificadores de serviço (job IDs) também os identifi-
RASCUNHO
cadores dos processos (PIDs), use a opção -l.
$> jobs -l
Cada serviço suspenso ou em segundo plano está conectado ao terminal que o iniciou,
de modo que, se você deslogar, o utilitário jobs executado em outro terminal não
listará os serviços iniciados no terminal de origem.
4.2 Sendo legal com outros usuários: o comando nice

O Linux é um sistema operacional multitarefas, o que significa que diversos proces-
sos (inclusive de diversos usuários) podem estar rodando ao mesmo tempo em uma
mesma máquina. Os processadores atuais estão sendo desenvolvidos com cada vez
mais núcleos (do inglês core), de modo que mais processos possam ser executados ao
mesmo tempo ou mesmo um só processo possa ser executado em paralelo em vários
núcleos simultaneamente.
O Linux também é um sistema operacional multiusuários, permitindo que vários
usuários possam ter acesso a uma mesma máquina ao mesmo tempo. Cada um desses
usuários pode dar início a diversos processos e o sistema deve dar conta de alternar
o uso dos recursos computacionais de modo a atender todas as requisições. Esse é o
papel do escalonador de processos do Linux.
Dentre todos os processos que devem ser executados em uma máquina, o escalo-
nador deve escolher quais irão sair da fila de espera e efetivamente serem executados
CAPÍTULO 4. PROCESSOS 29
em um núcleo e por quanto tempo cada processo ficará sendo executado até voltar
para a fila de espera e ceder o núcleo para execução de outro processo. Para fazer
essas escolhas, o escalonador de processos do Linux se baseia em duas características
que todo processo contém: prioridade e nível de nice.
O valor desses dois campos pode ser visualizado para cada processo usando os
comandos htop ou top, nas colunas PRI no htop (PR no top) para a prioridade e
NI em ambos os programas para o nível de nice (pressione a tecla q, do inglês quit,
para sair). Quanto maior a prioridade de um programa, maior a probabilidade de ele
ser selecionado para execução em um núcleo e maior o tamanho da janela de tempo
em que ele ficará executando antes de ser enviado de volta para a fila de espera. Já
o valor do nível de nice tem efeito contrário: podemos entendê-lo como o quanto o
processo é gentil, amável, simpático (nice) com os outros processos. Quanto maior
o nível de nice de um processo, mais ele cede seu lugar para que outros processos
sejam executados no lugar dele, seja sendo retirado menos vezes da fila de espera, seja
usando os recursos computacionais por janelas de tempo menores quando ele está em
execução.
Por padrão, se nada é indicado na linha de comando, os processos rodam com nice
nulo. Caso se deseje alterar o valor de nice padrão, deve-se usar o comando nice.
$> sleep 15
$> htop
$> nice sleep 15
$> htop
Ao rodar o comando nice sem argumentos, o valor de nice passa a ser 10. Para alterar
esse valor, devemos usar a opção -n.
RASCUNHO
$> nice -n 19 sleep 15
O intervalo de valores que pode ser usado como nice vai de -20 a 19. Somente o
usuário root pode usar valores negativos de nice e, nesses casos, os processos tem sua
prioridade de execução aumentada.
4.2.1 Alterando o valor de nice de um processo

Se um processo já está rodando e você deseja alterar o valor de nice dele, tarefa essa
que também é conhecida como “dar um renice no processo”, você pode usar o co-
mando top e digitar r.
4.3 Medindo o tempo de execução: o comando

/usr/bin/time
A maior parte dos comandos que foram citados até agora são executados quase que
instantaneamente: basta teclarmos <ENTER> e o resultado já aparece na tela. No en-
tanto, infelizmente, nem sempre é assim. Quando se passa a trabalhar com big data,
que é o caso da área de Bioinformática, por exemplo, além da quantidade enorme de
dados que devem ser processados também são usados algoritmos que possuem com-
plexidade alta. Nestes casos, é comum termos processos que duram muitos minutos,
horas e até vários dias.
Para esses processos demorados, vale a pena medirmos o seu tempo de execução
pelos seguintes motivos:
• Você pode estudar quais parâmetros e quais máquinas permitem uma execução mais
rápida.
• É possível passar a ter uma ideia de, dada uma mudança no tamanho de alguma das
entradas, quanto tempo o processo levará para terminar.
Essas observações são particularmente importantes quando esses processos são co-
locados para rodar em uma máquina que é compartilhada por muitos usuários e que
possua um controle de serviços, no qual você deve indicar, antecipadamente, quais e
por quanto tempo os recursos serão usados.
A sintaxe do comando /usr/bin/time é bem simples: basta colocá-lo antes do
comando para o qual se quer medir o tempo de execução.
$> /usr/bin/time sleep 2
Por padrão, ele informará o tempo gasto segundo três valores:
user Tempo gasto pelo processo do usuário.
system Tempo gasto pelo sistema, para fazer o escalonamento de processos entre fila
de espera e fila de execução, por exemplo.
elapsed Tempo “real” de execução, o mesmo que você obteria se estivesse marcando
com um relógio.
RASCUNHO
Em sistemas multicore, é comum notar que o tempo informado como elapsed equivale
aproximadamente à soma dos tempos user e system dividida pelo número de núcleos
usados para o processamento. Nesses momentos nos damos conta que um processo
que levou duas horas para terminar usando 100 núcleos em um servidor teria levado
mais de 8 dias para ser concluído em uma máquina monoprocessada.
Para obter as informações dadas pelo comando /usr/bin/time de uma forma
mais organizada e completa, incluindo informações sobre a quantidade de memória
usada, podemos usar a opção --verbose.
$> /usr/bin/time --verbose sleep 2
Se quisermos salvar a saída do comando /usr/bin/time em um arquivo, o que

inclusive evita que sua saída fique misturada com a saída do comando que está tendo
seu tempo de execução medido, podemos usar a opção --output=<ARQUIVO>.
$> /usr/bin/time --output=log/sleep.time sleep 2
No exemplo acima estamos gravando a saída do comando /usr/bin/time no arquivo

sleep.time dentro do diretório local chamado log.
Note que sempre escrevemos o caminho absoluto do comando: /usr/bin/time.
Se você usar apenas time, o programa a ser executado será outro e o resultado não será
o mesmo. Você não poderá, por exemplo, usar as opções --verbose ou --output.
4.4 Execução condicional de um processo

Às vezes você deseja executar um comando somente se um outro comando executar
sem erros. Uma das formas de se fazer isso é usando o símbolo &&.
$> ls *.txt && cowsay "Há arquivos do tipo texto na pasta."
A mensagem somente será exibida, ou seja, o comando cowsay somente será exe-
cutado, caso o comando ls encontre algum arquivo com a extensão txt no diretório
corrente. Caso contrário, a mensagem não é impressa.
Se, no entanto, queremos executar um comando somente se um outro comando
falhar, podemos usar o símbolo ||.
$> ls *.txt || cowsay "Não há arquivos do tipo texto na pasta."
4.5 Listando processos

Para listar todos os processos de um usuário, use o comando ps com a opção -u
seguida do nome do usuário.
$> ps -u pires
Já para listar todos os processos de todos os usuários você pode usar o comando
ps com as opções aux (sem hífen mesmo):
$> ps aux
RASCUNHO
Para visualizar todos os processos que estão rodando no sistema com o máximo
de detalhes, use as opções -ef.
$> ps -ef
Se você também quiser incluir informação sobre cada tarefa (thread ), use a opção
-L.
$> ps -eLf
Para especificar quais atributos serão listados como saída do comando ps você
deve usar a opção o em conjunto com especificadores padrão de formato. Por exemplo,
para listar apenas o identificador do processo, o tempo de execução e o nome do
comando, com um cabeçalho em português, faça:
$> ps ao pid o time=TEMPO o comm=COMANDO
Consulte o manual para descobrir outros campos que podem ser usados, além de pid,
time e comm.
Uma outra forma de visualização dos processos de um sistema é dada pelo co-
mando pstree.
$> pstree
Os processos são exibidos em um diagrama em forma de árvore. Os nomes mostrados

entre chaves são threads, componentes de um processo que podem rodar em paralelo.
Ao discutirmos o comando nice, comentamos rapidamente o uso dos comandos
htop e top para visualizar o valor de nice de cada processo. Juntamente com o
comando atop, estas três ferramentas nos fornecem uma visualização dinâmica de
todos os processos rodando no sistema.
$> atop
$> htop
$> top
4.6 Matando processos

Há duas formas de se matar um processo, dependendo se você possui ou não acesso
ao terminal em que o processo está rodando.
com acesso ao terminal Caso o comando tenha sido iniciado em primeiro plano e
você tenha acesso ao terminal dele, pode-se interrompê-lo enviando um sinal
de interrupção com a combinação de teclas <Ctrl + c>. Isto será o suficiente
para matar o processo.
sem acesso ao terminal Caso o comando tenha sido iniciado em segundo plano ou
você não tenha mais acesso ao terminal dele, você pode matá-lo com o co-
mando kill. Para tanto, você deve descobrir o identificador do processo com
o comando ps ax:
RASCUNHO
$> ps ax
Uma vez identificado, mate o processo enviando o sinal KILL (ou seu sinônimo
numérico: “-9”) com o comando kill:
$> kill -KILL <processID>

$> kill -9 <processID>
Outra forma é executando o comando top e digitando k.
4.7 Parando processos

Você também pode parar a execução processos enviando a eles o sinal de STOP. Caso
o processo esteja sendo executado no mesmo terminal em que você está logado, basta
digitar <Ctrl + z>. Caso contrário, envie o sinal de STOP a ele com o comando
kill.
$> kill -STOP 3210
No exemplo acima, o processo cujo identificador é 3210 é parado.

4.8 Substituição de comandos

Às vezes precisamos usar o resultado de um comando como entrada para um outro
comando. Nestes casos, em vez de armazenar o resultado em um arquivo, podemos
fazer uma substituição de comando, colocando o comando entre acentos graves.
$> echo "Meu sistema operacional é ‘uname‘."
Note que, da mesma forma como com variáveis de ambiente, se usamos aspas simples
o acento grave não é interpretado e a substituição de comando não é realizada.
$> echo ’Meu sistema operacional é ‘uname‘.’
Contudo, como o mesmo caractere usado para iniciar uma substituição de co-
mando é também usado para finalizá-la, não é possível aninhar substituições de co-
mandos uma dentro da outra; pelo menos não com essa sintaxe. A sintaxe alternativa
é usar “$(” para iniciar a substituição de comando e “)” para finalizar. Com isso é
possível que você execute comandos que possuam uma substituição dentro de outra.
$> cat > inicio.txt
3
$> cat > fim.txt
7
$> echo A sequência de números é $(seq $(cat inicio.txt) \
$(cat fim.txt)).
A sequência de números é 3 4 5 6 7.
4.9 Subshells
RASCUNHO
Todo comando que estiver entre parênteses será executado em um novo shell que será
criado.
$> (cd /tmp; pwd; ls)
Note que após a execução deste subshell o usuário continua no mesmo diretório que
estava antes, mostrando que o comando cd /tmp foi executado em um outro shell.
4.10 Deixando seus processos rodando... mesmo sem

estar logado!
Alguns processos possuem um tempo de execução extremamente longo, levando vá-
rios dias para serem concluídos. Por conta da necessidade de um alto poder de proces-
samento, esses processos geralmente são executados em servidores de grande porte,
que funcionam 24 horas por dia, todos os dias do ano, sendo raramente reiniciados.
Sendo assim, você pode logar remotamente no servidor e dar início ao processo a
partir de um laptop ou desktop instalado em sua casa ou no trabalho e deixar seu
computador ligado, aguardando o fim da longa execução do processo.
No entanto, a instalação elétrica e a conexão de rede de sua casa ou local de tra-
balho provavelmente não é tão estável quanto à da sala em que o servidor está fisica-
mente instalado. Com isso, é alta a probabilidade de que sua máquina seja reiniciada
por conta algum pico (ou mesmo falta) de energia elétrica ou que sua conexão caia
devido à uma queda da internet. É para evitar problemas nesses casos que existem
técnicas que podem ser aplicadas para garantir a execução de seus processos até o
final, independentemente de seu login se manter ativo ou não no servidor.
O primeiro comando que iremos aprender como uma solução para este problema
é o nohup.
4.11 Agendando seus comandos para serem executa-

dos em outro momento
Se por algum motivo você precisar que algum comando seja executado mais tarde (ou
até em outro dia), use o comando at.
$> at now + 2 days
at> cat file.txt > /tmp/at.out
at> <EOT>
O comando “cat file.txt > /tmp/at.out” será executado em dois dias. Para
finalizar a entrada da tarefa a ser agendada, use a combinação de teclas <CTRL> + d,
o que imprimirá o termo <EOT> e finalizará o prompt do comando at. Você também
pode passar um script como argumento.
$> at now + 2 minutes script.bash
RASCUNHO
Tratamento de arquivos
5
Conforme foi discutido no Capítulo 2, os nomes de arquivos no Linux não dependem
de uma extensão. Para descobrir o tipo de um arquivo, você pode usar o comando
file.
$> file arquivo.txt
$> file imagem.jpg
$> file musica.mp3
$> file /home
Pode ocorrer de uma determinada aplicação exigir que as linhas de um arquivo
sejam processadas em ordem inversa, de baixo para cima ao invés de de cima para
baixo, ou seja, começando pela última linha e terminando pela primeira. Nesses casos,
podemos fazer uso do comando tac.
RASCUNHO
$> tac arquivo
5.1 Visualizando o conteúdo de arquivos

Para visualizar o conteúdo de um arquivo que seja human readable, como no caso de
um arquivo texto, você pode usar o comando cat.
$> cat arquivo.txt
Caso o arquivo a ser visualizado esteja compactado, pode-se usar o comando zcat.
$> zcat arquivo.txt.gz
Outra opção é usar o comando nl, que é um acrônimo para o termo em inglês
numbers of the lines. Esse comando lista o conteúdo que é passado para ele, prece-
dendo esse conteúdo por uma coluna na qual é listado o número de cada linha.
$> nl arquivo.txt
O nome cat é parte da palavra em inglês concatenate, indicando que esse comando
não apenas ecoa para a saída padrão o conteúdo do arquivo, como também pode ser
usado para concatenar arquivos: basta passar seus nomes como argumento.
$> cat arquivo1.txt arquivo2.txt
35
Se, no entanto, o arquivo é demasiadamente comprido, usar o comando cat para

visualizá-lo não será muito efetivo, já que todo o texto passará rapidamente pela tela.
Para visualizar o conteúdo de um arquivo comprido pausadamente, página por página,
em vez do cat podemos usar o comando more.
$> more arquivo.txt
Note, porém, que o comando more só permite que você visualize cada vez mais
do arquivo, seja avançando uma linha ou uma página, mas nunca permitindo voltar.
Para além de visualizar também navegar por um arquivo, podendo interagir com a
exibição de modo a mostrar as próximas páginas ou linhas ou ainda voltar o texto que
já passou, use o comando less.
$> less arquivo.txt
Se o arquivo sendo visualizado possui linhas que contém um número de caracteres

maior que a capacidade de exibição do terminal sendo usado, o comando less exibe
o restante do conteúdo na linha seguinte. Apesar de essa estratégia permitir que você
veja o conteúdo completo de uma linha sem grandes esforços, ela pode ser inconveni-
ente quando você está visualizando um arquivo organizado em colunas. Nestes casos,
vale a pena usar a opção -S do comando less, com a qual será exibido apenas o
conteúdo que cabe em tela por linha.
$> less -S arquivo.csv
Para procurar por um determinado texto a partir do ponto que está sendo visuali-
zado no arquivo com o comando less, deve-se teclar ‘/’ seguida da expressão que se
RASCUNHO
quer procurar. A expressão será procurada no texto que se encontra adiante do que é
exibido em tela.
Já no caso de se querer procurar por uma determinada expressão na parte do texto
que já foi visualizada e se encontra “acima” do que é exibido no momento, deve-se
usar a tecla ‘?’ seguida da expressão que se quer procurar.
Dar uma olhada no comando most.
5.2 Contando linhas, palavras e caracteres

O comando wc permite que contemos o número de linhas, palavras e caracteres de um
arquivo.
$> wc arquivo.txt
5.3 Gerando sequências numéricas

O comando seq pode ser usado para gerar sequências numéricas. Por exemplo, para
gerar os números de 1 a 100, 1 em cada linha, podemos fazer:
$> seq 100

CAPÍTULO 5. TRATAMENTO DE ARQUIVOS 37
5.4 Sobre cabeças e rabos

Às vezes precisamos dar uma olhada no conteúdo de um arquivo mas ele é muito
extenso para que valha a pena usar o comando cat. Se a visualização de apenas as
dez primeiras linhas já é o suficiente, podemos usar o comando head.
$> seq 100 > sequencia.txt

$> head sequencia.txt
Somente o “cabeçalho” composto pelas dez primeiras linhas é exibido. Caso o arquivo
contenha menos de dez linhas, somente serão impressas as linhas do arquivo (não
serão impressas linhas vazias até completar o total de linhas pedidas).
Se, por outro lado, preferirmos olhar as dez últimas linhas do arquivo, podemos
usar o comando tail.
$> tail sequencia.txt
Da mesma forma que para o comando head, o comando tail também somente exi-
birá, por padrão, as dez últimas linhas do arquivo (ou apenas as linhas do arquivo,
caso ele possua menos de dez linhas).
Se, tanto para o comando head quanto para o comando tail, quisermos visuali-
zar um determinado número de linhas, podemos usar a opção -n seguida do número
desejado.
$> head -n 2 sequencia.txt

$> tail -n 2 sequencia.txt
RASCUNHO
Podemos até mesmo usar uma abreviação composta apenas pelo hífen e pelo número:
-2 neste caso.
$> head -2 sequencia.txt

$> tail -2 sequencia.txt
Para visualizar as primeiras linhas de mais de um arquivo pode-se passar quantos

argumentos forem necessários para o comando head.
$> head arquivo1.txt arquivo2.txt
Note que quando recebe mais de um argumento, o comando head imprime, para cada
arquivo, primeiramente o nome do arquivo para depois imprimir as 10 primeiras li-
nhas. Cada listagem é separada por uma linha em branco. Se o intuito é obter esse
mesmo efeito ao se usar o comando head com apenas um arquivo, deve-se usar a
opção -v.
$> head -v arquivo.txt
O comando tail possui a opção -f (do inglês follow), a qual permite acompanhar
o crescimento do arquivo em tempo real, exibindo as linhas que são adicionadas a seu
final.
$> tail -f /var/log/auth.log

5.5 Ordenação de linhas

Comando uniq. Remove as linhas repetidas consecutivas.
Comando sort. sort -u para unique e sort -r para reverse.
5.6 Trabalhando com colunas

Arquivos que representem dados estruturados em colunas são muito comuns, graças
ao enorme uso de planilhas eletrônicas. Quando esses arquivos são representados em
modo texto, vários caracteres podem ser usados como separadores de coluna. Os mais
comuns são: <TAB>, ‘,’ (vírgula), ‘ ’ (espaço) e ‘;’.
Há ferramentas que facilitam o uso de arquivos deste tipo, tais como o cut e o awk.
Para listar apenas a primeira coluna de um arquivo cujas colunas estejam separadas
por <TAB>, basta fazer:
$> cut -f1 arquivo.tsv
$> awk -F "\t" ’{print $1}’ arquivo.tsv
Note que o comando cut considera que os campos são separados pelo caractere <TAB>
por padrão. No caso de o caráter ‘,’ ser usado como separador de colunas, é possível
indicar isso usando a opção -d (de delimiter, “delimitador” em inglês).
$> cut -d, -f1 arquivo.tsv
A opção -F informa o delimitador da entrada.
$> awk -F: ’($3 > 999) {print $1}’ /etc/passwd
RASCUNHO
Para listar as 6 primeiras colunas de um arquivo com 6 ou mais colunas separadas
por <TAB>, use a opção -f do comando cut, separando os valores dos extremos do
intervalo com um hífen (‘-’).
$> cut -f1-6 arquivo.tsv
$> cut -f-6 arquivo.tsv
Note que o segundo exemplo usa uma forma abreviada do intervalo.
Também é possível escolher colunas isoladas e intervalos de colunas, tudo em um
mesmo comando.
$> cut -f1,3,5-8,12
O comando acima seleciona as colunas 1, 3, de 5 a 8 e 12, além de assumir que as
colunas estão separadas por caracteres <TAB>.
Pode ocorrer casos em que o interesse é selecionar de uma coluna em diante, não
importando quantas colunas há após.
$> cut -f9- arquivo.tsv
O comando acima lista da coluna 9 (inclusive) em diante de um arquivo cujas colunas
estão separadas por <TAB>.
Aplicações que exigem a seleção de colunas em uma ordem diferente da crescente,
invertendo duas colunas, por exemplo, ou a repetição de colunas, devem fazer uso da
função print do comando awk, indicando a ordem das colunas.
$> awk ’{ print $2,$1}’ arquivo.tsv

Note que não é possível obter esse resultado com o comando cut.
$> cut -f2,1 arquivo.tsv
O comando acima irá imprimir as colunas 1 e 2, nesta ordem, já que durante a exe-
cução do comando cut as colunas selecionadas são escritas na mesma ordem em que
são lidas e, inclusive, são escritas apenas uma vez. Assim, o comando:
$> cut -f1,3,2,1-3,2,3,1 arquivo.tsv
é equivalente a:
$> cut -f1-3 arquivo.tsv
5.6.1 De trás para frente

Até agora trabalhamos com colunas sendo contadas em ordem direta, ou seja, da pri-
meira para a última. Às vezes, no entanto, é preciso trabalhar com colunas sendo
contadas em ordem inversa, da última para a primeira. Imagine, por exemplo, a ne-
cessidade de se querer imprimir a última coluna nos seguintes casos:
• Não se sabe quantas colunas existem.
• Cada linha possui um número diferente de colunas.
Nenhuma das soluções apresentadas até agora é capaz de lidar com este problema,
para o qual apresentaremos duas soluções.
A primeira solução usa o comando rev. Este comando executa uma tarefa muito
RASCUNHO
simples: imprime de trás para frente cada linha que recebe. Note que, fazendo isso,
não importa se não sabemos quantas colunas existem ou se cada linha possui um
número diferente de colunas: após a inversão, a última coluna da entrada original
será, certamente, a primeira. Só não se pode esquecer da necessidade de “desinverter”
o resultado ao final.
$> < arquivo.tsv rev | cut -f1 | rev
A segunda solução usa o comando awk. Nessa linguagem de programação, o
número de colunas é armazenada na variável NF (abreviação do inglês Number of
Fields, de número de campos).
$> awk ’{print $NF}’ arquivo.tsv
As duas estratégias podem ser usadas para a extração de qualquer número de colu-
nas que sejam contadas de trás para frente. Veja, por exemplo, a obtenção da penúltima
coluna:
$> < arquivo.tsv rev | cut -f2 | rev
$> < arquivo.tsv awk ’{print $NF-1}’
5.6.2 Montando colunas

Comando paste.
5.7 Busca de expressões: o comando grep

O comando grep serve para buscar expressões em arquivos. Para buscar o padrão
AGATAGAGAATACA no arquivo 1_R1.fasta, podemos fazer:
$> grep "AGATAGAGAATACA" 1_R1.fasta
Esse comando irá imprimir na tela cada linha do arquivo 1_R1.fasta que contém o
padrão procurado.
Ao buscar o padrão em diversos arquivos, antes da impressão de cada linha é
impresso o nome do arquivo em que o conteúdo foi encontrado.
$> grep "AGATAGAGAATACA" *.fasta
Se você quiser imprimir apenas o nome dos arquivos em que o padrão procurado
ocorre, use a opção -l do grep.
$> grep -l "AGATAGAGAATACA" *.fasta
Para contar o número de linhas que resultou de uma busca com o comando grep,
use a opção -c. Outra opção é redirecionar sua saída para a entrada do comando
wc -l.
$> grep -c Brasil hinoNacional.txt

$> grep Brasil hinoNacional.txt | wc -l
É muito útil usar alguns metacaracteres ao se fazer buscas com o comando grep:
RASCUNHO
$> ls | grep png$
$> ls | grep ^#
O metacaractere $, quando usado para casar padrões, casa com qualquer string que
termine com a string fornecida imediatamente à sua esquerda. Já o metacaractere ^
restringe o resultado a item que iniciam com uma determinada string.
5.8 Substituição de expressões

O comando sed, de stream editor, possui várias aplicações sendo provavelmente a
mais usada a de realizar a substituição de expressões em arquivos.
$> sed ’s/T/U/’ 1_R1.fasta
O comando acima substitui a primeira ocorrência de ’T’ em cada linha por ’U’ no
arquivo 1_R1.fasta. Geralmente, não é o que se quer ao solicitar uma substituição:
o intuito é que a substituição ocorra a cada ocorrência do padrão, mesmo que sejam
várias ocorrências em uma mesma linha. Para isso, precisamos usar a opção g ao final
do comando de substituição.
$> sed ’s/T/U/g’ 1_R1.fasta

5.9 Busca por arquivos

Para obter uma listagem de todos os arquivos no diretório atual e em todos seus sub-
diretórios, use o comando find.
$> find
Caso a listagem que você deseja obter seja de todos os arquivos de um outro diretório
que não seja o atual, pode-se passar o nome do diretório como argumento para o
comando find.
$> find /home/pires/Downloads
Para restringir a busca, por exemplo pela extensão do arquivo, pode-se usar a opção
-name do comando find.
$> find . -name ’*.log’
No exemplo acima, apenas os arquivos que estiverem abaixo da árvore de diretórios
do diretório atual (‘.’) e que possuam a extensão log serão listados.
Às vezes queremos procurar por um arquivo cujo nome sabemos mas desconhe-
cemos se está escrito com letras maiúsculas, minúsculas ou uma combinação delas.
Nesses casos, podemos usar a opção -iname do comando find.
$> find . -iname readme
O comando acima será capaz de encontrar, em qualquer subdiretório do diretório cor-
rente, arquivos com o nome readme escrito em todas as combinações de maiúsculas e
minúsculas, tais como readme, README, Readme e readMe, dentre outras. O caractere
RASCUNHO
i no nome da opção -iname é um mnemônico para o termo em inglês “ignore case”.
O comando find também pode lidar com conectores lógicos. Digamos, por exem-
plo, que você queira encontrar, a partir do diretório atual, todos os arquivos que pos-
suam extensão fa ou fna.
$> find . -name ’*.fa’ -o -name ’*.fna’
Note que no comando acima os símbolos “(” e “)” dos parênteses estão “protegidos”
(ou “escapados”) pelo símbolo \ de barra invertida (ou “contrabarra”). Isso é necessá-
rio para que eles não sejam interpretados pelo shell como um subshell, tal como vimos
na Seção 4.9.
Também é possível restringir a saída do comando find para obter apenas diretó-
rios (usando a opção -type d), arquivos (-type f) ou links (-type l).
$> find . -type d
$> find . -type f
$> find . -type l
Para executar um comando que seja aplicado a cada arquivo que for encontrado
pelo comando find, você pode usar a opção -exec. Digamos, por exemplo, que você
deseja excluir todos os arquivos que se encontrem na árvore de diretórios atual que
possuam a extensão .swp:
$> find . -name ’*.swp’ -exec rm {} ’;’
Se, no entanto, você quiser ser mais cauteloso e deseja que seja mostrado primeira-
mente cada comando a ser executado para você responder se quer realmente seguir em
frente ou recusar a execução do comando para determinados argumentos, use a opção
-ok em vez de -exec.
$> find . -name ’*.swp’ -ok rm {} ’;’
Digamos agora que você queira listar os arquivos que tenham tido seus metadados
(tais como posse e permissões de leitura, escrita e execução) alterados há três dias
atrás. Para tanto, você pode usar a opção -ctime do comando find.
$> find . -ctime 3
Se você quiser listar os que tenham sofrido alteração nos últimos três dias, acrescente
o símbolo ‘-’ antes do dígito 3.
$> find . -ctime -3
E para listar os arquivos que sofreram alteração há mais de três dias, o símbolo deve
ser o ‘+’.
$> find . -ctime +3
Você também pode procurar por arquivos de acordo com a data em que foram lidos ou
acessados pela última vez (opção -atime) ou pela data em que foram modificados ou
escritos pela última vez (opção -mtime). Se em vez de especificar o tempo em dias
você precisar especificá-lo em minutos, use as opções -cmin, -amin e -mmin.
Outra grande utilidade do comando find é usá-lo para encontrar arquivos baseando-
RASCUNHO
se em seus tamanhos. Para tanto, use a opção -size.
$> find . -size 0
A medida padrão de tamanho corresponde a blocos de 512 bytes. Pode-se especificar

tamanhos em bytes (c, de character), quilobytes (k), megabytes (M) e gigabytes (G).
Por exemplo, para encontrar os arquivos ocupando mais de 10 megabytes, faça:
$> find . -size +10M
5.10 Compactação e descompactação de arquivos

Há uma diferença entre compactação (redução de tamanho sem perda) e compressão
de dados (redução de tamanho com perda).
Para descompactar arquivos com a extensão .zip use o comando unzip.
$> unzip arquivo.zip
Caso você queira que o arquivo seja descompactado em um outro diretório, use a
opção -d.
$> unzip arquivo.zip -d output/

5.10.1 O comando tar

É comum nos depararmos com arquivos compactados contendo vários outros arqui-
vos e que possuem a extensão .tgz ou .tar.gz. O comando usado para criar e
descompactar esse tipo de arquivo é o tar. Para exemplificar seu uso, consideremos
que há um diretório chamado exercicios que contém vários arquivos, nomeados
exercicio00.txt, exercicio01.txt, . . . , exercicio99.txt. Para compactar
esse diretório e todo seu conteúdo em um arquivo chamado exercicio.tgz, pode-
mos fazer:
$> tar zcvvf exercicio.tgz exercicio
As opções zcvvf possuem o seguinte significado:
z: indica que queremos compactar os arquivos (em vez de apenas juntá-los em um

arquivo só) usando o algoritmo implementado pelo programa gzip;
c: cria um arquivo de acordo com as outras opções passadas;
v: ativa o modo verbose (“verboso” ou “prolixo” em inglês), informando o nome de

todos os arquivos que estão sendo compactados;
v: o uso de um outro v adicional ativa também o modo verbose, porém em formato de

lista longa, exibindo metadados sobre os arquivos que estão sendo compactados,
tais como usu ário, grupo e data de criação, semelhante à opção -l do comando
ls.
f: indica que a entrada de dados a serem compactados ocorrerá através de um arquivo
RASCUNHO
(em vez da entrada padrão), cujo nome deve ser informado imediatamente após
o uso da opção.
Após a compactação dos dados, eventualmente você precisará descompactá-los

novamente para poder usá-los. Em nosso exemplo, poderíamos usar o seguinte co-
mando:
$> tar zxvvf exercicios.tgz
A única diferença em relação ao comando de compactação é a troca da opção c pela

opção x, a qual possui o seguinte significado:
x: abreviação para extract (“extrair” em inglês), essa opção permite extrair qualquer
arquivo que esteja armazenado no tarball, realizando a devida descompactação
dos dados.
Exercícios
① Imprima na tela uma contagem regressiva de 10 a 1.
② Considere que output/ é um subdiretório de seu diretório de trabalho atual e que

seu conteúdo consiste nos seguintes arquivos e diretórios:
a-s1-l7_R1.fastq b-s1-l7_R1.fastq boxPlot -> plot/boxPlot/

a-s1-l7_R2.fastq b-s1-l7_R2.fastq histogram -> plot/hist/
a-s1-l8_R1.fastq b-s1-l8_R1.fastq myProgram*
a-s1-l8_R2.fastq b-s1-l8_R2.fastq myScript*
a-s2-l7_R1.fastq b-s2-l7_R1.fastq plot/
a-s2-l7_R2.fastq b-s2-l7_R2.fastq scriptR/
a-s2-l8_R1.fastq b-s2-l8_R1.fastq scriptR1/
a-s2-l8_R2.fastq b-s2-l8_R2.fastq scriptR2/
(a) Liste todos os arquivos que possuem o termo “R2” como substring em seu
nome.
(b) Dos arquivos listados no item anterior, separe os identificadores que aparecem
antes do segundo hífen (“-”).
(c) A partir da listagem do item anterior, remova as linhas repetidas.
(d) Quantos identificadores únicos (diferentes) há? Não conte: use um comando
que forneça a resposta.
③ Uma determinada aplicação gera diversos arquivos intermediários com as exten-

sões o e out. Com o fim de fazer um uso mais econômico do espaço em disco,
escreva um comando que remova todos os arquivos que possuam essas extensões e
que não foram consultados nos últimos cinco dias.
④ Use o comando split com a opção -l para converter um arquivo multifasta em
vários arquivos fasta.
⑤ O arquivo nome.txt contém 5 nomes, um por linha. O arquivo email.txt contém
RASCUNHO
os emails correspondentes a cada nome, na mesma linha. Gere um arquivo que
contenha duas colunas: os nomes na primeira e os emails na segunda.
⑥ Remova da quarta coluna todos os caracteres que aparecem após o primeiro hífen,
inclusive.
Informações do sistema
6
Para descobrir o caminho completo de um comando, ou seja, o local onde se encontra
o seu script ou o seu binário, use o comando which.
$> which ls
Caso o comando que você esteja tentando executar não seja encontrado pelo which
Você pode tentar descobrir onde ele está usando o comando whereis.
$> whereis ls
O comando whereis exibe a localização do executável (binário), do código-fonte e

do manual do comando passado como argumento.
Se, no entanto, você deseja descobrir todos os arquivos que existem no sistema
RASCUNHO
que contém uma determinada string em seu nome, use o comando locate.
$> locate whereis
Note que esse comando mostra ainda mais resultados que o comando whereis apli-
cado à própria string whereis.
$> whereis whereis
Há uma outra vantagem no uso do comando locate em relação ao comando

whereis: ele pode ser usado para procurar por qualquer tipo de arquivo, não ape-
nas para comandos. Pode-se, por exemplo, procurar por todos os arquivos do tipo
PDF no sistema:
$> locate *.pdf
De fato, esse uso mais genérico aproxima o comando locate muito mais do comando
find do que do whereis. A diferença fica por conta de que o locate usa um banco
de dados que lista todos os arquivos em disco (e que pode estar defasado) enquanto
que o find busca os arquivos em disco em tempo real. Essa estratégia faz com que o
comando locate rode muito mais rápido que o comando find; deve-se apenas estar
atento à possibilidade de não serem listados os arquivos que foram criados após a
última atualização do banco de dados.
45
6.1 Uso de apelidos para comandos

Atualmente, as distribuições de Linux já trazem o sistema configurado de uma forma
bastante amigável. Um caso comum é o comando ls, o qual é executado, por padrão,
com a opção --color=auto, de modo a classificar com diferentes cores cada tipo de
item listado, facilitando a distinção entre diretórios, arquivos comuns, links simbólicos
e links simbólicos quebrados, por exemplo.
6.2 Carga do sistema

Para saber há quanto tempo o sistema está ativo você pode usar um dos comandos w,
top ou uptime.
$> w
$> top
$> uptime
Esses mesmos comandos informam quantos usuários estão logados no sistema e tam-
bém a carga do sistema.
A carga média é indicada pelos três valores de load average. Uma carga alta indica
que o sistema está muito ocupado na execução de processos. Quando o valor de load
average é alto, o valor de “id” na terceira linha do comando top deve ser baixo, e vice-
versa. Cada valor corresponde à porcentagem de uso da CPU durante um determinado
período de tempo. Os períodos correspondem ao último minuto, aos 5 últimos minutos
e aos 15 últimos minutos, respectivamente, para o primeiro, segundo e terceiro valor.
RASCUNHO
O comando top nos fornece ainda mais informações sobre outros tipos de carga do
sistema. O valor de wa na terceira linha, por exemplo, indica a porcentagem de servi-
ços que estão aguardando (waiting) por entrada e saída (“I/O”, do inglês input/output).
A porcentagem de tempo que tem sido gasta com interrupções de hardware e software
é indicada pelos valores de hi (hardware interruption) e si (software interruption). Já
o valor de st (de steal time) indica a porcentagem de CPU que está sendo usada para
o gerenciamento de máquinas virtuais.
É possível, inclusive, visualizar na forma de um gráfico, com o comando top, a
porcentagem de CPU que está sendo usada. Digite t uma vez para um gráfico de
linhas, t por uma segunda vez para um gráfico de barras, t pela terceira vez para
ocultar a segunda e a terceira linhas e t pela quarta vez para voltar para a exibição
padrão.
6.3 Memória
Para verificar o total de memória física disponível e o quanto dela está sendo usado,
use o comando top. A quarta linha exibe a quantidade total de memória, o quanto
dela está livre, o quanto está sendo usado e o quanto está sendo usado como buffer ou
cache.
Com relação à área de troca, a quinta linha do comando top exibe a quantidade
total de área de troca, o quanto dela está livre e o quanto está sendo usado.
CAPÍTULO 6. INFORMAÇÕES DO SISTEMA 47
6.4 Processos
O comando top exibe os processos que estão no sistema. A tabela possui diversas
colunas, cujos significados são os seguintes:
PID Número de identificação do processo.
USER Usuário dono do processo.
PR Valor da prioridade.
NI Valor do nice.
VIRT Memória virtual.
RES Memória física.
SHR Memória compartilhada.

S Estado.
%CPU Porcentagem de CPU usada.
%MEM Porcentagem de memória usada.

TIME+ Tempo de execução.
COMMAND Comando.
A segunda linha do comando top informa a quantidade de processos rodando, dor-
RASCUNHO
mindo, parados e zumbis no sistema. A terceira linha contém os valores de us (user)
e sy (system) que indicam a porcentagem de tempo da CPU que está sendo dividida
entre processos de usuários e processos do kernel (núcleo do sistema operacional).
Na terceira linha, o valor de ni informa a porcentagem de serviços que estão rodando
com baixa prioridade (ou seja, com nice alto).
Para visualizar a porcentagem de memória que está sendo usada no sistema como
um gráfico, digite m. Será exibido um gráfico preenchido por linhas. Digite m pela
segunda vez para um gráfico de barras, m pela terceira vez para ocultar a quarta e a
quinta linha e m pela quarta vez para voltar para a exibição padrão.
Para mostrar uma lista com os processos que são os principais consumidores de
recursos, use o comando A do top. Para entrar em sua tela de configuração, digite
f. Para selecionar interativamente um novo tipo de ordenação na lista de processos,
digite o.
RASCUNHO
Acesso remoto
7
7.1 ssh
O ssh (do inglês Secure SHell) é um programa que permite a um usuário conectar-se
a outra máquina de forma segura, usando criptografia. Você pode usar o programa
putty no Windows para conectar via SSH em uma máquina Linux. No Linux, basta
usar o comando ssh.
$> ssh pires@vital.butantan.gov.br
Note que o argumento passado como primeiro parâmetro neste exemplo é composto
por três partes: {usuário}@{computador}. Primeiramente é preciso dizer o nome
do usuário que se quer usar para fazer a conexão SSH e depois o nome da máquina
em que se quer conectar. Esses dois campos são separados pelo símbolo ‘@’.
RASCUNHO
Se o nome do usuário remoto é o mesmo do usuário local, pode-se passar como
argumento apenas o nome da máquina, que sempre deve ser completo, incluindo o
domínio.
$> ssh vital.butantan.gov.br
Também é possível usar o IP da máquina em vez de seu nome. Essa forma é muito
útil quando o DNS (Domain Name Server) não está funcionando.
$> ssh 172.25.2.25
O ssh irá solicitar a senha do usuário na máquina em que se quer conectar. Ao
digitar a senha, nada, nem mesmo caracteres ‘*’, aparecerá na tela. Isso é proposital,
pois quem por acaso estiver olhando para a tela não saberá nem mesmo por quantos
caracteres sua senha é composta.
Após entrar com a senha corretamente, será exibido o terminal da máquina remota.
7.2 scp
7.3 sshfs
Para montar uma pasta ou um sistema de arquivos via SSH:
sshfs name@server:/path/to/folder /path/to/mount/point
49
RASCUNHO
Scripts em bash
8
8.1 Os cinco tipos de ferramentas de linha de comando
ç
8.2 O shabang
É sabido que o Linux não depende de extensões nos nomes dos arquivos para saber
o tipo de arquivo com o qual se está lidando. Isso é possível graças aos chamado
magic numbers que são números colocados logo no início de um arquivo, informando
seu tipo. Já para arquivos do tipo texto, usa-se a combinação de símbolos “#!” para
informar o shell qual interpretador deve ser usado para ler o arquivo. Esse é o caso de
scripts em bash.
RASCUNHO
8.3 Variáveis de ambiente
Para criar uma variável no bash, basta realizar uma atribuição com o símbolo =.
$> NOME=Maria
No comando acima, NOME é o nome da variável, = é o comando de atribuição de um

valor a uma variável e Maria é o valor que está sendo atribuído à variável NOME. Note
que espaços não são permitidos nem antes nem depois do símbolo =.
Para usar o conteúdo de uma variável (ação chamada de expansão da variável),
basta precedermos seu nome com o símbolo $.
$> echo O nome dela é $NOME.
Ao trabalhar com variáveis de ambiente, devemos ficar atentos à expansão do valor

dessas variáveis. Observe os diferentes comportamentos abaixo, conforme usamos
diretamente o nome da variável, aspas simples ou aspas duplas.
$> NAME="Linux"
$> echo NAME
NAME
$> echo $NAME
51
Linux
$> echo ’NAME’
NAME
$> echo "NAME"
NAME
$> echo ’$NAME’
$NAME
$> echo "$NAME"
Linux
Podemos notar que ao usar aspas simples, o conteúdo envolto por elas é passado da
forma como está, sem nenhuma interpretação por parte do shell. Já no caso das aspas
duplas, o conteúdo é interpretado no sentido de expandir os valores das variáveis. Esse
é o mesmo comportamento que notamos na Seção 4.8, em que tratamos da substituição
de comandos.
Tão logo um usuário ganha acesso a um sistema, diversas variáveis de ambiente
são definidas para ele. O próprio texto que é exibido no “prompt” da linha de comando
é definido por uma variável de ambiente, chamada PS1. Nela, alguns códigos são
usados para expansão de outras variáveis. Por exemplo, \u é expandido para o nome
do usuário e \h é expandido para o nome da máquina (’h’ de host). Faça um teste e
altere o valor dela.
$> echo $PS1
$> PS1="\u@\h \$ "
$> echo $PS1
RASCUNHO
8.4 A estrutura de repetição for
Eventualmente precisamos realizar uma mesma tarefa com diferentes entradas. Faz-se
necessária uma estrutura de repetição, que receba uma lista com as entradas e permita
facilmente repetir os mesmos comandos em cada item da lista.
Outros tópicos
9
9.1 Buscando ajuda
Desde o usuário iniciante até o mais experiente, vez ou outra se faz necessária a con-
sulta a algum sistema de ajuda. Seja para aprender mais sobre algum comando, des-
cobrir novas opções ou simplesmente para se lembrar da sintaxe, existem diversas
formas de se buscar ajuda no próprio sistema.
Para saber onde se encontra o binário, o manual, o info e o código-fonte de um
comando, use o comando whereis.
$> whereis whereis
Se for encontrado mais de um binário para um mesmo comando, o que será exe-
cutado por padrão será o primeiro que aparecer ao se seguir a ordem dos diretórios
RASCUNHO
determinada pela variável de ambiente PATH. Para você saber o caminho absoluto do
executável selecionado, use o comando which.
$> which grep
O comando mais comum para obter ajuda na linha de comando é o man, abreviação
de manual. Ele mostra a seção do manual, uma descrição sobre o que o comando faz,
sua sintaxe, a lista de opções, exemplos de uso e sugestões de outros manuais de
comandos relacionados. O manual do comando ls, por exemplo, pode ser consultado
com o comando a seguir:
$> man ls
Para abrir o manual em uma determinada seção, é preciso especificá-la como pri-
meiro argumento, de modo que o comando para o qual se quer consultar o manual
passa a ser o segundo argumento.
$> man 7 ip
Os manuais estão instalados em /usr/share/man. Para gerar uma versão de um

manual no formato PostScript, ideal para impressão ou para leitura em um ambiente
gráfico, faça:
$> zcat /usr/share/man/man5/modprobe.d.gz | groff -man -Tps > modprobe.d.ps
53
Esse arquivo pode ser visualizado com o programa gv.

Para obter uma descrição de apenas uma linha sobre o que um comando faz ou,
eventualmente, quais são as seções de manual que contém explicações sobre o co-
mando, use o whatis (equivalente a man -f). whatis (equivalente a man -f).
$> whatis ls
$> man -f ls
Para fazer busca nos nomes das páginas e nas descrições, use o comando apropos
(equivalente a man -k).
$> apropos ls
$> man -k ls
Para alguns comandos, há seções com descrições mais amigáveis, como se fosse
um livro, as quais são acessadas através do comando info. Serve mais para aprender
do que para consultar. O mais indicado para consultar é o man.
$> info ls
Há ainda a opção --help.
$> ls --help
Às vezes um comando possui o mesmo nome de uma função em uma determinada

linguagem de programação. Em casos como esse, é preciso selecionar um capítulo es-
pecífico do manual, indicando o número do capítulo como uma opção para o comando
man. Por exemplo, o manual do comando printf está no capítulo 1 ao passo que o
da função printf da linguagem C está no capítulo 3.
RASCUNHO
$> man 1 printf
$> man 3 printf
Caso queira visualizar todos os capítulos, um depois do outro, use a opção -a do

comando man.
$> man -a printf
Uma outra forma de buscar por ajuda é por meio da execução do comando help.
$> help cd
No entanto, ele só funciona para alguns comandos populares que possuem versões
chamadas built-in. Para outros tipos de comando, como o ls, obtém-se uma mensa-
gem de erro.
$> help ls
bash: help: no help topics match ‘ls’. Try ‘help help’ or ‘man
-k ls’ or ‘info ls’.
Para obter uma listagem dos comandos built-in, execute o comando help sem
nenhum argumento.
$> help
CAPÍTULO 9. OUTROS TÓPICOS 55
Há ainda comandos, geralmente os mais recentes, que ainda não dispõem de um

manual. Nestes casos, você sempre pode tentar chamar a ferramenta com a opção -h
ou --help.
No caso de se desejar um sistema de ajuda que faça uso da interface gráfica, para
aplicativos KDE temos o comando khelpcenter e para aplicativos GNOME há os
comandos gnome-help e yelp.
Para encontrar informações sobre como a distribuição de Linux usada empacotou
o programa de seu interesse, procure pelo nome do pacote que contém o programa no
diretório /usr/share/doc.
Você também pode encontrar ajuda na web, tais como nas seguintes URLs:
• http://linuxcommand.org/tlcl.php
• https://help.ubuntu.com/
9.1.1 O sistema info

Um sistema de ajuda que é ótimo para o aprendizado de ferramentas mas que é pouco
usado é o info. A navegação pelas páginas de info não é muito intuitiva, de modo
que é importante decorar alguns atalhos principais:
Page Up Navega para uma página acima.
Page Down Navega para uma página abaixo.
q Sai do sistema info (do inglês quit, sair).
H Para chamar a ajuda (do inglês help, ajuda).
<ENTER> Para selecionar um item do menu.
RASCUNHO
Também há um conjunto de teclas de atalho para navegar entre nós da página info:
n Para ir para o próximo nó (do inglês next).
p Para ir para o nó anterior (do inglês previous).
u Para mover para um nó acima no índice (do inglês up).
Explorar o comando cheat (e dar uma olhada no tldr).
9.2 Configuração do Bash

9.2.1 .bash_profile
9.2.2 .bashrc
9.3 Jogos em modo texto

Não é só de coisa séria que o mundo do modo texto permite tratar: também há espaço
para a diversão.
Veja o que acontece, por exemplo, caso você cometa um erro de digitação e, em
vez de digitar ls você digitar sl.
Outros exemplos de comandos divertidos:
$> curl wttr.in

$> cmatrix
$> telnet towel.blinkenlights.nl
$> Xroach
$> hollywood
Bom para executar no terminal de alunos quando abandonam seus computadores

sem travar a tela:
$> xroach &; clear
Seguem alguns jogos em modo texto que variam entre ... e que podem garantir
horas e horas de muito entretenimento.
2048 https://github.com/tiehuis/2048-cli/releases (apt install libncurses5-dev)
nsnake
greed
bsdgames
moon-buggy
ninvaders
bastet
pacman4console
RASCUNHO
Exercícios
① Estude o manual do comando seq e descubra como imprimir na tela a contagem
de 20 a 40 listando, porém, apenas os números pares.

Introdução Ao Linux

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Introdução Ao Linux

Enviado por

Direitos autorais:

Formatos disponíveis

Introdução

David da Silva Pires

③ Por que você quer aprender sobre a linha de comando do Linux?

2.1 Sistema de arquivos

2.1.1 Diretórios: criação, listagem, navegação, renomeação e re-

Geralmente, após o login, o diretório padrão é o chamado “home” do próprio usuário.

Para armazenar todo o conteúdo de um determinado assunto em um mesmo lugar

$> mkdir curso

À palavra que é passada como parâmetro para um comando chamamos de argumento.

É bastante comum a necessidade de alterar para o diretório recém-criado.

$> mkdir culinária

$> mkdir vegana; cd vegana

Nomes de arquivos e diretórios no Linux são considerados diferentes quando escri-

Além dos nomes de arquivos e diretórios, os comandos também são sensíveis a

Dizemos que o diretório /home/pires contém e é o diretório pai do diretório

$> mkdir literatura

$ echo "Esta frase tem" \

$> mkdir --parents --verbose linux/capitulo2/exercicio

$> mkdir -pv linux/capitulo4/exercicio

Para remover um diretório não-vazio juntamente com todo o conteúdo existente

$> rm -rf <DIRETORIO>

$> mv linux introducaoAoLinux

Caso se esteja em um nível bem profundo de subdiretórios como, por exemplo:

ou simplesmente passar o argumento - como parâmetro para o comando cd:

2.1.2 Arquivos: criação, cópia, movimentação, renomeação e re-

$> touch arquivo

O arquivo de nome “arquivo” será criado no seu atual diretório de trabalho.

Remover arquivos é perigoso por si só. Tradicionalmente, o terminal do Linux

2.1.3 Arquivos e diretórios ocultos

2.1.4 Listagem em ordem alfanumérica e numérica

2.1.5 Espaços em nomes de arquivos e diretórios

$> cd Minhas\ Imagens

2.1.6 Link simbólico

Após o comando acima, o diretório /home/pires/Documents conterá um link sim-

$> ln -s /project/pires/tese.tex doutorado.tex

Assim, o link doutorado.tex criado no diretório corrente apontará para o arquivo

Observe, como exemplo, a sequência de comandos abaixo:

$> mkdir dir

2.2 Histórico de comandos

2.3 Diretórios do sistema operacional

2.3.2 O diretório / (barra)

2.3.3 Outros diretórios do sistema

2.4 Permissões de acesso

drwxrwx--- 2 pires pires 4096 dez 9 11:45 diretorio

2.4.1 Alteração das permissões de acesso

u usuário dono do item;

a todos (do inglês all).

$> chmod <ALTERAÇÃO> <ARQUIVO>

A alteração envolve um conjunto de caracteres que representa as categorias para as

$> chmod g+rw teste.txt

2.4.2 Alteração das permissões de acesso usando código binário

2.5 Estatística de arquivos e diretórios

2.6 Caracteres especiais

2.7 Teclas de atalho

Caso haja mais de uma possibilidade de completamento, o pressionamento da tecla

2.7.2 Navegação com o cursor

2.7.3 Rolamento de tela

<Shift + ↑> Rola a tela para cima, linha a linha.

2.7.4 Outros atalhos interessantes

<Ctrl + r> Busca reversa.

② Escreva os comandos necessários para executar as seguintes ações (use somente os

• Mova para o seu diretório home.

③ Escreva os comandos necessários para executar as seguintes ações (use somente os