3.2 Lição 1

Certificate:

Linux Essentials

Version:

1.6

Topic:

3 O poder da linha de comando

Objective:

3.2 Como buscar e extrair dados de arquivos

Lesson:

1 of 2

Introdução

Nesta lição, vamos nos concentrar no redirecionamento ou transmissão de informações de uma fonte para outra com a ajuda de ferramentas específicas. A linha de comando do Linux redireciona as informações através de canais padrão específicos. O teclado é considerado a entrada padrão (stdin ou canal 0) do comando, e a tela, a saída padrão (stdout ou canal 1). Há também um terceiro canal destinado a redirecionar a saída de erro (stderr ou canal 2) de um comando ou as mensagens de erro de um programa. A entrada e/ou saída podem ser redirecionadas.

Ao executar um comando, às vezes queremos transmitir determinadas informações a ele ou redirecionar a saída para um arquivo específico. Cada uma dessas funcionalidades será discutida nas duas seções a seguir.

Redirecionamento de E/S

O redirecionamento de E/S permite que o usuário redirecione informações de ou para um comando usando um arquivo de texto. Como explicado anteriormente, a entrada, a saída e a saída de erro padrão podem ser redirecionadas, e as informações, obtidas de arquivos de texto.

Redirecionando a saída padrão

Para redirecionar a saída padrão para um arquivo em vez da tela, devemos usar o operador > seguido pelo nome do arquivo. Se o arquivo não existir, um novo será criado; caso contrário, a informação vai sobrescrever o arquivo existente.

Para ver o conteúdo do arquivo que acabamos de criar, podemos usar o comando cat. Por padrão, esse comando exibe o conteúdo de um arquivo na tela. Consulte a página do manual para saber mais sobre suas funcionalidades.

O exemplo abaixo demonstra a funcionalidade do operador. Na primeira instância, um novo arquivo é criado contendo o texto “Hello World!”:

$ echo "Hello World!" > text
$ cat text
Hello World!

Na segunda invocação, o mesmo arquivo é sobrescrito com o novo texto:

$ echo "Hello!" > text
$ cat text
Hello!

Se quisermos adicionar novas informações ao final do arquivo, usamos o operador >>. Esse operador também cria um novo arquivo caso não encontre um arquivo existente.

O primeiro exemplo mostra a adição do texto. Como vemos, o novo texto é adicionado na linha seguinte:

$ echo "Hello to you too!" >> text
$ cat text
Hello!
Hello to you too!

O segundo exemplo demonstra que um novo arquivo será criado:

$ echo "Hello to you too!" >> text2
$ cat text2
Hello to you too!

Redirecionando o erro padrão

Para redirecionar apenas as mensagens de erro, o administrador do sistema precisará usar o operador 2> seguido pelo nome do arquivo no qual os erros serão escritos. Se o arquivo não existir, um novo será criado; caso contrário, o arquivo será sobrescrito.

Como explicado, o canal para redirecionar o erro padrão é o canal 2. Ao redirecionar o erro padrão, o canal deve ser especificado, ao contrário da outra saída padrão, em que o canal 1 já está definido a princípio. O comando no exemplo a seguir procura por um arquivo ou diretório chamado games e escreve apenas o erro no arquivo text-error, enquanto exibe a saída padrão na tela:

$ find /usr games 2> text-error
/usr
/usr/share
/usr/share/misc
---------Omitted output----------
/usr/lib/libmagic.so.1.0.0
/usr/lib/libdns.so.81
/usr/games
$ cat text-error
find: `games': No such file or directory

Note	Para saber mais sobre o comando `find`, consulte a página de manual correspondente.

O comando do exemplo a seguir será executado sem erros e, portanto, nenhuma informação será gravada no arquivo text-error:

$ sort /etc/passwd 2> text-error
$ cat text-error

Além da saída padrão, o erro padrão também pode ser incluído em um arquivo com o operador 2 >>. Isso adicionará o novo erro no final do arquivo. Se o arquivo não existir, um novo será criado. O primeiro exemplo mostra a adição das novas informações ao arquivo. O segundo exemplo mostra que o comando cria um novo arquivo quando um arquivo existente com o mesmo nome não pode ser encontrado:

$ sort /etc 2>> text-error
$ cat text-error
sort: read failed: /etc: Is a directory

$ sort /etc/shadow 2>> text-error2
$ cat text-error2
sort: open failed: /etc/shadow: Permission denied

Usando esse tipo de redirecionamento, apenas as mensagens de erro serão redirecionadas para o arquivo; a saída normal será escrita na tela ou passará pela saída padrão ou stdout.

Existe um arquivo em particular que tecnicamente é um bit bucket (um arquivo que aceita entrada e não faz nada com ela): /dev/null. É possível redirecionar para lá qualquer informação irrelevante que não precise ser exibida ou redirecionada para um arquivo importante, como mostrado no exemplo abaixo:

$ sort /etc 2> /dev/null

Redirecionando a entrada padrão

Esse tipo de redirecionamento é usado para inserir dados em um comando a partir de um arquivo especificado em vez de um teclado. Nesse caso, o operador < é usado, como no exemplo abaixo:

$ cat < text
Hello!
Hello to you too!

Em geral, redirecionamos a entrada padrão com comandos que não aceitam argumentos de arquivo. O comando tr é um deles. Esse comando pode ser usado para traduzir o conteúdo do arquivo modificando as palavras de maneira específica, como por exemplo a exclusão de um determinado caractere. O exemplo abaixo mostra a exclusão do caractere l:

$ tr -d "l" < text
Heo!
Heo to you too!

Para saber mais, consulte a página de manual do tr.

Here documents

Ao contrário dos redirecionamentos de saída, o operador << age de maneira diferente em comparação com os outros operadores. Esse fluxo de entrada também é chamado de here document. O here document representa o bloco de código ou texto que pode ser redirecionado para o comando ou o programa interativo. Diferentes tipos de linguagens de script, como bash, sh e csh, podem receber entradas diretamente da linha de comando, sem usar nenhum arquivo de texto.

Como vemos no exemplo abaixo, o operador é usado para inserir dados no comando, ao passo que a palavra que vem depois não especifica o nome do arquivo. A palavra é interpretada como o delimitador da entrada e não será levada em consideração como conteúdo; portanto, o cat não a exibirá:

$ cat << hello
> hey
> ola
> hello
hey
ola

Consulte a página de manual do comando cat para saber mais.

Combinações

A primeira combinação de que trataremos combina o redirecionamento da saída padrão e o da saída de erro padrão para o mesmo arquivo. Os operadores &> e &>> são usados: & representa a combinação do canal 1 e do canal 2. O primeiro operador substituirá o conteúdo existente no arquivo e o segundo incluirá ou adicionará as novas informações ao final do arquivo. Ambos os operadores permitem a criação de um novo arquivo se já não existir um, como nas seções anteriores:

$ find /usr admin &> newfile
$ cat newfile
/usr
/usr/share
/usr/share/misc
---------Omitted output----------
/usr/lib/libmagic.so.1.0.0
/usr/lib/libdns.so.81
/usr/games
find: `admin': No such file or directory
$ find /etc/calendar &>> newfile
$ cat newfile
/usr
/usr/share
/usr/share/misc
---------Omitted output----------
/usr/lib/libmagic.so.1.0.0
/usr/lib/libdns.so.81
/usr/games
find: `admin': No such file or directory
/etc/calendar
/etc/calendar/default

Vamos ver um exemplo que usa o comando cut:

$ cut -f 3 -d "/" newfile
$ cat newfile

share
share
share
---------Omitted output----------
lib
games
find: `admin': No such file or directory
calendar
calendar
find: `admin': No such file or directory

O comando cut corta campos especificados do arquivo de entrada usando a opção -f, o terceiro campo em nosso caso. Para que o comando encontre o campo, um delimitador também deve ser especificado com a opção -d. Em nosso caso, o delimitador será o caractere /.

Para saber mais sobre o comando cut, consulte a página man correspondente.

Pipes na linha de comando

O redirecionamento é usado principalmente para armazenar o resultado de um comando a ser processado por um comando diferente. Esse tipo de processo intermediário pode se tornar tedioso e complicado quando os dados precisam passar por múltiplos processos. Para evitar isso, podemos vincular o comando diretamente usando pipes. Em outras palavras, a saída do primeiro comando se torna automaticamente a entrada do segundo comando. Essa conexão é feita usando o operador | (barra vertical):

$ cat /etc/passwd | less
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
:

No exemplo acima, o comando less, após o operador pipe, modifica a maneira como o arquivo é exibido. O comando less exibe o arquivo de texto, permitindo ao usuário rolar uma linha por vez para cima e para baixo.less também é usado por padrão para exibir as páginas de manual, conforme discutido nas lições anteriores.

É possível empregar várias pipes ao mesmo tempo. Os comandos intermediários que recebem uma entrada, a alteram e produzem uma saída são chamados de filtros. Vamos pegar o comando ls -l e tentar contar o número de palavras das 10 primeiras linhas da saída. Para isso, teremos de usar o comando head que, por padrão, exibe as 10 primeiras linhas de um arquivo, e em seguida contar as palavras usando o comando wc:

$ ls -l | head | wc -w
10

Como já mencionado, por padrão, o head exibe apenas as 10 primeiras linhas do arquivo de texto especificado. Esse comportamento pode ser modificado usando opções específicas. Verifique a página man do comando para saber mais.

Existe outro comando para exibir o final de um arquivo: tail. Por padrão, esse comando seleciona as últimas 10 linhas e as exibe, mas, como em head, esse número também pode ser modificado. Verifique a página de manual de tail para mais detalhes.

Note	A opção `-f` mostra as últimas linhas de um arquivo enquanto ele está sendo atualizado. Esse recurso pode ser muito útil ao se monitorar a atividade em andamento em um arquivo como o `syslog`.

O comando wc (contagem de palavras) conta por padrão as linhas, palavras e bytes de um arquivo. Como mostrado no exercício, a opção -w faz com que o comando conte apenas as palavras dentro das linhas selecionadas. As opções mais comuns desse comando são: -l, que especifica que o comando deve contar apenas as linhas, e -c, usado para contar apenas os bytes. Mais variações e opções do comando, bem como informações sobre o wc, podem ser encontradas na página de manual do comando.

Exercícios Guiados

Liste o conteúdo do diretório atual, incluindo o proprietário e as permissões, e redirecione a saída para um arquivo chamado contents.txt dentro de seu diretório inicial.
Ordene o conteúdo do arquivo contents.txt a partir do diretório atual e inclua esse conteúdo ordenado no final de um novo arquivo chamado contents-sorted.txt
Exiba as últimas 10 linhas do arquivo /etc/passwd e redirecione-as para um novo arquivo no diretório Documents do seu usuário.
Conte o número de palavras no arquivo contents.txt e inclua a saída ao final de um arquivo chamado field2.txt em seu diretório inicial. Você precisará usar redirecionamentos de entrada e de saída.
Exiba as 5 primeiras linhas do arquivo /etc/passwd e classifique a saída em ordem alfabética reversa.
Usando o arquivo contents.txt criado anteriormente, conte o número de caracteres das últimas 9 linhas.
Conte o número de arquivos chamados test no diretório /usr/share e em seus subdiretórios. Nota: cada linha da saída do comando find representa um arquivo.

Exercícios Exploratórios

Selecione o segundo campo do arquivo contents.txt e redirecione a saída padrão e a saída de erro para outro arquivo chamado field1.txt.
Usando o operador de redirecionamento de entrada e o comando tr, exclua os hífens (-) do arquivo contents.txt.
Qual é a maior vantagem de redirecionar apenas os erros para um arquivo?
Substitua todos os espaços repetidos no arquivo contents.txt classificado em ordem alfabética por um único espaço.
Em uma linha de comando, elimine os espaços repetidos (como feito no exercício anterior), selecione o nono campo e ordene-o em ordem alfabética reversa e sem distinção entre maiúsculas e minúsculas. Quantos pipes você teve de usar?

Resumo

Nesta lição, você aprendeu:

Tipos de redirecionamento
Como usar os operadores de redirecionamento
Como usar pipes pra filtrar a saída dos comandos

Comandos usados nesta lição:

cut: Remove seções de cada linha de um arquivo.
cat: Exibe ou concatena arquivos.
find: Busca por arquivos em uma hierarquia de diretórios.
less: Exibe um arquivo, permitindo que o usuário role uma linha por vez.
more: Exibe um arquivo, uma página por vez.
head: Exibe as primeiras 10 linhas de um arquivo.
tail: Exibe as últimas 10 linhas de um arquivo.
sort: Classifica os arquivos.
wc: Conta por padrão as linhas, palavras ou bytes de um arquivo.

Respostas aos Exercícios Guiados

Liste o conteúdo do diretório atual, incluindo o proprietário e as permissões, e redirecione a saída para um arquivo chamado contents.txt dentro de seu diretório inicial.
```
$ ls -l > contents.txt
```
Ordene o conteúdo do arquivo contents.txt a partir do diretório atual e inclua esse conteúdo ordenado no final de um novo arquivo chamado contents-sorted.txt
```
$ sort contents.txt >> contents-sorted.txt
```
Exiba as últimas 10 linhas do arquivo /etc/passwd e redirecione-as para um novo arquivo no diretório Documents do seu usuário.
```
$ tail /etc/passwd > Documents/newfile
```
Conte o número de palavras no arquivo contents.txt e inclua a saída no final de um arquivo chamado field2.txt em seu diretório inicial. Você precisará usar redirecionamentos de entrada e de saída.
```
$ wc < contents.txt >> field2.txt
```
Exiba as 5 primeiras linhas do arquivo /etc/passwd e classifique a saída em ordem alfabética reversa.
```
$ head -n 5 /etc/passwd | sort -r
```
Usando o arquivo contents.txt criado anteriormente, conte o número de caracteres das últimas 9 linhas.
```
$ tail -n 9 contents.txt | wc -c
531
```
Conte o número de arquivos chamados test no diretório /usr/share e em seus subdiretórios. Nota: cada linha da saída do comando find representa um arquivo.
```
$ find /usr/share -name test | wc -l
125
```

Respostas aos Exercícios Exploratórios

Selecione o segundo campo do arquivo contents.txt e redirecione a saída padrão e a saída de erro para outro arquivo chamado field1.txt.
```
$ cut -f 2 -d " " contents.txt &> field1.txt
```
Usando o operador de redirecionamento de entrada e o comando tr, exclua os hífens (-) do arquivo contents.txt.
```
$ tr -d "-" < contents.txt
```
Qual é a maior vantagem de redirecionar apenas os erros para um arquivo?

O redirecionamento dos erros para um arquivo ajuda a manter um arquivo de log monitorado com frequência.
Substitua todos os espaços repetidos no arquivo contents.txt classificado em ordem alfabética por um único espaço.
```
$ sort contents.txt | tr -s " "
```
Em uma linha de comando, elimine os espaços repetidos (como feito no exercício anterior), selecione o nono campo e ordene-o em ordem alfabética reversa e sem distinção entre maiúsculas e minúsculas. Quantos pipes você teve de usar?
```
$ cat contents.txt | tr -s " " | cut -f 9 -d " " | sort -fr
```
O exercício usa 3 pipes, um para cada filtro.