Tira Gosto

Shell em pedaços pequenos e gostosos

---

Em construção para sempre

---

Esta página, apesar de estar no escopo do Papo de Botequim, nunca foi publicada na Linux Magazine. Trata-se de artigos que escrevi para outras mídias, dicas úteis que li pela internet afora (e neste caso com os devidos créditos), contribuições deste pessoal do Software Livre, maravilhoso e sempre pronto a ajudar e da imperdível Lista de Shell Script

---

---

Passando parâmetros com xargs

Existe um comando, cuja função primordial é construir listas de parâmetros e passá-la para a execução de outros programas ou instruções. Este comando é o xargs e deve ser usado da seguinte maneira:

    xargs [comando [argumento inicial]]

xargs combina o argumento inicial com os argumentos recebidos da entrada padrão, de forma a executar o comando especificado uma ou mais vezes.

Exemplo:

Vamos procurar em todos os arquivos abaixo de um determinado diretório uma cadeia de caracteres usando o comando find com a opção -type f para pesquisar somente os arquivos normais, desprezando diretórios, arquivos especiais, arquivos de ligações, etc, e vamos torná-la mais genérica recebendo o nome do diretório inicial e a cadeia a ser pesquisada como parâmetros. Para isso fazemos:

Na execução deste script procuramos, a partir do diretório definido na variável $1, todos os arquivos que continham a cadeia definida na variável $2.

Exatamente a mesma coisa poderia ser feito se a linha do programa fosse a seguinte:

    find $1 -type f -exec grep -l "$2" {} \;

O primeiro processo tem duas grandes desvantagens sobre o anterior:

• A primeira é bastante visível: o tempo de execução deste método é muito superior ao daquele, isso porque o grep será feito em cada arquivo que lhe for passado pelo find, um-a-um, ao passo que com o xargs, será passada toda, ou na pior das hipóteses, a maior parte possível, da lista de arquivos gerada pelo find;

• Dependendo da quantidade de arquivos encontrados que atendem ao find, poderemos ganhar aquela famosa e fatídica mensagem de erro Too many arguments indicando um estouro da pilha de execução do grep. Como foi dito no item anterior, se usarmos o xargs ele passará para o grep a maior quantidade de parâmetros possível, suficiente para não causar este erro, e caso necessário executará o grep mais de uma vez.

Vamos agora analisar um exemplo que é mais ou menos o inverso deste que acabamos de ver. Desta vez, vamos fazer um script para remover todos os arquivos do diretório corrente, pertencentes a um determinado usuário.

A primeira idéia que surge é, como no caso anterior, usar um comando find, da seguinte maneira:

    find . -user cara -exec rm -f {} \;

Quase estaria certo, o problema é que desta forma você removeria não só os arquivos do cara no diretório corrente, mas também de todos os outros subdiretórios "pendurados" neste. Vejamos então como fazer:

    ls -l | grep " cara " | cut -c55- | xargs rm

Desta forma, o grep selecionou os arquivos que continham a cadeia cara no diretório corrente listado pelo ls -l. O comando cut pegou somente o nome dos arquivos, passando-os para a remoção pelo rm usando o comando xargs como ponte

O xargs é também uma excelente ferramenta de criação de one-liners (scripts de somente uma linha). Veja este para listar todos os donos de arquivos (inclusive seus links) "pendurados" no diretório /bin e seus subdiretórios.

Muitas vezes o /bin é um link (se não me engano, no Solaris o é) e a opção -follows obriga o find a seguir o link. O comando xargs alimenta o ls -al e a seqüência de comandos seguinte é para pegar somente o 3º campo (dono) e classificá-lo devolvendo somente uma vez cada dono (opção -u do comando sort, que equivale ao comando uniq).

Opções do xargs

Você pode usar as opções do xargs para construir comandos extremamente poderosos.

Opção -i

Para exemplificar isso e começar a entender as principais opções desta instrução, vamos supor que temos que remover todos as arquivos com extensão .txt sob o diretório corrente e apresentar os seus nomes na tela. Veja o que podemos fazer:

A opção -i do xargs troca pares de chaves ({}) pela cadeia que está recebendo pelo pipe (|). Então neste caso as chaves ({}) serão trocadas pelos nomes dos arquivos que satifaçam ao comando find.

Opção -n

Olha só a brincadeira que vamos fazer com o xargs:

Quando mandamos a saída do ls para o arquivo usando o xargs, comprovamos o que foi dito anteriormente, isto é, o xargs manda tudo que é possível (o suficiente para não gerar um estouro de pilha) de uma só vez. Em seguida, usamos a opção -n 1 para listar um por vez. Só para dar certeza veja o exemplo a seguir, quando listaremos dois em cada linha:

Mas a linha acima poderia (e deveria) ser escrita sem o uso de pipe (|), da seguinte forma:

Opção -p

Outra opção legal do xargs é a -p, na qual o sistema pergunta se você realmente deseja executar o comando. Digamos que em um diretório você tenha arquivos com a extensão .bug e .ok, os .bug estão com problemas que após corrigidos são salvos como .ok. Dá uma olhadinha na listagem deste diretório:

Para comparar os arquivos bons com os defeituosos, fazemos:

Opção -t

Para finalizar, o xargs também tem a opção -t, onde vai mostrando as instruções que montou antes de executá-las. Gosto muito desta opção para ajudar a depurar o comando que foi montado.

Resumo

Então podemos resumir o comando de acordo com a tabela a seguir:

-t	Mostra a linha de comando montada antes de executá-la
Opção	Ação
-i	Substitui o par de chaves ({}) pelas cadeias recebidas
-nNum	Manda o máximo de parâmetros recebidos, até o máximo de Num para o comando a ser executado
-lNum	Manda o máximo de linhas recebidas, até o máximo de Num para o comando a ser executado
-p	Mostra a linha de comando montada e pergunta se deseja executá-la

Here Strings

Primeiro um programador com complexo de inferioridade criou o redirecionamento de entrada e representou-o com um sinal de menor (<) para representar seus sentimento. Em seguida, outro sentindo-se pior ainda, criou o here document representando-o por dois sinais de menor (<<) porque sua fossa era maior. O terceiro, pensou: "estes dois não sabem o que é estar por baixo"... Então criou o here strings representado por três sinais de menor (<<<).

Brincadeiras a parte, o here strings é utilíssimo e, não sei porque, é um perfeito desconhecido. Na pouquíssima literatura que há sobre o tema, nota-se que o here strings é freqüentemente citado como uma variante do here document, teoria com a qual discordo pois sua aplicabilidade é totalmente diferente daquela. Sua sintaxe é simples:

    $ comando <<< $cadeia

Onde cadeia é expandida e alimenta a entrada primária (stdin) de comando.

Como sempre, vamos direto aos exemplos dos dois usos mais comuns para que vocês próprios tirem suas conclusões.

• Uso #1. Substituindo a famigerada construção echo "cadeia" | comando, que força um fork, criando um subshell e onerando o tempo de execução.

Exemplos:

Para mostrar a melhoria no desempenho, vamos fazer um loop de 500 vezes usando o exemplo dados para o comando tr: Veja agora esta seqüência de comandos com medidas de tempo:

Veja agora esta seqüência de comandos com medidas de tempo:

Observando este quadro você verá que no primeiro usamos a forma convencional, no segundo usamos um named pipe temporário para executar uma substituição de processos e no terceiro usamos here strings. Notará também que ao contrário do exemplo anterior, aqui o uso de here strings não foi o mais veloz. Mas repare bem que neste último caso o comando who está sendo executado em um subshell e isso onerou o processo como um todo.

Vejamos uma forma rápida de inserir uma linha como cabeçalho de um arquivo:

• Uso #2. Outra forma legal de usar o here strings é casando-o com um comando read, não perdendo de vista o que aprendemos sobre IFS (veja aqui, na explicação do comando for). O comando cat com as opções -vet mostra o <ENTER> como $, o <TAB> como ^I e os outros caracteres de controle com a notação ^L onde L é uma letra qualquer. Vejamos então o conteúdo de uma variável e depois vamos ler cada um de seus campos:

Exemplos:

Também podemos ler direto para um vetor (array) veja:

Rotatório Peczenyj

Julio descobri uma forma para o Shell criar combinaçãoes fazendo rotação com os elementos estipulados. Podemos gerar todos os binários de 0000 a 1111 da seguinte forma:

Uma aplicação pratica que vejo é para combinar valores diferentes sem ter que encadear loops nem usar o seq

Neste caso eu combinei os números de 1 a 3 eliminando repetições com o grep. Usei um tr 'podre' para melhor tratar os dados, saltando linha.

O grep é simples como você pode notar, eu vejo se uma determinada parte da combinação (.+?(\b[0-9]+\b).+?) existe em outra parte (\1), se existe eu não deixo imprimir por causa da opção -v, assim

    1 1 2
    1 2 1
    1 1 1

não serão impressos.

Agora vai o meu exemplo: o one-liner a seguir gerará todas as permissões possíveis (em octal) para o arquivo arq (o exemplo foi interrompido porque existem 512 combinações de permissões possíveis).

Vamos ver este exemplo passo-a-passo para entendê-lo:

A seguir o xargs (clique para dicas do xargs) executa o comando bash -c (que serve para executar uma linha de comandos) que por sua vez executa o chmod e o ls -l para mostrar que as permissões estão sendo alteradas.

Aritmética em Shell

Antigamente usávamos o comando expr para fazer operações aritméticas e muita gente ainda usa, pois é compatível com quaquer ambiente.

Exemplo:

Neste artigo porém, vamos ver outras formas não tanto conhecidas, porém mais simples de usar, mais elaboradas e com precisão maior.

O uso do bc

Uma forma bacana de fazer cálculos em Shell – usada normalmente quando a expressão aritmética é mais complexa, ou quando é necessário trabalharmos com casas decimais – é usar a instrução calculadora do UNIX/LINUX. O bc. Veja como:

Exemplo:

Para trabalhar com números reais (números não necessariamente inteiros), especifique a precisão (quantidade de decimais) com a opção scale do comando bc. Assim vejamos o penúltimo exemplo:

Outros exemplos:

Obviamente todos os exemplos acima no caso de linux, poderiam (e deveriam) ser escritos usando Here Strings. Veja os últimos como ficariam:

Uma vez apareceu na lista (excelente por sinal) de Shell script no Yahoo (http://br.groups.yahoo.com/group/shell-script/) um cara com a seguinte dúvida: "eu tenho um arquivo cujos campos estão separados por <TAB> e o terceiro deles possui números. Como posso calcular a soma de todos os números desta coluna do arquivo?"

Mandei a seguinte resposta:

Vamos por partes para entender melhor e primeiramente vamos ver como era o arquivo que fiz para teste:

Como pode-se ver, está dentro do padrão do problema, onde eu tenho como terceiro campo números reais. Vamos ver o que faria a primeira parte da linha de comandos, onde eu transformo os caracteres <ENTER> (new-line) em um sinal de mais (+):

Se eu mandasse desse jeito para o bc, ele me devolveria um erro por causa daquele sinal de mais (+) solto no final do texto. A minha saída foi colocar um zero no final, pois somando zero o resultado não se alterará. Vamos ver então como ficou:

Isso é o que se costuma chamar one-liner, isto é, códigos que seriam complicados em outras linguagens (normalmente seria necessário criar contadores e fazer um loop de leitura somando o terceiro campo ao contador) e em Shell são escritos em uma única linha.

Há também gente que chama isso de método KISS, que é o acrônimo de Keep It Simple Stupid.

Mas o potencial de uso desta calculadora não se encerra aí, existem diversas facilidades por ela propiciadas. Veja só este exemplo:

Nestes exemplos vimos como fazer mudanças de base de numeração com o uso do bc. Na primeira explicitamos a base de saída (obase) como 16 (hexadecimal) e na segunda, dissemos que a base da entrada (ibase) era 10 (decimal).

Outras formas de trabalhar com inteiros

Outra forma muito legal de fazer cálculos é usar a notação $((exp aritmética)). É bom ficar atento, porém, ao fato desta sintaxe não ser universalizada. O Bourne Shell (sh), por exemplo, não a reconhece.

Exemplo:

Usando o mesmo exemplo que já havíamos usado:

Agora olha só esta maluquice:

Ué!! Não é o cifrão ($) precedente que caracteriza uma variável? Sim, porém em todos os sabores UNIX que testei, sob bash ou ksh, ambas as formas de construção produzem uma boa aritmética.

Preste a atenção nesta seqüência:

Repare que apesar da variável não estar definida, pois foi feito um unset nela, nenhum dos comandos acusou erro, porque, como estamos usando construções aritméticas, sempre que uma variável não existe, é inicializada com zero (0).

Repare que o i++ produziu zero (0). Isto ocorre porque este tipo de construção chama-se pós-incrementação, isto é, primeiramente o comando é executado e só então a variável é incrementada. No caso do ++i, foi feita uma pré-incrementação: primeiro incrementou e somente após o comando foi executado.

Também são válidos:

Estas três operações seriam o mesmo que:

    i=$((i+3))
    i=$((i*3))
    i=$((i%2))

E isto seria válido para todos os operadores aritméticos o que em resumo produziria a tabela a seguir:

Expansão Aritmética
||	OU lógico
Expressão	Resultado
id++ id--	pós-incremento e pós-decremento de variáveis
++id -–id	pré-incremento e pré-decremento de variáveis
**	exponenciação
* / %	multiplicação, divisão, resto da divisão
+ -	adição, subtração
<= >= < >	comparação
== !=	igualdade, desigualdade
&&	E lógico

Mas o auge desta forma de construção com duplo parênteses é o seguinte:

Este tipo de construção deve ser lido da seguinte forma: caso a variável var seja maior que 40 (var>40), então (?) faça var igual a var menos 40 (var-40), senão (:) faça var igual a var mais 40 (var+40). O que quis dizer é que os caracteres ponto-de-interrogação (?) e dois-pontos (:) fazem o papel de "então" e "senão", servindo desta forma para montar uma operação aritmética condicional.

Da mesma forma que usamos a expressão $((...)) para fazer operações aritméticas, também poderíamos usar a intrínseca (built-in) let ou construção do tipo $[...].

Os operadores são os mesmos para estas três formas de construção, o que varia um pouco é a operação aritmética condicional com o uso do let. Vejamos como seria:

Baseando

Se você quiser trabalhar com bases diferentes da decimal, basta usar o formato:

    base#numero

Onde base é um número decimal entre 2 e 64 representando o sistema de numeração, e numero é um número no sistema numérico definido por base. Se base# for omitida, então 10 é assumida como default. Os algarismos maiores que 9 são representados por letras minúsculas, maiúsculas, @ e _, nesta ordem.

Se base for menor ou igual a 36, maiúsculas ou minúsculas podem ser usadas indiferentemente para definir algarismos maiores que 9 (não está mal escrito, os algarismos do sistema hexadecimal, por exemplo, variam entre 0 (zero) e F). Vejamos como isso funciona:

Nestes exemplos usei as notações $((...)) e $[...] indistintamente, para demonstrar que ambas funcionam.

Funciona também uma mudança automática para a base decimal, desde que você esteja usando a convenção numérica do C, isto é, em 0xNN, o NN será tratado como um hexadecimal e em 0NN, o NN será visto como um octal. Veja o exemplo:

Exemplo

Ah, já ia me esquecendo! As expressões aritméticas com os formatos $((...)), $[...] e com o comando let usam os mesmos operadores usados na instrução expr, além dos operadores unários (++, --, +=, *=, ...) e condicionais que acabamos de ver.

Testes usando expressões regulares

No Papo de Botequim 004, nós falamos tudo sobre comandos condicionais, mas faltou um que não existia àquela época. Neste mesmo Papo de Botequim, na seção E tome de test nós chegamos a falar de uma construção do tipo:

    [[ Expressao ]] && cmd

Onde o comando cmd será executado caso a expressão condicional Expressao seja verdadeira. Disse ainda que Expressao poderia ser estipulada de acordo com as regras de Geração de Nome de Arquivos (File Name Generation). A partir do bash versão 3, foi incorporado a esta forma de teste um operador representado por =~, cuja finalidade é fazer comparações com Expressões Regulares.

Exemplo:

Vamos dar uma esmiuçada na Expressão Regular ^(Governa|Sena|Verea)dora?$: ela casa com tudo que começa (^) por Governa, ou (|) Sena, ou (|) Verea, seguido de dor e seguido de um a opcional (?). O cifrão ($) serve para marcar o fim. Em outras palavras esta Expressão Regular casa com Governador, Senador, Vereador, Governadora, Senadora e Vereadora.

Colorindo a tela

Como você já havia visto no Papo de Botequim 007, o comando tput serve para fazer quase tudo referente a formatação de tela, mas o que não foi dito é que com ele também pode-se usar cores de frente (dos caracteres) e de fundo. Existem também outras formas de fazer o mesmo, acho porém, esta que veremos agora, mais intuitiva (ou menos “desintuitiva”). A tabela a seguir mostra os comandos para especificarmos os padrões de cores de frente (foreground) ou de fundo (background):

Obtendo cores com o comando tput
tput setab n	Especifica n como a cor de fundo (background)
Comando	Efeito
tput setaf n	Especifica n como a cor de frente (foreground)

Bem, agora você já sabe como especificar o par de cores, mas ainda não sabe as cores. A tabela a seguir mostra os valores que o n (da tabela anterior) deve assumir para cada cor:

Valores das cores com o comando tput
7	Cinza claro
Valor	Cor
0	Preto
1	Vermelho
2	Verde
3	Marrom
4	Azul
5	Púrpura
6	Ciano

Neste ponto você já pode começar a brincar com as cores.

- Mas peraí, ainda são muito poucas!

- É, tem toda razão... O problema é que ainda não lhe disse que se você colocar o terminal em modo de ênfase (tput bold), estas cores geram outras oito. Vamos montar então a tabela definitiva de cores:

Valores das cores com o comando tput
7	Cinza claro	Branco
Valor	Cor	Cor após tput bold
0	Preto	Cinza escuro
1	Vermelho	Vermelho claro
2	Verde	Verde claro
3	Marron	Amarelo
4	Azul	Azul Brilhante
5	Púrpura	Rosa
6	Ciano	Ciano claro

Exemplo

Como exemplo, vejamos um script que mudará a cor de sua tela de acordo com sua preferência.

Ganhando o jogo com mais coringas

Estava eu lendo meus e-mails quando recebo um do Tiago enviado para a lista de Shell Script (já falei da lista e do Tiago no Rotatório Peczenyj). A seguir o conteúdo do e-mail:

Não sei se é conhecimento de todos mas o shell possui, alem do globbing normal (a expansão *, ? e [a-z] de nomes de arquivos e diretórios), um globbing extendido.

Acho que, em alguns casos, podera ser BEM util, eliminando um pipe para um grep por exemplo.

São eles:

    ?(padrao)

Casa zero ou uma ocorrência de um determinado padrao

    *(padrao)

Casa zero ou mais ocorrências de um determinado padrao

    +(padrao)

Casa uma ou mais ocorrências de um determinado padrao

    @(padrao)

Casa com exatamente uma ocorrência de um determinado padrao

    !(padrao)

Casa com qualquer coisa, exceto com padrao

Para poder utilizá-lo precisa executar o shopt conforme o exemplo abaixo:

Usando o awk para pesquisar por equivalência

Aí vai mais uma que o Tiago mandou para a lista de Shell Script do Yahoo (já falei da lista e do Tiago no Rotatório Peczenyj e no Ganhando o jogo com mais coringa)

Quem ja não passou por isso: Procurar uma palavra, porém uma letra acentuada, ou não, atrapalhou a busca?

Não descobri como fazer o grep ou sed aceitarem algo semelhante, mas o gawk aceita classes de equivalência!

Melhor explicar com um exemplo, onde vou listar o número da linha e a ocorrência casada:

Ou seja, usar [=X=] permite que a expressão encontre a letra X estando acentuada ou não (é sensivel à localização corrente!).

A sintaxe é parecida com a das classes POSIX, trocando os dois-pontos (:) antes e depois da classe por sinais de igual (=).

Achei curioso e deve servir para algum caso semelhante ao descrito.

find – Procurando arquivo por características

Se você está como o Mr. Magoo, procurando em vão um arquivo, use o comando find que serve para procurar arquivos não só pelo nome, como por diversas outras características. Sua sintaxe é a seguinte:

    find [caminho ...] expressão [ação]

Parâmetros:

caminho      Caminhos de diretório a partir do qual (porque ele é recursivo, sempre tentará entrar pelos subdiretórios "pendurados" neste) irá procurar pelos arquivos;
expressão   Define quais critérios de pesquisa. Pode ser uma combinação entre vários tipos de procura;
ação           Define que ação executar com os arquivos que atender aos critérios de pesquisa definidos por expressão.

Os principais critérios de pesquisa definidos por expressão são:

-name	Procura arquivos que tenham o nome especificado. Aqui podem ser usados metacaracteres ou caracteres curingas, porém estes caracteres deverão estar entre aspas, apóstrofos ou imediatamente precedidos por uma contrabarra isso porque quem tem de expandir os coringas é o find. Se fosse o Shell que os expandisse, isto seria feito somente com relação ao diretório corrente, o que jogaria por terra a característica recursiva do find;
-user	Procura arquivos que tenham usuário como dono;
-group	Procura arquivos que tenham grupo como grupo dono;
-type c	Procura por arquivos que tenham o tipo c, correspondente à letra do tipo do arquivo. Os tipos aceitos estão na tabela a seguir:
	Valores de c	Tipo de arquivo procurado
	b	Arquivo especial acessado a bloco
	c	Arquivo especial acessado a caractere
	d	Diretório
	p	Named pipe (FIFO)
	f	Arquivo normal
	l	Link simbólico
	s	Socket
-size ±n[unid]	Procura por arquivos que usam mais (+n) de n unidades unid de espaço ou a menos (-n) de n unidades unid de espaço.
	Unidades	Valor
	b	Bloco de 512 bytes (valor default)
	c	Caracteres
	k	Kilobytes (1024 bytes)
	w	Palavras (2 bytes)
-atime ±d	Procura por arquivos que foram acessados há mais (+d) de d dias ou a menos (-d) de d dias;
-ctime ±d	Procura por arquivos cujo status mudou há mais (+d) de d dias ou a menos (-d) de d dias;
-mtime ±d	Procura por arquivos cujos dados foram modificados há mais (+d) de d dias ou a menos (-d) de d dias;

Para usar mais de um critério de pesquisa, faça:
     expressão1 expressão2
ou
     expressão1 –a expressão2
para atender aos critérios especificados por expressão1 e expressão2;
     expressão1 –o expressão2
para atender aos critérios especificados por expressão1 ou expressão2.

As principais ações definidas para ação são:

-print	Esta opção faz com que os arquivos encontrados sejam exibidos na tela. Esta é a opção default no Linux. Nos outros sabores Unix que conheço, se nenhuma ação for especificada, ocorrerá um erro;
-exec cmd {} \;	Executa o comando cmd. O escopo de comando é considerado encerrado quando um ponto-e-vírgula (;) é encontrado. A cadeia {} é substituída pelo nome de cada arquivo que satisfaz ao critério de pesquisa e a linha assim formada é executada. Assim como foi dito para a opção –name, o ponto-e-vírgula (;) deve ser precedido por uma contrabarra (\), ou deve estar entre aspas ou apóstrofos;
-ok cmd {} \;	O mesmo que o anterior porém pergunta se pode executar a instrução cmd sobre cada arquivo que atende ao critério de pesquisa;
-printf formato	Permite que se escolha os campos que serão listados e formata a saída de acordo com o especificado em formato.

Exemplos:

Para listar na tela (-print) todos os arquivos, a partir do diretório corrente, terminados por .sh, faça:

Preciso abrir espaço em um determinado file system com muita urgência, então vou remover arquivos com mais de um megabyte e cujo último acesso foi há mais de 60 dias. Para isso, vou para este file system e faço:

Repare que no exemplo acima usei três critérios de pesquisa, a saber:

-type f	Todos os arquivos regulares (normais)
-size +1000000c	Tamanho maior do que 1000000 de caracteres (+1000000c)
-atime +60	Último acesso há mais de 60 (+60) dias.

Repare ainda que entre estes três critérios foi usado o conector e, isto é, arquivos regulares e maiores que 1MByte e sem acesso há mais de 60 dias.

Para listar todos os arquivos do disco terminados por .sh ou .txt, faria:

Neste exemplo devemos salientar além das contrabarras (\) antes dos asteriscos (*), o uso do –o para uma ou outra extensão e que o diretório inicial era o raiz (/); assim sendo, esta pesquisa deu-se no disco inteiro (o que freqüentemente é bastante demorado).

Com o printf é possível formatar a saída do comando find e especificar os dados desejados. A formatação do printf é muito semelhante à do mesmo comando na linguagem C e interpreta caracteres de formatação precedidos por um símbolo de percentual (%). Vejamos seus efeitos sobre a formatação:

Caractere	Significado
%U	Número do usuário (UID) do dono do arquivo
%f	Nome do arquivo (caminho completo não aparece)
%F	Indica a qual tipo de file system o arquivo pertence
%g	Grupo ao qual o arquivo pertence
%G	Grupo ao qual o arquivo pertence (GID- Numérico)
%h	Caminho completo do arquivo (tudo menos o nome)
%i	Número do inode do arquivo (em decimal)
%m	Permissão do arquivo (em octal)
%p	Nome do arquivo
%s	Tamanho do arquivo
%u	Nome de usuário (username) do dono do arquivo

Também é possível formatar datas e horas obedecendo às tabelas a seguir:

Caractere	Significado
%a	Data do último acesso
%c	Data de criação
%t	Data de alteração

Os três caracteres anteriores produzem uma data semelhante ao do comando date.

Veja um exemplo:

Nesse exemplo, o %p foi o responsável por colocar os nomes dos arquivos. Caso fosse omitido, somente as datas seriam listadas. Observe ainda que ao final foi colocado um /n. Sem ele não haveria salto de linha e a listagem anterior seria uma grande tripa.

Essas datas também podem ser formatadas, para isso basta passar as letras da tabela anterior para maiúsculas (%A, %C e %T) e usar um dos formatadores das duas tabelas a seguir:

Tabela de formatação de tempo
Z	Fuso horário (na Cidade Maravilhosa BRST)
Caractere	Significado
H	Hora (00..23)
I	Hora (01..12)
k	Hora (0..23)
l	Hora (1..12)
M	Minuto (00..59)
p	AM or PM
r	Horário de 12 horas (hh:mm:ss) seguido de AM ou PM
S	Segundos (00 ... 61)
T	Horário de 24-horas (hh:mm:ss)

Tabela de formatação de datas
Y	Ano com 4 dígitos
Caractere	Significado
a	Dia da semana abreviado (Dom...Sab)
A	Dia da semana por extenso (Domingo...Sábado)
b	Nome do mês abreviado (Jan...Dez)
B	Dia do mês por extenso (Janeiro...Dezembro)
c	Data e hora completa (Fri Dec 23 15:21:41 2005)
d	Dia do mês (01...31)
D	Data no formato mm/dd/aa
h	Idêntico a b
j	Dia seqüencial do ano (001…366)
m	Mês (01...12)
U	Semana seqüencial do ano. Domingo como 1º dia da semana (00...53)
w	Dia seqüencial da semana (0..6)
W	Semana seqüencial do ano. Segunda-feira como 1º dia da semana (00...53)
x	Representação da data no formato do país (definido por $LC_ALL)
y	Ano com 2 dígitos (00...99)

Para melhorar a situação, vejamos uns exemplos; porém, vejamos primeiro quais são os arquivos do diretório corrente que começam por .b:

Para listar esses arquivos em ordem de tamanho, podemos fazer:

No exemplo que acabamos de ver, o \t foi substituído por um na saída de forma a tornar a listagem mais legível. Para listar os mesmos arquivos classificados por data e hora da última alteração:

Algumas implementações do Bash 4.0

Aqui neste tópico lançarei somente o que é inteiramente novo a partir do Bash 4.0. O que já existia, mas que foi aprimorado a partir desta versão do Bash (como as expansões de parâmetro), está sendo publicado na seção correspondente.

Coprocessos

A partir da versão 4.0, o Bash incorporou o comando coproc. Este novo intrínseco (builtin) permite dois processos assíncronos se comunicarem e interagirem. Como cita Chet Ramey no Bash FAQ, ver. 4.01:

"Há uma nova palavra reservada, coproc, que especifica um coprocesso: um comando assíncrono que é executado com 2 pipes conectados ao Shell criador. coproc pode receber nome. Os descritores dos arquivos de entrada e saída e o PID do coprocesso estão disponíveis para o Shell criador em variáveis com nomes específicos do coproc."

George Dimitriu explica:

"O coproc é uma facilidade usada na substituição de processos que agora está publicamente disponível."

A comprovação do que disse Dimitriu não é complicada, quer ver? Veja a substituição de processos a seguir:

Viu?! O cat não esperou pela conclusão dos comandos entre parênteses, mas foi executado no fim de cada um deles. Isso aconteceu porque estabeleceu-se um pipe temporário/dinâmico e os comandos que estavam sendo executados, mandavam para ele as suas saídas, que por sua vez as mandava para a entrada do cat.

Isso significa que os comandos desta substituição de processos rodaram paralelos, sincronizando somente nas saídas dos echo com a entrada do cat.

A sintaxe de um coprocesso é:

   coproc [nome] cmd redirecionamentos

Isso criará um coprocesso chamado nome. Se nome for informado, cmd deverá ser um comando composto. Caso contrário (no caso de nome não ser informado), cmd poderá ser um comando simples ou composto.

Quando um coproc é executado, ele cria um vetor com o mesmo nome nome no Shell criador. Sua saída padrão é ligada via um pipe a um descritor de arquivo associado à variável ${nome[0]} à entrada padrão do Shell pai (lembra que a entrada padrão de um processo é sempre associada por default ao descritor zero?). Da mesma forma, a entrada do coproc é ligada à saída padrão do script, via pipe, a um descritor de arquivos chamado ${nome[1]}. Assim, simplificando, vemos que o script mandará dados para o coproc pela variável ${nome[0]}, e receberá sua saída em ${nome[1]}. Note que estes pipes serão criados antes dos redirecionamentos especificados pelo comando, já que eles serão as entradas e saídas do coprocesso.

A partir daqui, vou detalhar rapidamente uns estudos que fiz. Isso contém um pouco de divagações e muita teoria. Se você pular para depois desses ls's, não perderá nada, mas se acompanhar, pode ser bom para a compreensão do mecanismo do coproc.

Após colocar um coproc rodando, se ele está associado a um descritor de arquivo, vamos ver o que tem ativo no diretório correspondente:

Hummm, é um link para o /proc/self/fd... O que será que tem lá?

Epa, que o 0, 1 e 2 apontavam para /dev/pts/0 eu já sabia, pois são a entrada padrão, saída padrão e saída de erros padrão apontando para o pseudo terminal corrente, mas quem será esse maldito device 3? Vejamos:

Epa, aí estão os links apontando para os pipes. Esse monte de arquivo de pipe que foi listado, deve ser porque estava testando exaustivamente essa nova facilidade do Bash.

Para terminar esta teoria chata, falta dizer que o PID do Shell gerado para interpretar o coproc pode ser obtido na variável $nome_PID e o comando wait pode ser usado para esperar pelo fim do coprocesso. O código de retorno do coprocesso ($?) é o mesmo de cmd.

Exemplo:

Vamos começar com o mais simples: um exemplo sem nome e direto no prompt:

Como você viu, o vetor COPROC, está associado a dois pipes; o ${COPROC[1]} que contém o endereço do pipe de saída, e por isso a saída do echo esta redirecionada para ele e o ${COPROC[0]} que contém o endereço do pipe de entrada, e por isso usamos a opção -u do read que lê dados a partir de um descritor de arquivo definido, ao invés da entrada padrão.

Como o coprocesso utilizava a sintaxe sem nome, o padrão do nome do vetor é COPROC.

Só mais uma teoriazinha chata:

Como você viu ${COPROC[0]} estava usando o pipe apontado por /proc/$$/fd/59 e ${COPROC[1]} usava /proc/$$/fd/54. Agora chega de teoria mesmo! Vamos agora usar nome neste mesmo exemplo, para ver que pouca coisa muda:

Nesse momento, é bom mostrar uma coisa interessante: Quais são os processos em execução?

Vamos executar 2 coprocessos simultâneos:

Xiiii! Acho que deu zebra! Mas será que deu mesmo? Repare que além do PID 2883 de nome1, ele também me devolveu o PID 2884, que deve ser de nome2. Vamos ver o que está acontecendo:

Parece que foi só um aviso, pois os dois PIDs informados quando iniciamos os dois coprocessos, estão ativos. Então vamos testar esses 2 caras:

Vetores associativos

A partir do Bash 4.0, passou a existir o vetor associativo. Chama-se vetor associativo, aqueles cujos índices são alfabéticos. As regras que valem para os vetores inteiros, valem também para os associativos, porém antes de valorar estes últimos, é obrigatório declará-los.

Exemplo:

Repare que os valores não são ordenados, ficam armazenados na ordem que são criados, diferentemente dos vetores inteiros que ficam em ordem numérica.

Supondo que esse vetor tivesse centenas de elementos, para listar separadamente os domésticos dos selvagens, poderíamos fazer um script assim:

Gostaria de chamar a sua atenção para um detalhe: neste script me referi a um elemento de vetor associativo empregando ${Animais[$Animal]} ao passo que me referi a um elemento de um vetor inteiro usando ${Sel[i]}. Ou seja, quando usamos uma variável como índice de um vetor inteiro, não precisamos prefixá-la com um cifrão ($), ao passo que no vetor associativo, o cifrão ($) é obrigatório.

Lendo um arquivo para um vetor

Ainda falando do Bash 4.0, eis que ele surge com uma outra novidade: o comando intrínseco (builtin) mapfile, cuja finalidade é jogar um arquivo de texto inteiro para dentro de um vetor, sem loop ou substituição de comando.

    - EPA! Isso deve ser muito rápido!

    - E é. Faça os teste e comprove!

Exemplo:

Obteríamos resultado idêntico se fizéssemos:

Porém isso seria mais lento porque a substituição de comando é executada em um subshell. Uma outra forma de fazer isso que logo vem à cabeça é ler o arquivo com a opção -a do comando read. Vamos ver como seria o comportamento disso:

Como deu para perceber, foi lido somente o primeiro registro de frutas.

Vou aproveitar também para mandar o meu jabá: diga para os amigos que quem estiver afim de fazer um curso porreta de programação em Shell que mande um e-mail para a nossa gerencia de treinamento para informar-se.

Qualquer dúvida ou falta de companhia para um chope ou até para falar mal dos políticos é só mandar um e-mail para mim.

Valeu!