RES: [shell-script] Arquivo TXT

[Julio Cezar Neves - DATAPREVRJ]

Fala Tchê,
Como vão as coisas aí nos Pampas? Não tenho certeza se este exemplo está na
4º Edição, mas com certeza está na 5ª, que deve estar chegando nas livrarias
em 30/60 dias. O livro já deve estar com quase 500 páginas (o meu livro é
como eu, não para de crescer (no meu caso para frente e para os lados :( )).

[ ]s,
Julio
:wq

| -----Mensagem original-----
| De: Rodolfo Villanova
| [mailto:address@hidden]
| Enviada em: quarta-feira, 29 de dezembro de 2004 15:51
| Para: address@hidden
| Assunto: RES: [shell-script] Arquivo TXT
| 
| 
| 
| Grande Julio!
| 
| Professor, não encontrei a passagem com esse exemplo bastante 
| ilustrativo
| sobre named pipes na 3a. edição do teu livro Programação 
| Shell - Linux.
| No capítulo "Saco de Gatos" tem alguma coisa sobre o assunto, 
| mas não com
| esse ótimo exemplo apresentado aqui.
| Ele já está "engordando" a + recente edição - é a 4a. ou 5a.?
| Que outras novidades a integram?
| 
| Grande abraço!
| --------------------------
| Rodolfo Gross Villanova
| Telefonica Empresas
| 
| > -----Mensagem original-----
| > De: Julio Cezar Neves - DATAPREVRJ
| > [mailto:address@hidden]
| > Enviada em: quarta-feira, 29 de dezembro de 2004 14:20
| > Para: address@hidden
| > Assunto: RES: [shell-script] Arquivo TXT
| >
| > Falou Beto,
| > é isso aí! A substituição de processos (process 
| substitution) gera a saída
| > de um cmd em um arquivo tipo named pipe temporário. Para 
| constar isso
| > execute o cmd a seguir:
| >
| > Prompt>  ls -l >(cat)
| > l-wx------  1 jneves jneves   64 Dec 29 13:51 /dev/fd/63 -> 
| pipe:[165010]
| >
| > Como alguns cmds (como o paste da dúvida do colega) exigem 
| como entrada
| > arquivos, a substituição de processos foi usada para gerá-los.
| >
| > Abaixo trecho (desformatado) do meu livro que fala sobre o assunto:
| >
| > ===========================================>8CorteAqui8<==========
| > ==========
| > ====================
| > O Shell também usa os named pipes de uma maneira bastante
| > singular. Como já
| > vimos, quando um comando está entre parênteses, ele na realidade
| > é executado
| > em um subshell. Como o Shell atual recebe uma saída única deste
| > subshell, se
| > agruparmos diversos comandos sob um par de parênteses, esta 
| saída poderia
| > ser redirecionada como uma unidade. Por exemplo, o comando:
| > $ (pwd ; ls -l)> saida.out
| >
| > enviará a saída de dois comandos (o pwd e o ls -l) para o arquivo
| > saída.out.
| > Uma substituição de processos (process substitution) ocorre
| > quando você põe
| > um < ou um > grudado na frente do parêntese da esquerda. 
| Teclando-se o
| > comando:
| > $ cat <(ls -l)      O < tem que estar colado no parêntese
| >
| > Resultará no comando ls -l executado em um subshell como é 
| normal, porém
| > redirecionará a saída para um named pipe temporário, que o 
| Shell cria,
| > nomeia e depois remove. Então o cat terá um nome de arquivo
| > válido para ler
| > (que será este named pipe e cujo dispositivo lógico associado é
| > /dev/fd/63),
| > e teremos a mesma saída que a gerada pela listagem do ls -l,
| > porém dando um
| > ou mais passos que o usual. Esta técnica chama-se process 
| substitution ou
| > substituição de processos.
| > Similarmente dando >(comando) resultará no Shell nomeando um pipe
| > temporário
| > do qual o comando dentro dos parênteses lê a entrada.
| > Você deve estar pensando que isto é uma maluquice de nerd, né?
| > Então suponha
| > que você tenha 2 diretórios: dir e dir.bkp e deseja saber 
| se os dois estão
| > iguais (aquela velha dúvida: será que meu backup está 
| atualizado?). Basta
| > comparar os 2 diretórios com o comando cmp, fazendo:
| > $ cmp <(ls -la dir1) <(ls -la dir.bkp)
| >
| > O comando cmp, cuja entrada só aceita arquivos, irá receber 
| a listagem dos
| > dois diretórios como se fossem arquivos (named pipes temporários ou
| > /dev/fd/63), lê-los e compará-los.
| > Outro exemplo:
| > $ echo $impar
| > 1 3 5 7
| > $ echo $par
| > 2 4 6 8
| > $ paste <(echo $impar | tr " " "\012") <(echo $par | tr " " "\012")
| > 1       2
| > 3       4
| > 5       6
| > 7       8
| >
| > No último exemplo, o comando tr transformou os espaços em branco das
| > variáveis impares e pares em <ENTER> (usei a notação octal 
| \012, mas no
| > Linux poderia ter usado \n) e cada um destes grupamentos de 
| comandos gerou
| > um arquivo temporário que pôde ser lido pelo paste.
| > Tanto o tar quanto o bzip2 necessitam de arquivos para 
| serem felizes e
| > executar corretamente as suas atribuições. Então para gerarmos um
| > arquivo do
| > tipo .tar.bz2 teríamos de executar primeiramente o tar e na 
| sua saída
| > executar o bzip2. Usando a técnica de substituição de processos,
| > poderíamos
| > fazer o mesmo de forma mais compacta conforme o exemplo a seguir:
| > $ tar cf >(bzip2 -c > arquivo.tar.bz2) $NomeDiretorio
| >
| > Esmiuçando este exemplo: primeiramente é feito um tar no 
| arquivo apontado
| > pela variável $NomeDiretorio e a sua saída é mandada para o arquivo
| > temporário /dev/fd/63, que é um named pipe usado para 
| canalizar a saída do
| > comando tar para o bzip2, gerando desta maneira o arquivo.tar.bz2.
| > O último exemplo para atestar a versatilidade da 
| substituição de processos
| > vem a seguir e é um fragmento de código extraído de um 
| script da distro
| > SuSE:
| > while read  des what mask iface; do
| > #   comandos ...
| > done < <(route -n)
| >
| > Para testá-lo, vamos substituir comandos ... por alguma besteira sem
| > sentido, tal como:
| > while read des what mask iface; do
| >     echo $des $what $mask $iface
| > done < <(route -n)
| >
| > Que reproduziria a tabela de roteamento IP do kernel. 
| Ourtra forma de
| > cumprir a mesma tarefa, porém mais fácil de entender do que 
| esta seria a
| > seguinte:
| > route -n |
| > while read des what mask iface; do
| >     echo $des $what $mask $iface
| > done
| >
| > Apesar desta forma de codificação produzir uma saída idêntica à
| > anterior, o
| > uso do pipe (|) gera um subshell para a execução do laço 
| (loop) while; do
| > ... done e portanto alterações de valores de variáveis no 
| seu interior
| > seriam perdidas ao término deste subshell. Assim sendo, se 
| fizéssemos:
| > route -n | while read x
| > do
| >     ((y++))
| > done
| > echo $y
| >
| > Não obteríamos saída alguma porque a variável $y não teria 
| sido sequer
| > criada no Shell corrente, no entanto se fizéssemos:
| > while read x
| > do
| >     ((y++))
| > done < <(route -n)
| > echo $y
| >
| > Teríamos como saída a quantidade de linhas gerados pelo 
| comando route -n.
| > Já que estamos no finalzinho desta seção, que você teve tanta
| > paciência para
| > ler, vejamos se a substituição de processos (process 
| substitution) é mesmo
| > feita via um named pipe temporário:
| > $ ls -l >(cat)
| > l-wx------ 1 jneves jneves 64 Aug 27 12:26 /dev/fd/63 -> pipe:[7039]
| > $ ls -l >(cat)
| > l-wx------ 1 jneves jneves 64 Aug 27 12:26 /dev/fd/63 -> pipe:[7050]
| >
| > É, realmente é um named pipe.
| > A substituição de processos também pode ser misturada, você 
| pode ver que o
| > exemplo a seguir
| > $ cat <(cat <(cat <(ls -l)))
| >
| > trabalha como uma forma muito redundante para listar o 
| diretório corrente.
| > Como você pode ver, os named pipes, com uma pequena ajuda do
| > Shell, permite
| > que árvores de pipes sejam criadas. As possibilidades são 
| limitadas apenas
| > pela sua imaginação.
| > ===========================================>8CorteAqui8<==========
| > ==========
| > ====================
| >
| > Julio
| > :wq
| >
| > | -----Mensagem original-----
| > | De: oteb_04 [mailto:address@hidden]
| > | Enviada em: quarta-feira, 29 de dezembro de 2004 13:44
| > | Para: address@hidden
| > | Assunto: RES: [shell-script] Arquivo TXT
| > |
| > |
| > |
| > |
| > | Olá
| > |
| > | >A explicação da construção <(...) é longa e eu já postei 
| na lista há
| > | >uns 2
| > | >meses. Quem achar favor reproduzir.
| > |
| > | Encontrei isso aqui:
| > |
| > | "...uma saída muito mais elegante (porém muito pouco 
| conhecida) que é
| > | através do uso de named pipes temporários, via substituição
| > | de processo
| > | (process substitution), teste isso:
| > |
| > | $ while read line
| > | > do
| > | > let i++ # Com o let não é necessário inicializar a 
| variável (i=0)
| > | > echo -n $i
| > | > done < <(seq 10)
| > | 12345678910$
| > | ..."
| > |
| > | A mensagem completa está em:
| > | http://br.groups.yahoo.com/group/shell-script/message/11444
| > |
| > | Olhei no abs-guide:
| > | http://www.die.net/doc/linux/abs-guide/process-sub.html
| > |
| > | e no primeiro paragráfo diz:
| > | Process substitution is the counterpart to command substitution.
| > | Command substitution sets a variable to the result of a 
| command, as in
| > | dir_contents=`ls -al` or xref=$( grep word datafile). Process
| > | substitution feeds the output of a process to another process (in
| > | other words, it sends the results of a command to another 
| command).
| > |
| > | o que parece ser algo como:
| > | O process substitution(substituição de processo) é a 
| contrapartida ao
| > | command substitution(comando de substituição). Este atribui a uma
| > | variável o resultado de um comando, como em
| > |
| > |                    dir_contents=`ls -al`
| > |                    ou
| > |                    xref=$(grep word datafile)
| > |
| > | O process substitution(substituição de processo) 
| alimenta, com a saida
| > | de um processo, um outro processo( em outras palavras; envia o
| > | resultado de um comando para outro comando)
| > |
| > | obs: não existe espaço entre o direcionador e o parenteses
| > |
| > | Além do exemplo acima, mais um(tirado do abs-guide):
| > | cat <(ls -l)
| > | # É o mesmo que     ls -l | cat
| > |
| > |
| > | abraço
| > | Beto
| > |
| > |
| > |
| > |
| > |
| > |
| > |
| > |
| > |
| > | 
| ---------------------------------------------------------------------
| > | Esta lista não admite a abordagem de outras liguagens de
| > | programação, como perl, C etc. Quem insistir em não seguir
| > | esta regra será moderado sem prévio aviso.
| > | 
| ---------------------------------------------------------------------
| > | Sair da lista: address@hidden
| > | 
| ---------------------------------------------------------------------
| > | Esta lista é moderada de acordo com o previsto em
| > http://www.listas-discussao.cjb.net
| > 
| ---------------------------------------------------------------------
| >
| > Links do Yahoo! Grupos
| >
| >
| >
| >
| >
| >
| >
| >
| >
| > 
| ---------------------------------------------------------------------
| > Esta lista não admite a abordagem de outras liguagens de
| > programação, como perl, C etc. Quem insistir em não seguir esta
| > regra será moderado sem prévio aviso.
| > 
| ---------------------------------------------------------------------
| > Sair da lista: address@hidden
| > 
| ---------------------------------------------------------------------
| > Esta lista é moderada de acordo com o previsto em
| http://www.listas-discussao.cjb.net
| ---------------------------------------------------------------------
| 
| Links do Yahoo! Grupos
| 
| 
| 
| 
| 
| 
| 
| 
| 
| 
| 
| ---------------------------------------------------------------------
| Esta lista não admite a abordagem de outras liguagens de 
| programação, como perl, C etc. Quem insistir em não seguir 
| esta regra será moderado sem prévio aviso.
| ---------------------------------------------------------------------
| Sair da lista: address@hidden
| ---------------------------------------------------------------------
| Esta lista é moderada de acordo com o previsto em 
http://www.listas-discussao.cjb.net
---------------------------------------------------------------------
 
Links do Yahoo! Grupos