Prezados Jimmy e Renato;

Antes de mais nada gostaria muito de agradecer a colaboração.
Tanto o script.sh  quanto as linhas sed e awk funcionaram.
Tive problemas quando a saida era para terminal. Dessa maneira 
obtinha a data hora truncada. Depois que redirecionei para um arquivo 
tudo tudo se encaixou.

Grande abraço
Jair

 


________________________________
De: jimmy <jimmy.tty@...>
Para: sed-br@...
Enviadas: Quinta-feira, 27 de Outubro de 2011 20:45
Assunto: Re: [sed-br] formatar colunas


 
On Wed, Oct 26, 2011 at 04:29:15PM -0700, Jair Menegon wrote:
> Prezados Colegas;
>
> Tenho o arquivos txt formatados como abaixo:
>
>
> 2010-11-23 01:00:00 01:00:00
> #    z  speed    dir      W   sigW       T       bck   error
>     40   0.78  190.8  -0.11   0.10   23.31  6.61E+09       0
>     60   0.55  216.0  -0.07   0.11   23.39  1.72E+08       0
>     80   0.35  215.5   0.01   0.12   23.48  4.33E+07       0
>    100   0.25  174.1  -0.05   0.14   23.69  9.61E+06       0
>
> 2010-11-23 02:00:00 01:00:00
> #    z  speed    dir      W   sigW       T       bck   error
>     40   0.63  172.8  -0.02   0.09   23.40  1.00E+10       0
>     60   0.62  239.9   0.00   0.11   23.35  1.96E+08       0
>     80   0.30  203.3   0.01   0.11   23.35  7.08E+07       0
>    100   0.36  175.6  -0.02   0.12   23.57  1.91E+07       0
>    120   0.15  218.2  -0.09   0.10   23.77  3.53E+07       0
>    140   0.14  248.9  -0.10   0.14   23.84  2.44E+07       0
>
> 2010-11-23 03:00:00 01:00:00
> #    z  speed    dir      W   sigW       T       bck   error
>     40   0.22  239.6   0.00   0.04   23.15  8.08E+09       0
>     60   0.50  260.3   0.01   0.06   23.11  2.12E+08       0
>     80   0.41  180.7   0.04   0.07   23.10  5.93E+07       0
>    100   0.62  177.0   0.00   0.08   23.31  1.74E+07       0
>    120   0.31  188.6  -0.03   0.12   23.52  3.38E+07       0
>    140   0.18  202.7  -0.06   0.13   23.59  2.35E+07       0
>    160   0.08  151.0  -0.07   0.18   23.55  1.82E+07       0
>    180   0.12  149.9  -0.11  99.99   23.45  1.66E+07       0
>
> Usando o sed e/ou awk  gostaria de deixa-lo como:
>
> 2010-11-23 01:00:00 01:00:00    40   0.78  190.8  -0.11   0.10   23.31
 6.61E+09       0
> 2010-11-23 01:00:00 01:00:00    60   0.55  216.0  -0.07   0.11   23.39
 1.72E+08       0
> 2010-11-23 01:00:00 01:00:00    80   0.35  215.5   0.01   0.12   23.48
 4.33E+07       0
> 2010-11-23 01:00:00 01:00:00   100   0.25  174.1  -0.05   0.14   23.69
 9.61E+06       0
>
> 2010-11-23 02:00:00 01:00:00    40   0.63  172.8  -0.02   0.09   23.40
 1.00E+10       0
> 2010-11-23 02:00:00 01:00:00    60   0.62  239.9   0.00   0.11   23.35
 1.96E+08       0
> 2010-11-23 02:00:00 01:00:00    80   0.30  203.3   0.01   0.11   23.35
 7.08E+07       0
> 2010-11-23 02:00:00 01:00:00   100   0.36  175.6  -0.02   0.12   23.57
 1.91E+07       0
> 2010-11-23 02:00:00 01:00:00   120   0.15  218.2  -0.09   0.10   23.77
 3.53E+07       0
> 2010-11-23 02:00:00 01:00:00   140   0.14  248.9  -0.10   0.14   23.84
 2.44E+07       0
>
> 2010-11-23 03:00:00 01:00:00    40   0.22  239.6   0.00   0.04   23.15
 8.08E+09       0
> 2010-11-23 03:00:00 01:00:00    60   0.50  260.3   0.01   0.06   23.11
 2.12E+08       0
> 2010-11-23 03:00:00 01:00:00    80   0.41  180.7   0.04   0.07   23.10
 5.93E+07       0
> 2010-11-23 03:00:00 01:00:00   100   0.62  177.0   0.00   0.08   23.31
 1.74E+07       0
> 2010-11-23 03:00:00 01:00:00   120   0.31  188.6  -0.03   0.12   23.52
 3.38E+07       0
> 2010-11-23 03:00:00 01:00:00   140   0.18  202.7  -0.06   0.13   23.59
 2.35E+07       0
> 2010-11-23 03:00:00 01:00:00   160   0.08  151.0  -0.07   0.18   23.55
 1.82E+07       0
> 2010-11-23 03:00:00 01:00:00   180   0.12  149.9  -0.11  99.99   23.45
 1.66E+07       0
>
> Obrigado 
> Grande abraço
>
>  
> Jair João Menegon
> jairmenegon@...
> www.usp.br/massa

Saudações Jair,

Parece bem simples o que pretende fazer, mas o e-mail veio cheio de
caracteres octal 240, vou assumir apenas aquilo que "posso ver", ou
seja, espaços :P

Com o sed, fica algo parecido com:

sed '/^[0-9]/{h;d};/^#/d;/^\s/{G;s/\(.*\)\n\(.*\)/\2\t\1/}' txt.txt

esse comando tem apenas três fases:

1. /^[0-9]/{h;d} => se a linha começar com número, coloca no hold space
e a deleta do pattern space.

2. /^#/d; => se a linha começar com #, deleta do pattern space.

3. /^\s/{G;s/\(.*\)\n\(.*\)/\2\t\1/} => se a linha começar com
caracteres brancos, apensa o conteúdo do hold space ao pattern space,
e acerta as posições.

Com awk:

awk '/^[0-9]/{s=$0}/^#/{next}/^ /{print s"\t"$0}' txt.txt

que é praticamente a mesma lógica usado no meu exemplo com sed, e que
também pode ser usado como base para implementar com várias outras
ferramentas, editores de texto inclusive.




[As partes desta mensagem que não continham texto foram removidas]

Ola, pessoal

Estou com um problema é um pouco complicado de explicar, mas qualquer dúvida é
só me falar.
Já consegui fazer uma solução com o Script que será descrito abaixo, mas
gostaria de sugestões para melhorias utilizando o sed talvez, principalmente
para melhorar o desempenho.
Bem, preciso separar um arquivo de texto em vários outros baseados em partes de
cada linha dele.
Um exemplo de uma das linhas deste arquivo é:
05114105841813000016417100000000121130000000000000000{00000000000000{00000000000\
000{00000000078486G00000000000000{0551601010001049906010920113108201115655615457\
1051583
R.

Os dois primeiros caracteres da linha representam um registro, ou seja, a linha
exemplo é do registro 05.
Os caracteres, a partir da posição 151, representam erros. Os erros são
compostos de 6 caracteres cada, então, de acordo com a linha de exemplo temos
três erros: erro 156556 (caracteres 151 a 156), erro 154571 (caracteres 157 a
162), e erro 051583 (caracteres 163 a 168). Os erros podem estender-se pelos
caracteres em branco até a letra 'R'.

Os registros e erros de cada linha indicarão em qual arquivo está linha deverá
constar no resultado. Pelo exemplo que estou utilizando, a linha deverá então
constar nos seguintes arquivos de saída, gerados também pelo script:
-ArquivoResultado.05.156556.txt
-ArquivoResultado.05.154571.txt
-ArquivoResultado.05.051583.txt

Fiz o script abaixo, que atende a necessidade mas demonstrou baixo rendimento,
uma vez que tenho que tratar com arquivos que podem passar de 1 Gb.

# !/bin/bash
#
# Separador.sh
#
# Script para separar um arquivo de texto em vários baseados em valor de código
de erro e registro constantes e cada linha

while read LINHA; do # Laço para percorrer a linha

	 for ind in $(seq 150 6 265); do # Indica as diversas posições em que o código
de erro fica na linha
		 nome=`echo $LINHA | cut -c$ind-$((ind+5))` # Nome do erro que fica no fim de
cada linha do arquivo
		 reg=`echo $LINHA | cut -c1-2` # Nome do registro que são os dois primeiros
caracteres de cada linha do arquivo
		 if test "$nome" != "      " # Teste para indicar se ainda possui algum erro em
determinada linha. Caso esteja em branco, sai para a outra linha.
		 then
			 echo "$LINHA" >> arquivoSaida.$reg.$nome.txt # Aqui gerará os vários arquivos
com o nome do erro e o registro
		 else
			 break
		 fi
	 done

done < $1 # Parametro onde o usuário indica qual arquivo deseja tratar.

Solicito, por favor, amigos, que analisem o script acima e agradeço por qualquer
sugestão.

Segue abaixo também uma amostra do arquivo que será a entrada do script:


05114105841813000016417100000000121130000000000000000{00000000000000{00000000000\
000{00000000078486G00000000000000{0551601010001049906010920113108201115655615457\
1051583
R
05114105841813000020769400000000131130000000000000000{00000000000000{00000000000\
000{00000000014564{00000000000000{0375101010001049906010920113108201115655615457\
1051583
R
05114105841813000025085200000000111130000000000000000{00000000000000{00000000000\
000{00000000013287B00000000000000{0509201010001049906010920113108201115655615457\
1051583
R
05114105841813000025567100000000181130000000000000000{00000000000000{00000000000\
000{00000000020882G00000000000000{0546101010001049906010920113108201115655615457\
1051583
R
05114105841813000055403900000000121130000000000000000{00000000000000{00000000000\
000{00000000019494G00000000000000{0491001010001049906010920113108201115655615457\
1051583
R
05114105841813000055447200000000171130000000000000000{00000000000000{00000000000\
000{00000000010115B00000000000000{0570201010001049906010920113108201115655615457\
1051583
R
05114105841813000070017400000000111130000000000000000{00000000000000{00000000000\
000{00000000006045G00000000000000{0496501010001049906010920113108201115655615457\
1051583
R
05114105841813000073785200000000151130000000000000000{00000000000000{00000000000\
000{00000000073330D00000000000000{0517901010001049906010920113108201115655615457\
1051583
R
05114105841813000084251500000000151130000000000000000{00000000000000{00000000000\
000{00000000471382H00000000000000{0457801010001049906010920113108201115655615457\
1051583
R
05114105841813000086597800000000121130000000000000000{00000000000000{00000000000\
000{00000000001370A00000000000000{0504801010001049906010920113108201115655615457\
1051583
R

On Fri, Oct 28, 2011 at 09:30:31PM -0000, Wilton wrote:
> Ola, pessoal
Saudações Wilton,

> Estou com um problema é um  pouco complicado de explicar, mas qualquer
> dúvida é só me falar.

> Já consegui fazer  uma solução com o Script que  será descrito abaixo,
> mas  gostaria de  sugestões para  melhorias utilizando  o sed  talvez,
> principalmente para melhorar o desempenho.
>
> Bem, preciso separar um arquivo de  texto em vários outros baseados em
> partes de cada linha dele.
>
> Um exemplo de uma das linhas deste arquivo é:
>
05114105841813000016417100000000121130000000000000000{00000000000000{00000000000\
000{00000000078486G00000000000000{0551601010001049906010920113108201115655615457\
1051583
R.

> Os  dois primeiros  caracteres da  linha representam  um registro,  ou
> seja, a linha exemplo é do registro 05.
>
> Os caracteres,  a partir da  posição 151, representam erros.  Os erros
> são compostos  de 6 caracteres cada,  então, de acordo com  a linha de
> exemplo temos  três erros:  erro 156556 (caracteres  151 a  156), erro
> 154571 (caracteres 157  a 162), e erro 051583 (caracteres  163 a 168).
> Os erros podem estender-se pelos caracteres em branco até a letra 'R'.
Essa parte não  entendi muito bem, sempre haverá uma  quantidade fixa de
caracteres para cada registro? Ou em outras palavras, quando não existir
6 números haverá 6 espaços?

> Os registros  e erros  de cada  linha indicarão  em qual  arquivo está
> linha deverá constar no resultado.  Pelo exemplo que estou utilizando,
> a linha deverá então constar  nos seguintes arquivos de saída, gerados
> também pelo script:
>
> -ArquivoResultado.05.156556.txt
> -ArquivoResultado.05.154571.txt
> -ArquivoResultado.05.051583.txt
>
> Fiz o  script abaixo,  que atende a  necessidade mas  demonstrou baixo
> rendimento, uma vez que tenho que tratar com arquivos que podem passar
> de 1 Gb.
Aqui  complicou,   "demonstrar  baixo   rendimento"  seria   uma  medida
comparativa, mas no seu caso, qual o critério de comparação? Poderia ser
requisitos  de  projetos,  expectativas  pessoais,  qualquer  combinação
das  duas  ou  nenhuma.  Isso  é  importante  para  saber  qual  caminho
tomar,   otimização  da   performance  do   hardware/infraestrutura,  do
algoritmo/implementação ou reanalisar a coisa toda a partir do zero ...

> # !/bin/bash
> #
> # Separador.sh
> #
> # Script para separar um arquivo de texto em vários baseados em valor de
código de erro e registro constantes e cada linha
>
> while read LINHA; do # Laço para percorrer a linha
>
>  for ind in $(seq 150 6 265); do # Indica as diversas posições em que o código
de erro fica na linha
> 	 nome=`echo $LINHA | cut -c$ind-$((ind+5))` # Nome do erro que fica no fim de
cada linha do arquivo
> 	 reg=`echo $LINHA | cut -c1-2` # Nome do registro que são os dois primeiros
caracteres de cada linha do arquivo
> 	 if test "$nome" != "      " # Teste para indicar se ainda possui algum erro
em determinada linha. Caso esteja em branco, sai para a outra linha.
> 	 then
> 		 echo "$LINHA" >> arquivoSaida.$reg.$nome.txt # Aqui gerará os vários
arquivos com o nome do erro e o registro
> 	 else
> 		 break
> 	 fi
>  done
>
> done  < $1  #  Parametro onde  o usuário  indica  qual arquivo  deseja
> tratar. Solicito,  por favor,  amigos, que analisem  o script  acima e
> agradeço por qualquer sugestão.
Aprimorar a  lógica usada no  script _provavelmente_ otimizaria  muito a
performance geral, perceba que você está cortando a mesma linha 20 vezes
sendo que  poderia fazer  isso apenas  1 vez,  contudo, caso  o hardware
disponível  tenha um  poder  de processamento  estupidamente superior  a
vazão de I/O de disco, não fará diferença alguma mudar isso.

Até onde eu conheço, sed não  é dinâmico o suficiente para resolver esse
problema sozinho.

[]'s
--
"Não manejo bem as palavras
Mas manipulo bem as strings."
------------------------------
http://tecnoveneno.blogspot.com

Ola,

Primeiramente quero agradecer a atenção do amigo Jimmy. Vou
esclarecer, juntamente com o texto da mensagem, os pontos que o Jimmy
abordou:

Em 29 de outubro de 2011 22:52, jimmy <jimmy.tty@...> escreveu:

> **
>
>
> On Fri, Oct 28, 2011 at 09:30:31PM -0000, Wilton wrote:
> > Ola, pessoal
> Saudações Wilton,
>
>
> > Estou com um problema é um pouco complicado de explicar, mas qualquer
> > dúvida é só me falar.
>
> > Já consegui fazer uma solução com o Script que será descrito abaixo,
> > mas gostaria de sugestões para melhorias utilizando o sed talvez,
> > principalmente para melhorar o desempenho.
> >
> > Bem, preciso separar um arquivo de texto em vários outros baseados em
> > partes de cada linha dele.
> >
> > Um exemplo de uma das linhas deste arquivo é:
> >
>
05114105841813000016417100000000121130000000000000000{00000000000000{00000000000\
000{00000000078486G00000000000000{0551601010001049906010920113108201115655615457\
1051583
> R.
>
> > Os dois primeiros caracteres da linha representam um registro, ou
> > seja, a linha exemplo é do registro 05.
> >
> > Os caracteres, a partir da posição 151, representam erros. Os erros
> > são compostos de 6 caracteres cada, então, de acordo com a linha de
> > exemplo temos três erros: erro 156556 (caracteres 151 a 156), erro
> > 154571 (caracteres 157 a 162), e erro 051583 (caracteres 163 a 168).
> > Os erros podem estender-se pelos caracteres em branco até a letra 'R'.
> Essa parte não entendi muito bem, sempre haverá uma quantidade fixa de
> caracteres para cada registro? Ou em outras palavras, quando não existir
> 6 números haverá 6 espaços?
>

Cada linha contem a mesma quantidade de caracteres, a partir da posição 151
até o final da linha é o espaço para descrever os erros que aquela linha(
que é um registro) possuem. Cada erro possui 6 caracteres. Pode ter
registro com 1, 2 ou mais erros. Por isso os espaços em branco no final das
linhas.

>
>
> > Os registros e erros de cada linha indicarão em qual arquivo está
> > linha deverá constar no resultado. Pelo exemplo que estou utilizando,
> > a linha deverá então constar nos seguintes arquivos de saída, gerados
> > também pelo script:
> >
> > -ArquivoResultado.05.156556.txt
> > -ArquivoResultado.05.154571.txt
> > -ArquivoResultado.05.051583.txt
> >
> > Fiz o script abaixo, que atende a necessidade mas demonstrou baixo
> > rendimento, uma vez que tenho que tratar com arquivos que podem passar
> > de 1 Gb.
> Aqui complicou, "demonstrar baixo rendimento" seria uma medida
> comparativa, mas no seu caso, qual o critério de comparação? Poderia ser
> requisitos de projetos, expectativas pessoais, qualquer combinação
> das duas ou nenhuma. Isso é importante para saber qual caminho
> tomar, otimização da performance do hardware/infraestrutura, do
> algoritmo/implementação ou reanalisar a coisa toda a partir do zero ...
>

Essa observação foi muito boa e que não pensei quando mandei a mensagem. O
que acontece é que diante do problema citado, eu apresentei a idéia lógica
para a solução em Shell Script e funcionou. Outro colega, que conhece bem
Java, implementou nesta linguagem conseguindo finalizar o processo muito
mais rápido. O que me impressionou é que a lógica foi a mesma, mas em Java
acabou-se utilizando muitas funções e mesmo assim ficou mais rápido.
Acredito que deva ter outra funções onde eu possa utilizar o Shell  Script
e consiga a mesma performance.

>
>
> > # !/bin/bash
> > #
> > # Separador.sh
> > #
> > # Script para separar um arquivo de texto em vários baseados em valor de
> código de erro e registro constantes e cada linha
> >
> > while read LINHA; do # Laço para percorrer a linha
> >
> > for ind in $(seq 150 6 265); do # Indica as diversas posições em que o
> código de erro fica na linha
> > nome=`echo $LINHA | cut -c$ind-$((ind+5))` # Nome do erro que fica no
> fim de cada linha do arquivo
> > reg=`echo $LINHA | cut -c1-2` # Nome do registro que são os dois
> primeiros caracteres de cada linha do arquivo
> > if test "$nome" != " " # Teste para indicar se ainda possui algum erro
> em determinada linha. Caso esteja em branco, sai para a outra linha.
> > then
> > echo "$LINHA" >> arquivoSaida.$reg.$nome.txt # Aqui gerará os vários
> arquivos com o nome do erro e o registro
> > else
> > break
> > fi
> > done
> >
> > done < $1 # Parametro onde o usuário indica qual arquivo deseja
> > tratar. Solicito, por favor, amigos, que analisem o script acima e
> > agradeço por qualquer sugestão.
> Aprimorar a lógica usada no script _provavelmente_ otimizaria muito a
> performance geral, perceba que você está cortando a mesma linha 20 vezes
> sendo que poderia fazer isso apenas 1 vez, contudo, caso o hardware
> disponível tenha um poder de processamento estupidamente superior a
> vazão de I/O de disco, não fará diferença alguma mudar isso.
>
> Até onde eu conheço, sed não é dinâmico o suficiente para resolver esse
> problema sozinho.
>
> []'s
> --
> "Não manejo bem as palavras
> Mas manipulo bem as strings."
> ------------------------------
> http://tecnoveneno.blogspot.com
>
>
>


[As partes desta mensagem que não continham texto foram removidas]

On Sun, Oct 30, 2011 at 04:32:20PM -0200, Wilton Furtado Amaro wrote:
> (...)
> > > Os caracteres, a partir da posição 151, representam erros. Os erros
> > > são compostos de 6 caracteres cada, então, de acordo com a linha de
> > > exemplo temos três erros: erro 156556 (caracteres 151 a 156), erro
> > > 154571 (caracteres 157 a 162), e erro 051583 (caracteres 163 a 168).
> > > Os erros podem estender-se pelos caracteres em branco até a letra 'R'.
> > Essa parte não entendi muito bem, sempre haverá uma quantidade fixa de
> > caracteres para cada registro? Ou em outras palavras, quando não existir
> > 6 números haverá 6 espaços?
> >
>
> Cada linha contem a mesma quantidade de caracteres, a partir da posição 151
> até o final da linha é o espaço para descrever os erros que aquela linha(
> que é um registro) possuem. Cada erro possui 6 caracteres. Pode ter
> registro com 1, 2 ou mais erros. Por isso os espaços em branco no final das
> linhas.
>
> (...)
> > > Fiz o script abaixo, que atende a necessidade mas demonstrou baixo
> > > rendimento, uma vez que tenho que tratar com arquivos que podem passar
> > > de 1 Gb.
> > Aqui complicou, "demonstrar baixo rendimento" seria uma medida
> > comparativa, mas no seu caso, qual o critério de comparação? Poderia ser
> > requisitos de projetos, expectativas pessoais, qualquer combinação
> > das duas ou nenhuma. Isso é importante para saber qual caminho
> > tomar, otimização da performance do hardware/infraestrutura, do
> > algoritmo/implementação ou reanalisar a coisa toda a partir do zero ...
> >
>
> Essa observação foi muito boa e que não pensei quando mandei a mensagem. O
> que acontece é que diante do problema citado, eu apresentei a idéia lógica
> para a solução em Shell Script e funcionou. Outro colega, que conhece bem
> Java, implementou nesta linguagem conseguindo finalizar o processo muito
> mais rápido. O que me impressionou é que a lógica foi a mesma, mas em Java
> acabou-se utilizando muitas funções e mesmo assim ficou mais rápido.
> Acredito que deva ter outra funções onde eu possa utilizar o Shell  Script
> e consiga a mesma performance.

Num caso onde a performance  fosse algo crucial, não usaria shell-script
(bash,  zsh,  awk, sed  ...)  e  muito  provavelmente java  também  não.
Otimização e performance é um assunto  por demais extenso e com diversos
níveis de complexidade,  fica como dever de casa estudá-lo  mais a fundo
:P

Fiz um  teste aqui na minha  máquina com seu  script e com o  arquivo de
exemplo replicado (323 linhas), o resultado foi o seguinte:

     $ time ./bash.sh arquivo.txt
    ./bash.sh arquivo.txt  7.17s user 7.61s system 50% cpu 29.179 total

Fiz  uma implementação  simplista do  seu script  em gawk,  e tive  como
resultado:

     time gawk 'BEGIN{FIELDWIDTHS="2 147
60"}{i=2;while(i<=length($3)){erro=substr($3,i,6);i+=6;if(erro~/[0-9]/){print $0
>> "arquivoSaida."$1"."erro".txt"}}}' arquivo.txt
     gawk  arquivo.txt  0.02s user 0.00s system 95% cpu 0.027 total

Porque a  diferença é  tão grande?  Porque o awk  abriu cada  arquivo de
destino apenas 1 vez e só os fechou ao término da execução, diferente da
construção em  shell "echo >>  arquivo" sempre  abre e fecha  o arquivo,
alguns outros pontos que também  influenciaram no baixo rendimento foram
mencionados  no  e-mail  anterior.  Ainda usando  apenas  bash,  podemos
otimizar bastante  essa abordagem,  mas irei deixar  isso como  dever de
casa, os e-mails tem muito texto e quase nenhum código :P

Muito obrigado, Jimmy, pela sua orientação.

Fiquei impressionado com o código em awk. Tenho procurado informações sobre
esta linguagem mas não tenho encontrado muita coisa em português. Você
poderia me indicar alguma material sobre a linguagem, preferencialmente em
português?

Mais uma vez, obrigado.

Wilton


Em 30 de outubro de 2011 23:06, jimmy <jimmy.tty@...> escreveu:

> **
>
>
> On Sun, Oct 30, 2011 at 04:32:20PM -0200, Wilton Furtado Amaro wrote:
> > (...)
>
> > > > Os caracteres, a partir da posição 151, representam erros. Os erros
> > > > são compostos de 6 caracteres cada, então, de acordo com a linha de
> > > > exemplo temos três erros: erro 156556 (caracteres 151 a 156), erro
> > > > 154571 (caracteres 157 a 162), e erro 051583 (caracteres 163 a 168).
> > > > Os erros podem estender-se pelos caracteres em branco até a letra
> 'R'.
> > > Essa parte não entendi muito bem, sempre haverá uma quantidade fixa de
> > > caracteres para cada registro? Ou em outras palavras, quando não
> existir
> > > 6 números haverá 6 espaços?
> > >
> >
> > Cada linha contem a mesma quantidade de caracteres, a partir da posição
> 151
> > até o final da linha é o espaço para descrever os erros que aquela linha(
> > que é um registro) possuem. Cada erro possui 6 caracteres. Pode ter
> > registro com 1, 2 ou mais erros. Por isso os espaços em branco no final
> das
> > linhas.
> >
> > (...)
>
> > > > Fiz o script abaixo, que atende a necessidade mas demonstrou baixo
> > > > rendimento, uma vez que tenho que tratar com arquivos que podem
> passar
> > > > de 1 Gb.
> > > Aqui complicou, "demonstrar baixo rendimento" seria uma medida
> > > comparativa, mas no seu caso, qual o critério de comparação? Poderia
> ser
> > > requisitos de projetos, expectativas pessoais, qualquer combinação
> > > das duas ou nenhuma. Isso é importante para saber qual caminho
> > > tomar, otimização da performance do hardware/infraestrutura, do
> > > algoritmo/implementação ou reanalisar a coisa toda a partir do zero ...
> > >
> >
> > Essa observação foi muito boa e que não pensei quando mandei a mensagem.
> O
> > que acontece é que diante do problema citado, eu apresentei a idéia
> lógica
> > para a solução em Shell Script e funcionou. Outro colega, que conhece bem
> > Java, implementou nesta linguagem conseguindo finalizar o processo muito
> > mais rápido. O que me impressionou é que a lógica foi a mesma, mas em
> Java
> > acabou-se utilizando muitas funções e mesmo assim ficou mais rápido.
> > Acredito que deva ter outra funções onde eu possa utilizar o Shell Script
> > e consiga a mesma performance.
>
> Num caso onde a performance fosse algo crucial, não usaria shell-script
> (bash, zsh, awk, sed ...) e muito provavelmente java também não.
> Otimização e performance é um assunto por demais extenso e com diversos
> níveis de complexidade, fica como dever de casa estudá-lo mais a fundo
> :P
>
> Fiz um teste aqui na minha máquina com seu script e com o arquivo de
> exemplo replicado (323 linhas), o resultado foi o seguinte:
>
> $ time ./bash.sh arquivo.txt
> ./bash.sh arquivo.txt 7.17s user 7.61s system 50% cpu 29.179 total
>
> Fiz uma implementação simplista do seu script em gawk, e tive como
> resultado:
>
> time gawk 'BEGIN{FIELDWIDTHS="2 147
> 60"}{i=2;while(i<=length($3)){erro=substr($3,i,6);i+=6;if(erro~/[0-9]/){print
> $0 >> "arquivoSaida."$1"."erro".txt"}}}' arquivo.txt
> gawk arquivo.txt 0.02s user 0.00s system 95% cpu 0.027 total
>
> Porque a diferença é tão grande? Porque o awk abriu cada arquivo de
> destino apenas 1 vez e só os fechou ao término da execução, diferente da
> construção em shell "echo >> arquivo" sempre abre e fecha o arquivo,
> alguns outros pontos que também influenciaram no baixo rendimento foram
> mencionados no e-mail anterior. Ainda usando apenas bash, podemos
> otimizar bastante essa abordagem, mas irei deixar isso como dever de
> casa, os e-mails tem muito texto e quase nenhum código :P
>
>
>


[As partes desta mensagem que não continham texto foram removidas]

On Mon, Oct 31, 2011 at 08:04:39AM -0200, Wilton Furtado Amaro wrote:
> Muito obrigado, Jimmy, pela sua orientação.
>
> Fiquei impressionado com o código em awk. Tenho procurado informações sobre
> esta linguagem mas não tenho encontrado muita coisa em português. Você
> poderia me indicar alguma material sobre a linguagem, preferencialmente em
> português?
Realmente não há muita documentação em português sobre awk, os poucos
existentes são fáceis de encontrar.

> Mais uma vez, obrigado.
>
> Wilton

--
"Não manejo bem as palavras
Mas manipulo bem as strings."
------------------------------
http://tecnoveneno.blogspot.com

Boa tarde, pessoal

Estou com um problema semelhante ao resolvido abaixo. O problema é que os
textos que trabalho são XML.
O texto passa por uma validação onde indica tags que estão com erro. Para
análise preciso separar o conteúdo entre as tags indicadas, mas o problema
é que o arquivo vem com várias tags na mesma linha, utilizando o exemplo da
mensagem abaixo, ficaria parecido com isso:

<body><div id="principal"><div id="lateralEsquerdo"><ul id=menuesquerdo>
<li>Teste</li></ul> </div><div id="Conteudo"><h3>This is a header</h3>
<p>This is a paragraph.</p><h3>This is a header</h3><p>This is a
paragraph.</p>
<h3>This is a header</h3><p>This is a paragraph.</p></div><div
id="lateralDireito"><ul id=menudireito><li>Teste</li></ul></div></div><div
id="rodape">
<ul id=menuesquerdo><li>Teste<li>
</ul></div></body>

Tem alguma forma de mostrar apenas o conteúdo da tag solicitada, excluindo
tudo que vier antes da tag inicial e tudo que vier depois da tag final?
Poderiam me ajudar? Porque até agora não encontrei solução.

Obrigado.

Wilton Furtado Amaro


Em 26 de setembro de 2011 21:31, Marcio Gil <marciomgil@...>escreveu:

> **
>
>
> Carla,
>
> Não sei se você já resolveu o problema, mas a solução da última
> discussão também resolve este seu problema:
>
> $ sed -n '/<div id="Conteudo">/{:a;/<\/div>/!{N;ba};p}' temp.txt
> <div id="Conteudo">
> <h3>This is a header</h3>
> <p>This is a paragraph.</p>
> <h3>This is a header</h3>
> <p>This is a paragraph.</p>
> <h3>This is a header</h3>
> <p>This is a paragraph.</p>
> </div>
>
> No entanto, se você quiser o conteúdo de uma TAG que também tenham tags
> com o mesmo terminador, então complica:
>
> $ sed -n '/<div id="principal">/{:a;/<\/div>/!{N;ba};p}' temp.txt
> <div id="principal">
> <div id="lateralEsquerdo">
> <ul id=menuesquerdo>
> <li>Teste</li>
> </ul>
> </div>
>
> Marcio.
>
> Em 13/9/2011 10:59, Carla da silva escreveu:
> >
> >
> > Bom dia a todos, prezados colegas sei
> > que o comando sed é possível especificar para imprimir de uma linha até
> > uma outra, porém minha dúvida é:
> > Tem como fazer um comando para abranger toda uma tag, porém essa tag
> > abrange varias linhas.
> > Exemplo:
> > Abranger toda tag <div id="Conteudo"> que está na linha 12 até a 19?
> >
> > http://pastebin.com/g9k2Y7J6
> >
> > ou
> >
> > 1. # o comando abaixo abrange a linha 12 até a linha 19
> > 2. sed -n '/<div id="Conteudo">/,/<div id="lateralDireito">/p'
> > 3.
> > 4. <body>
> > 5. <div id="principal">
> > 6. <div id="lateralEsquerdo">
> > 7. <ul id=menuesquerdo>
> > 8. <li>Teste</li>
> > 9. </ul>
> > 10. </div>
> > 11.
> > 12. <div id="Conteudo">
> > 13. <h3>This is a header</h3>
> > 14. <p>This is a paragraph.</p>
> > 15. <h3>This is a header</h3>
> > 16. <p>This is a paragraph.</p>
> > 17. <h3>This is a header</h3>
> > 18. <p>This is a paragraph.</p>
> > 19. </div>
> > 20.
> > 21. <div id="lateralDireito">
> > 22. <ul id=menudireito>
> > 23. <li>Teste</li>
> > 24. </ul>
> > 25. </div>
> > 26. </div>
> > 27. <div id="rodape">
> > 28. <ul id=menuesquerdo>
> > 29. <li>Teste</li>
> > 30. </ul>
> > 31. </div>
> > 32. </body>
> >
>
>


[As partes desta mensagem que não continham texto foram removidas]

Saudações Wilton,

On Sat, Dec 17, 2011 at 07:09:58PM -0200, Wilton Furtado Amaro wrote:
> Boa tarde, pessoal
>
> Estou com um problema semelhante ao resolvido abaixo. O problema é que
> os textos que trabalho são XML.
>
> O texto passa por uma validação onde indica tags que estão com erro.
Esses erros  seriam problemas de  estrutura como tags que  fechamento ou
não que podem/devem estar contidas noutras  tags ou seria um problema
relacionado ao conteúdo?

> Para análise preciso separar o conteúdo entre as tags indicadas, mas o
> problema  é  que  o  arquivo  vem com  várias  tags  na  mesma  linha,
> utilizando o exemplo da mensagem abaixo, ficaria parecido com isso:
>
> <body><div id="principal"><div id="lateralEsquerdo"><ul id=menuesquerdo>
> <li>Teste</li></ul> </div><div id="Conteudo"><h3>This is a header</h3>
> <p>This is a paragraph.</p><h3>This is a header</h3><p>This is a
> paragraph.</p>
> <h3>This is a header</h3><p>This is a paragraph.</p></div><div
> id="lateralDireito"><ul id=menudireito><li>Teste</li></ul></div></div><div
> id="rodape">
> <ul id=menuesquerdo><li>Teste<li>
> </ul></div></body>
>
> Tem alguma forma de mostrar apenas o conteúdo da tag solicitada, excluindo
> tudo que vier antes da tag inicial e tudo que vier depois da tag final?
Seguindo essa  abordagem textual, podemos usar  expressões regulares com
sed  ou  grep como quebra-galho para  se  obter  algumas  informações.
Dependendo da demanda, não resolverá de fato o seu problema.

Talvez a  melhor solução fosse mais  adequado analisar linguagens/parses
de XML e HTML.

> Poderiam me ajudar? Porque até agora não encontrei solução.
Dê  uma  olhada  no  linguagem xpath[1], no  xsh[2]  (meu  favorito),  no
xmllint[3] e no xmlstarlet[4].

[1] http://www.w3.org/TR/xpath20/
[2] http://xsh.sourceforge.net/
[3] http://xmlsoft.org/xmllint.html
[4] http://xmlstar.sourceforge.net/

> Obrigado.
>
> Wilton Furtado Amaro

[]'s.
--
"Não manejo bem as palavras
Mas manipulo bem as strings."
------------------------------
http://tecnoveneno.blogspot.com

Boa noite,

Acho que não expliquei bem o que quero.
Sei que o sed captura toda a linha que tiver o elemento procurado. No
assunto deste tópico foi apresentado uma forma de buscar um texto que está
entre tags mesmo em várias linhas.
O que gostaria é de que, alem disso, o comando retornasse apenas o texto
que se deseja mesmo havendo outro texto nas linhas desses.
Vamos utilizar o texto abaixo como exemplo(para melhor visualização, ver no
pastebin: http://pastebin.com/KbtW7P0D)
<Doc3040 DtBase="2010-10" CNPJ="12345678" Remessa="1" Parte="1"
TpArq="F"><Cli Tp="2" Cd="00038166" Autorzc="S" PorteCli="1" TpCtrl="01"
IniRelactCli="2010-01-01" CongEcon="000000" ClassCli="AA"><Op
DetCli="00038166000288" Contrt="ABC123" NatuOp="01" Mod="0101"
OrigemRec="0101" Indx="11" VarCamb="790" DtVencOp="2020-01-01" ClassOp="AA"
CEP="00000000" TaxEft="20.25" DtContr="2010-01-01" ProvConsttd="1000.0"
CaracEspecial="02;03">
<Venc v110="10000" v120="10000" v130="10000" v140="10000"
v150="10000"/><Gar Tp="0902" Ident="22222222" PercGar="100"/>
</Op><Op DetCli="00038166000369" Contrt="XYZ123" NatuOp="01" Mod="0101"
OrigemRec="0101" Indx="11" VarCamb="790" DtVencOp="2020-01-01" ClassOp="AA"
CEP="00000000" TaxEft="54.23" DtContr="2010-01-01"
ProvConsttd="1000.0"><Venc v110="20000" v120="20000" v130="20000"
v140="20000" v150="20000"/><Gar Tp="0102" VlrOrig="100000" VlrData="100000"
DtReav="2010-10-01"/>
</Op></Cli><Agreg Mod="0101" ClassOp="AA" FaixaVlr="1" TpCli="1"
TpCtrl="01" Localiz="10058" OrigemRec="0100" NatuOp="01" CaracEspecial="01"
VincME="N" PrzProvm="N" DesempOp="01" QtdOp="10000" QtdCli="8000"
ProvConsttd="1000000"><Venc v110="20000" v120="20000" v130="20000"
v140="20000" v150="20000"/>
</Agreg><Agreg Mod="0202" ClassOp="B" FaixaVlr="1" TpCli="1" TpCtrl="01"
Localiz="10058" OrigemRec="0100" NatuOp="01" CaracEspecial="01" VincME="N"
PrzProvm="N" DesempOp="01" QtdOp="10000" QtdCli="8000"
ProvConsttd="1000000">
<Venc v110="20000" v120="20000" v130="20000" v140="20000"
v150="20000"/></Agreg></Doc3040>

Digamos, que eu precise apenas do conteúdo da tag "Cli". Utilizando o
comando sed abordado no tópico, o resultado seria:
<Doc3040 DtBase="2010-10" CNPJ="12345678" Remessa="1" Parte="1"
TpArq="F"><Cli Tp="2" Cd="00038166" Autorzc="S" PorteCli="1" TpCtrl="01"
IniRelactCli="2010-01-01" CongEcon="000000" ClassCli="AA"><Op
DetCli="00038166000288" Contrt="ABC123" NatuOp="01" Mod="0101"
OrigemRec="0101" Indx="11" VarCamb="790" DtVencOp="2020-01-01" ClassOp="AA"
CEP="00000000" TaxEft="20.25" DtContr="2010-01-01" ProvConsttd="1000.0"
CaracEspecial="02;03">
<Venc v110="10000" v120="10000" v130="10000" v140="10000"
v150="10000"/><Gar Tp="0902" Ident="22222222" PercGar="100"/>
</Op><Op DetCli="00038166000369" Contrt="XYZ123" NatuOp="01" Mod="0101"
OrigemRec="0101" Indx="11" VarCamb="790" DtVencOp="2020-01-01" ClassOp="AA"
CEP="00000000" TaxEft="54.23" DtContr="2010-01-01"
ProvConsttd="1000.0"><Venc v110="20000" v120="20000" v130="20000"
v140="20000" v150="20000"/><Gar Tp="0102" VlrOrig="100000" VlrData="100000"
DtReav="2010-10-01"/>
</Op></Cli><Agreg Mod="0101" ClassOp="AA" FaixaVlr="1" TpCli="1"
TpCtrl="01" Localiz="10058" OrigemRec="0100" NatuOp="01" CaracEspecial="01"
VincME="N" PrzProvm="N" DesempOp="01" QtdOp="10000" QtdCli="8000"
ProvConsttd="1000000"><Venc v110="20000" v120="20000" v130="20000"
v140="20000" v150="20000"/>

Mas, o que eu preciso é apenas o conteúdo da tag "Cli":
<Cli Tp="2" Cd="00038166" Autorzc="S" PorteCli="1" TpCtrl="01"
IniRelactCli="2010-01-01" CongEcon="000000" ClassCli="AA"><Op
DetCli="00038166000288" Contrt="ABC123" NatuOp="01" Mod="0101"
OrigemRec="0101" Indx="11" VarCamb="790" DtVencOp="2020-01-01" ClassOp="AA"
CEP="00000000" TaxEft="20.25" DtContr="2010-01-01" ProvConsttd="1000.0"
CaracEspecial="02;03">
<Venc v110="10000" v120="10000" v130="10000" v140="10000"
v150="10000"/><Gar Tp="0902" Ident="22222222" PercGar="100"/>
</Op><Op DetCli="00038166000369" Contrt="XYZ123" NatuOp="01" Mod="0101"
OrigemRec="0101" Indx="11" VarCamb="790" DtVencOp="2020-01-01" ClassOp="AA"
CEP="00000000" TaxEft="54.23" DtContr="2010-01-01"
ProvConsttd="1000.0"><Venc v110="20000" v120="20000" v130="20000"
v140="20000" v150="20000"/><Gar Tp="0102" VlrOrig="100000" VlrData="100000"
DtReav="2010-10-01"/>
</Op></Cli>

Observem que, para conseguir o resultado acima, tive que retirar o que
estava antes da tag <Cli..., e o que veio depois da tag de
fechamento(</Cli>). Mas fiz isso manualmente.
Tem alguma forma de obter este resultado de forma automática?

Agradeço a colaboração.

Wilton



Em 21 de dezembro de 2011 00:12, jimmy <jimmy.tty@...> escreveu:

> **
>
>
> Saudações Wilton,
>
>
> On Sat, Dec 17, 2011 at 07:09:58PM -0200, Wilton Furtado Amaro wrote:
> > Boa tarde, pessoal
> >
> > Estou com um problema semelhante ao resolvido abaixo. O problema é que
> > os textos que trabalho são XML.
> >
> > O texto passa por uma validação onde indica tags que estão com erro.
> Esses erros seriam problemas de estrutura como tags que fechamento ou
> não que podem/devem estar contidas noutras tags ou seria um problema
> relacionado ao conteúdo?
>
>
> > Para análise preciso separar o conteúdo entre as tags indicadas, mas o
> > problema é que o arquivo vem com várias tags na mesma linha,
> > utilizando o exemplo da mensagem abaixo, ficaria parecido com isso:
> >
> > <body><div id="principal"><div id="lateralEsquerdo"><ul id=menuesquerdo>
> > <li>Teste</li></ul> </div><div id="Conteudo"><h3>This is a header</h3>
> > <p>This is a paragraph.</p><h3>This is a header</h3><p>This is a
> > paragraph.</p>
> > <h3>This is a header</h3><p>This is a paragraph.</p></div><div
> > id="lateralDireito"><ul
> id=menudireito><li>Teste</li></ul></div></div><div
> > id="rodape">
> > <ul id=menuesquerdo><li>Teste<li>
> > </ul></div></body>
> >
> > Tem alguma forma de mostrar apenas o conteúdo da tag solicitada,
> excluindo
> > tudo que vier antes da tag inicial e tudo que vier depois da tag final?
> Seguindo essa abordagem textual, podemos usar expressões regulares com
> sed ou grep como quebra-galho para se obter algumas informações.
> Dependendo da demanda, não resolverá de fato o seu problema.
>
> Talvez a melhor solução fosse mais adequado analisar linguagens/parses
> de XML e HTML.
>
>
> > Poderiam me ajudar? Porque até agora não encontrei solução.
> Dê uma olhada no linguagem xpath[1], no xsh[2] (meu favorito), no
> xmllint[3] e no xmlstarlet[4].
>
> [1] http://www.w3.org/TR/xpath20/
> [2] http://xsh.sourceforge.net/
> [3] http://xmlsoft.org/xmllint.html
> [4] http://xmlstar.sourceforge.net/
>
> > Obrigado.
> >
> > Wilton Furtado Amaro
>
> []'s.
> --
> "Não manejo bem as palavras
> Mas manipulo bem as strings."
> ------------------------------
> http://tecnoveneno.blogspot.com
>
>
>


[As partes desta mensagem que não continham texto foram removidas]

Mantendo essa abordadem, remova todos os "\n" para que todo o conteúdo
fique apenas em uma única linha e use uma expressão regular, exemplos
que provavelmente irão lhe quebrar um galho:

     $ tr '\n' ' ' < arquivo.xml | grep -o -P '<Cli[^>]*>.*?<\/Cli>'

ou com o sed:

     $ sed ':o;$!N;s/\n/
/;to;${s/<Cli/\r&/g;s|</Cli>|&\n|g;s/^[^\r]*\r//;s/\n[^\r]*\r/\n/g;s/\n[^\n\r]*$\
//}' arquivo.xml


Obs.: O caminho  mais adequado de fato seria o  que apresentei no e-mail
anterior.

On Wed, Dec 21, 2011 at 09:37:09PM -0200, Wilton Furtado Amaro wrote:
> Boa noite,
>
> Acho que não expliquei bem o que quero.
> Sei que o sed captura toda a linha que tiver o elemento procurado. No
> assunto deste tópico foi apresentado uma forma de buscar um texto que está
> entre tags mesmo em várias linhas.
> O que gostaria é de que, alem disso, o comando retornasse apenas o texto
> que se deseja mesmo havendo outro texto nas linhas desses.
> Vamos utilizar o texto abaixo como exemplo(para melhor visualização, ver no
> pastebin: http://pastebin.com/KbtW7P0D)
> <Doc3040 DtBase="2010-10" CNPJ="12345678" Remessa="1" Parte="1"
> TpArq="F"><Cli Tp="2" Cd="00038166" Autorzc="S" PorteCli="1" TpCtrl="01"
> IniRelactCli="2010-01-01" CongEcon="000000" ClassCli="AA"><Op
> DetCli="00038166000288" Contrt="ABC123" NatuOp="01" Mod="0101"
> OrigemRec="0101" Indx="11" VarCamb="790" DtVencOp="2020-01-01" ClassOp="AA"
> CEP="00000000" TaxEft="20.25" DtContr="2010-01-01" ProvConsttd="1000.0"
> CaracEspecial="02;03">
> <Venc v110="10000" v120="10000" v130="10000" v140="10000"
> v150="10000"/><Gar Tp="0902" Ident="22222222" PercGar="100"/>
> </Op><Op DetCli="00038166000369" Contrt="XYZ123" NatuOp="01" Mod="0101"
> OrigemRec="0101" Indx="11" VarCamb="790" DtVencOp="2020-01-01" ClassOp="AA"
> CEP="00000000" TaxEft="54.23" DtContr="2010-01-01"
> ProvConsttd="1000.0"><Venc v110="20000" v120="20000" v130="20000"
> v140="20000" v150="20000"/><Gar Tp="0102" VlrOrig="100000" VlrData="100000"
> DtReav="2010-10-01"/>
> </Op></Cli><Agreg Mod="0101" ClassOp="AA" FaixaVlr="1" TpCli="1"
> TpCtrl="01" Localiz="10058" OrigemRec="0100" NatuOp="01" CaracEspecial="01"
> VincME="N" PrzProvm="N" DesempOp="01" QtdOp="10000" QtdCli="8000"
> ProvConsttd="1000000"><Venc v110="20000" v120="20000" v130="20000"
> v140="20000" v150="20000"/>
> </Agreg><Agreg Mod="0202" ClassOp="B" FaixaVlr="1" TpCli="1" TpCtrl="01"
> Localiz="10058" OrigemRec="0100" NatuOp="01" CaracEspecial="01" VincME="N"
> PrzProvm="N" DesempOp="01" QtdOp="10000" QtdCli="8000"
> ProvConsttd="1000000">
> <Venc v110="20000" v120="20000" v130="20000" v140="20000"
> v150="20000"/></Agreg></Doc3040>
>
> Digamos, que eu precise apenas do conteúdo da tag "Cli". Utilizando o
> comando sed abordado no tópico, o resultado seria:
> <Doc3040 DtBase="2010-10" CNPJ="12345678" Remessa="1" Parte="1"
> TpArq="F"><Cli Tp="2" Cd="00038166" Autorzc="S" PorteCli="1" TpCtrl="01"
> IniRelactCli="2010-01-01" CongEcon="000000" ClassCli="AA"><Op
> DetCli="00038166000288" Contrt="ABC123" NatuOp="01" Mod="0101"
> OrigemRec="0101" Indx="11" VarCamb="790" DtVencOp="2020-01-01" ClassOp="AA"
> CEP="00000000" TaxEft="20.25" DtContr="2010-01-01" ProvConsttd="1000.0"
> CaracEspecial="02;03">
> <Venc v110="10000" v120="10000" v130="10000" v140="10000"
> v150="10000"/><Gar Tp="0902" Ident="22222222" PercGar="100"/>
> </Op><Op DetCli="00038166000369" Contrt="XYZ123" NatuOp="01" Mod="0101"
> OrigemRec="0101" Indx="11" VarCamb="790" DtVencOp="2020-01-01" ClassOp="AA"
> CEP="00000000" TaxEft="54.23" DtContr="2010-01-01"
> ProvConsttd="1000.0"><Venc v110="20000" v120="20000" v130="20000"
> v140="20000" v150="20000"/><Gar Tp="0102" VlrOrig="100000" VlrData="100000"
> DtReav="2010-10-01"/>
> </Op></Cli><Agreg Mod="0101" ClassOp="AA" FaixaVlr="1" TpCli="1"
> TpCtrl="01" Localiz="10058" OrigemRec="0100" NatuOp="01" CaracEspecial="01"
> VincME="N" PrzProvm="N" DesempOp="01" QtdOp="10000" QtdCli="8000"
> ProvConsttd="1000000"><Venc v110="20000" v120="20000" v130="20000"
> v140="20000" v150="20000"/>
>
> Mas, o que eu preciso é apenas o conteúdo da tag "Cli":
> <Cli Tp="2" Cd="00038166" Autorzc="S" PorteCli="1" TpCtrl="01"
> IniRelactCli="2010-01-01" CongEcon="000000" ClassCli="AA"><Op
> DetCli="00038166000288" Contrt="ABC123" NatuOp="01" Mod="0101"
> OrigemRec="0101" Indx="11" VarCamb="790" DtVencOp="2020-01-01" ClassOp="AA"
> CEP="00000000" TaxEft="20.25" DtContr="2010-01-01" ProvConsttd="1000.0"
> CaracEspecial="02;03">
> <Venc v110="10000" v120="10000" v130="10000" v140="10000"
> v150="10000"/><Gar Tp="0902" Ident="22222222" PercGar="100"/>
> </Op><Op DetCli="00038166000369" Contrt="XYZ123" NatuOp="01" Mod="0101"
> OrigemRec="0101" Indx="11" VarCamb="790" DtVencOp="2020-01-01" ClassOp="AA"
> CEP="00000000" TaxEft="54.23" DtContr="2010-01-01"
> ProvConsttd="1000.0"><Venc v110="20000" v120="20000" v130="20000"
> v140="20000" v150="20000"/><Gar Tp="0102" VlrOrig="100000" VlrData="100000"
> DtReav="2010-10-01"/>
> </Op></Cli>
>
> Observem que, para conseguir o resultado acima, tive que retirar o que
> estava antes da tag <Cli..., e o que veio depois da tag de
> fechamento(</Cli>). Mas fiz isso manualmente.
> Tem alguma forma de obter este resultado de forma automática?
>
> Agradeço a colaboração.
>
> Wilton
>
>
>
> Em 21 de dezembro de 2011 00:12, jimmy <jimmy.tty@...> escreveu:
>
> > **
> >
> >
> > Saudações Wilton,
> >
> >
> > On Sat, Dec 17, 2011 at 07:09:58PM -0200, Wilton Furtado Amaro wrote:
> > > Boa tarde, pessoal
> > >
> > > Estou com um problema semelhante ao resolvido abaixo. O problema é que
> > > os textos que trabalho são XML.
> > >
> > > O texto passa por uma validação onde indica tags que estão com erro.
> > Esses erros seriam problemas de estrutura como tags que fechamento ou
> > não que podem/devem estar contidas noutras tags ou seria um problema
> > relacionado ao conteúdo?
> >
> >
> > > Para análise preciso separar o conteúdo entre as tags indicadas, mas o
> > > problema é que o arquivo vem com várias tags na mesma linha,
> > > utilizando o exemplo da mensagem abaixo, ficaria parecido com isso:
> > >
> > > <body><div id="principal"><div id="lateralEsquerdo"><ul id=menuesquerdo>
> > > <li>Teste</li></ul> </div><div id="Conteudo"><h3>This is a header</h3>
> > > <p>This is a paragraph.</p><h3>This is a header</h3><p>This is a
> > > paragraph.</p>
> > > <h3>This is a header</h3><p>This is a paragraph.</p></div><div
> > > id="lateralDireito"><ul
> > id=menudireito><li>Teste</li></ul></div></div><div
> > > id="rodape">
> > > <ul id=menuesquerdo><li>Teste<li>
> > > </ul></div></body>
> > >
> > > Tem alguma forma de mostrar apenas o conteúdo da tag solicitada,
> > excluindo
> > > tudo que vier antes da tag inicial e tudo que vier depois da tag final?
> > Seguindo essa abordagem textual, podemos usar expressões regulares com
> > sed ou grep como quebra-galho para se obter algumas informações.
> > Dependendo da demanda, não resolverá de fato o seu problema.
> >
> > Talvez a melhor solução fosse mais adequado analisar linguagens/parses
> > de XML e HTML.
> >
> >
> > > Poderiam me ajudar? Porque até agora não encontrei solução.
> > Dê uma olhada no linguagem xpath[1], no xsh[2] (meu favorito), no
> > xmllint[3] e no xmlstarlet[4].
> >
> > [1] http://www.w3.org/TR/xpath20/
> > [2] http://xsh.sourceforge.net/
> > [3] http://xmlsoft.org/xmllint.html
> > [4] http://xmlstar.sourceforge.net/
> >
> > > Obrigado.
> > >
> > > Wilton Furtado Amaro
> >
> > []'s.
> > --
> > "Não manejo bem as palavras
> > Mas manipulo bem as strings."
> > ------------------------------
> > http://tecnoveneno.blogspot.com

Para resolver este problema é relativamente simples, basta acrescentar
comandos para remover o que vem antes e depois da TAG, respectivamente
"s/.*\(<Cli\)/\1/" e "s/\(<\/Cli>\).*/\1/"

Neste caso eu coloquei na expressão regular os "\(" e "\)" para não ter
que repetir o que está entre eles, mas somente "\1". É o mesmo que:
"s/.*<Cli/<Cli/" e "s/<\/Cli>.*/<\/Cli>/"

Veja:

$ sed -n '/<Cli
/{:a;/<\/Cli>/!{N;ba};s/.*\(<Cli\)/\1/;s/\(<\/Cli>\).*/\1/;p}' temp.txt
<Cli Tp="2" Cd="00038166" Autorzc="S" PorteCli="1" TpCtrl="01"
IniRelactCli="2010-01-01" CongEcon="000000" ClassCli="AA"><Op
DetCli="00038166000288" Contrt="ABC123" NatuOp="01" Mod="0101"
OrigemRec="0101" Indx="11" VarCamb="790" DtVencOp="2020-01-01"
ClassOp="AA" CEP="00000000" TaxEft="20.25" DtContr="2010-01-01"
ProvConsttd="1000.0" CaracEspecial="02;03">
<Venc v110="10000" v120="10000" v130="10000" v140="10000"
v150="10000"/><Gar Tp="0902" Ident="22222222" PercGar="100"/>
</Op><Op DetCli="00038166000369" Contrt="XYZ123" NatuOp="01" Mod="0101"
OrigemRec="0101" Indx="11" VarCamb="790" DtVencOp="2020-01-01"
ClassOp="AA" CEP="00000000" TaxEft="54.23" DtContr="2010-01-01"
ProvConsttd="1000.0"><Venc v110="20000" v120="20000" v130="20000"
v140="20000" v150="20000"/><Gar Tp="0102" VlrOrig="100000"
VlrData="100000" DtReav="2010-10-01"/>
</Op></Cli>

Na verdade, o problema ao qual me referia era se houvesse dentro da TAG
outra TAG com o mesmo nome (TAGs recursivas). Exemplo:

... <Cli Tp="1" ...> ... <Cli Tp="2" ...> ... </Cli> ... </Cli> ...

Se eu quiser extrair a TAG "<Cli Tp=\"2\"", tranquilo:

<Cli Tp="2" ...> ... </Cli>

Mas se eu quiser extrair a TAG "<Cli Tp=\"1\"", complica. No lugar de:

<Cli Tp="1" ...> ... <Cli Tp="2" ...> ... </Cli> ... </Cli>

Eu obteria:

<Cli Tp="1" ...> ... <Cli Tp="2" ...> ... </Cli>

É um desafio interessante, caso seja for possível, conseguir fazer isso
com SED....

Em 21/12/2011 21:37, Wilton Furtado Amaro escreveu:
> Boa noite,
>
> Acho que não expliquei bem o que quero.
> Sei que o sed captura toda a linha que tiver o elemento procurado. No
> assunto deste tópico foi apresentado uma forma de buscar um texto que está
> entre tags mesmo em várias linhas.
> O que gostaria é de que, alem disso, o comando retornasse apenas o texto
> que se deseja mesmo havendo outro texto nas linhas desses.
> Vamos utilizar o texto abaixo como exemplo(para melhor visualização, ver no
> pastebin: http://pastebin.com/KbtW7P0D)
> (...)
>
> Digamos, que eu precise apenas do conteúdo da tag "Cli". Utilizando o
> comando sed abordado no tópico, o resultado seria:
> (...)
>
> Mas, o que eu preciso é apenas o conteúdo da tag "Cli":
> (...)
>
> Observem que, para conseguir o resultado acima, tive que retirar o que
> estava antes da tag<Cli..., e o que veio depois da tag de
> fechamento(</Cli>). Mas fiz isso manualmente.
> Tem alguma forma de obter este resultado de forma automática?
>
> Agradeço a colaboração.
>
> Wilton
>

Pessoal, acho que consegui:

$ test="aaa <Cli Tp=\"1\" bbb> ccc <Cli Tp=\"2\" ddd> eee </Cli> fff </Cli> ggg"

$ echo $test | sed -n '/.*<\(Cli
Tp="1"\)/{s//<.\1/;:a;/<\/Cli>/!{N;ba};s/<\/Cli>/<.\/Cli>/;/<Cli.*<\.\/Cli/{s/<C\
li/<.Cli>/;ba};s/\(.*<\.\/Cli>\).*/\1/;s/<\./</g;p}'
<Cli Tp="1" bbb> ccc <Cli> Tp="2" ddd> eee </Cli> fff </Cli>

$ echo $test | sed -n '/.*<\(Cli
Tp="2"\)/{s//<.\1/;:a;/<\/Cli>/!{N;ba};s/<\/Cli>/<.\/Cli>/;/<Cli.*<\.\/Cli/{s/<C\
li/<.Cli>/;ba};s/\(.*<\.\/Cli>\).*/\1/;s/<\./</g;p}'
<Cli Tp="2" ddd> eee </Cli>

Se houver a possibilidade de haver esta TAG mais de uma vez em
uma linha, então será melhor fazer um pré-tratamento:

$ sed 's/<Cli Tp="2"/\n&/g' temp.txt | ./buscatag.sed

Sendo "buscatag.sed" um arquivo contendo o seguinte script com
comentários:

#!/bin/sed -nf
# Extraindo a TAG <Cli...>...</Cli> com SubTAGs do mesmo tipo

# Expressão regular já com os marcadores "\(" e "\)"
/.*<\(Cli Tp="2"\)/{
   # Remove os caracteres precedentes e marca a TAG encontrada
   s//<.\1/;
   # Enquanto não encontrar a TAG final </Cli>:
   :a;
   /<\/Cli>/!{
     # Junte a linha atual com a linha seguinte
     N;
     ba
   };
   # Marque a TAG final
   s/<\/Cli>/<.\/Cli>/;
   # Se a TAG final fecha uma SubTAG
   /<Cli.*<\.\/Cli/{
     # Marque a SubTAG
     s/<Cli/<.Cli>/;
     # E repita o loop
     ba
   };
   # Remove os caracteres subsequentes à TAG final
   s/\(.*<\.\/Cli>\).*/\1/;
   # Remove os marcadores
   s/<\./</g;
   # Exibe o conteúdo trabalhado
   p
}

--- Em sed-br@..., Marcio Gil <marciomgil@...>
escreveu:
>
> Na verdade, o problema ao qual me referia era se houvesse
> dentro da TAG outra TAG com o mesmo nome (TAGs recursivas).
> Exemplo:
>
> ... <Cli Tp="1" ...> ... <Cli Tp="2" ...> ... </Cli> ... </Cli>
> ...
>
> Se eu quiser extrair a TAG "<Cli Tp=\"2\"", tranquilo:
>
> <Cli Tp="2" ...> ... </Cli>
>
> Mas se eu quiser extrair a TAG "<Cli Tp=\"1\"", complica. No
> lugar de:
>
> <Cli Tp="1" ...> ... <Cli Tp="2" ...> ... </Cli> ... </Cli>
>
> Eu obteria:
>
> <Cli Tp="1" ...> ... <Cli Tp="2" ...> ... </Cli>
>
> É um desafio interessante, caso seja for possível, conseguir
> fazer isso com SED....
>

Boa tarde, gostaria, se for possivel, esclarecer minha duvida.

Sei que há varios comando que podemos usar na linha de comando para
visualizar/download de uma pagina de site, tais como uasr o CURL, W3M,
LYNX, WGET entre outro, mas minha dúvida quanto ao firefox.


é possivel usar o FIREFOX na linha de comando com direcionamento do codigo fonte
ao arquivo?


Usando o comando abaixo ele abre a pagina, mas como faço para redirecionar esse
resultado.
firefox "http://www.google.com.br" >> google.html

[As partes desta mensagem que não continham texto foram removidas]

não sou expert, mas ao executar o programa firefox na linha de comando, ele
abrira o cliente gráfico do firefox usando como argumento a URL passada,
não há saida para o terminal. você pode, ao abrir o firefox, usar "salvar
como..."

Não posso te ajudar mais que isso, não entendi o porquê do comando...

Em 25 de janeiro de 2012 14:57, Carla da silva
<manoeljuridico@...>escreveu:

> **
>
>
> Boa tarde, gostaria, se for possivel, esclarecer minha duvida.
>
> Sei que há varios comando que podemos usar na linha de comando para
> visualizar/download de uma pagina de site, tais como uasr o CURL, W3M,
> LYNX, WGET entre outro, mas minha dúvida quanto ao firefox.
>
> é possivel usar o FIREFOX na linha de comando com direcionamento do codigo
> fonte ao arquivo?
>
> Usando o comando abaixo ele abre a pagina, mas como faço para redirecionar
> esse resultado.
> firefox "http://www.google.com.br" >> google.html
>
> [As partes desta mensagem que não continham texto foram removidas]
>
>
>


[As partes desta mensagem que não continham texto foram removidas]

Olá Srs

Tenho uma String com uma coordenada geográfica latitude e longitude, assim:

-49.1406567141366 -25.4435160197174,-49.1416468944387
-25.4437000779372,-49.1423886123512 -25.4442827102467,-49.1433292409292
-25.4443758554799

Preciso inverter a posições devendo ficar assim:

-25.4435160197174 -49.1406567141366 -25.4437000779372 -49.1416468944387......

utilizando PHP tinha essa função :
//expressão regular, by Nasair Júnior da Silva, que inverte as longitudes e as
latitudes
	 $resultado = preg_replace(';([-0-9\.]+)[ ,]([-0-9\.-]+);','\2 \1',$resultado);

Mas agora que estou migrando a aplicação pra java não funciona.

Alguma idéia de como fazer?

public String resultado = '-49.1406567141366
-25.4435160197174,-49.1416468944387 -25.4437000779372,-49.1423886123512
-25.4442827102467,-49.1433292409292 -25.4443758554799';

resultado.replaceAll('([-0-9\.]+)[ ,]([-0-9\.-]+)','$2 $1');


algo por ai, (não testei nada)

Em 23 de maio de 2012 10:18, daniel_plim <danielpdelima@...> escreveu:

> **
>
>
> Olá Srs
>
> Tenho uma String com uma coordenada geográfica latitude e longitude, assim:
>
> -49.1406567141366 -25.4435160197174,-49.1416468944387
> -25.4437000779372,-49.1423886123512 -25.4442827102467,-49.1433292409292
> -25.4443758554799
>
> Preciso inverter a posições devendo ficar assim:
>
> -25.4435160197174 -49.1406567141366 -25.4437000779372
> -49.1416468944387......
>
> utilizando PHP tinha essa função :
> //expressão regular, by Nasair Júnior da Silva, que inverte as longitudes
> e as latitudes
> $resultado = preg_replace(';([-0-9\.]+)[ ,]([-0-9\.-]+);','\2
> \1',$resultado);
>
> Mas agora que estou migrando a aplicação pra java não funciona.
>
> Alguma idéia de como fazer?
>
>
>


[As partes desta mensagem que não continham texto foram removidas]

Opa.

Perfeito, estava quase chegando lá só faltou os [], mas agora está blza.

Obrigado.


--- Em sed-br@..., Jan FRS <janfrs3@...> escreveu
>
> public String resultado = '-49.1406567141366
> -25.4435160197174,-49.1416468944387 -25.4437000779372,-49.1423886123512
> -25.4442827102467,-49.1433292409292 -25.4443758554799';
>
> resultado.replaceAll('([-0-9\.]+)[ ,]([-0-9\.-]+)','$2 $1');
>
>
> algo por ai, (não testei nada)
>
> Em 23 de maio de 2012 10:18, daniel_plim <danielpdelima@...> escreveu:
>
> > **
> >
> >
> > Olá Srs
> >
> > Tenho uma String com uma coordenada geográfica latitude e longitude, assim:
> >
> > -49.1406567141366 -25.4435160197174,-49.1416468944387
> > -25.4437000779372,-49.1423886123512 -25.4442827102467,-49.1433292409292
> > -25.4443758554799
> >
> > Preciso inverter a posições devendo ficar assim:
> >
> > -25.4435160197174 -49.1406567141366 -25.4437000779372
> > -49.1416468944387......
> >
> > utilizando PHP tinha essa função :
> > //expressão regular, by Nasair Júnior da Silva, que inverte as longitudes
> > e as latitudes
> > $resultado = preg_replace(';([-0-9\.]+)[ ,]([-0-9\.-]+);','\2
> > \1',$resultado);
> >
> > Mas agora que estou migrando a aplicação pra java não funciona.
> >
> > Alguma idéia de como fazer?
> >
> >
> >
>
>
> [As partes desta mensagem que não continham texto foram removidas]
>

Olá,

Estou tendo dificuldades em explicar essa validação feita em um código java:

"/(.*?/|.*?\\\\)?([^\\./|^\\.\\\\]+)(?:\\.([^\\\\]*)|)"

Sei que ela é usada para validar o path. Por exemplo: com ela o path
/teste/meudir é válido, enquanto o /teste/meudir/ é inválido.

Peço ajuda para tentar entende-la melhor.

Grato,
--
Pahim

Opa, vou tentar dismiuçar sua regex:

"/(.*?/|.*?\\\\)?([^\\./|^\\.\\\\]+)(?:\\.([^\\\\]*)|)"

primeiro vamos assumir que cada contra-barra *leia-se: \ , precisa ser
escapada uma contra barra, para escapá-la, por isso
sempre se precisa de quatro contra-barras para representar uma (me corrijam
se eu estiver errado) vamos sumir com elas

"/(.*?/|.*?\)?([^\./|^\.\]+)(?:\.([^\]*)|)"

agora vamos tentar ler da esquerda para a direita

/ # uma barra

(.*?/|.*?\)? # qualquer coisa n vezes ou qualquer coisa n vezes mais
contra-barra, tudo opcional - grupo1

([^\./|^\.\]+) # um ou mais caracteres, estes sendo qualquer coisa que não
seja barra, contra-barra, pipe, ponto literal, grupo2

(?:\.([^\]*)|) # grupo não salvável (?:), ponto literal, grupo3 zero ou
mais caracteres que não sejam contra-barra ou nada



Em 14 de junho de 2012 13:49, Amador Pahim <amador@...> escreveu:

> "/(.*?/|.*?\\\\)?([^\\./|^\\.\\\\]+)(?:\\.([^\\\\]*)|)"
>


[As partes desta mensagem que não continham texto foram removidas]

Obrigado Jan, esclareceu muito.

Só fiquei com uma dúvida... o que significa "grupo não salvável"?

Abraco.

2012/6/14 Jan FRS <janfrs3@...>

> **
>
>
> Opa, vou tentar dismiuçar sua regex:
>
>
> "/(.*?/|.*?\\\\)?([^\\./|^\\.\\\\]+)(?:\\.([^\\\\]*)|)"
>
> primeiro vamos assumir que cada contra-barra *leia-se: \ , precisa ser
> escapada uma contra barra, para escapá-la, por isso
> sempre se precisa de quatro contra-barras para representar uma (me corrijam
> se eu estiver errado) vamos sumir com elas
>
>
> "/(.*?/|.*?\)?([^\./|^\.\]+)(?:\.([^\]*)|)"
>
> agora vamos tentar ler da esquerda para a direita
>
> / # uma barra
>
> (.*?/|.*?\)? # qualquer coisa n vezes ou qualquer coisa n vezes mais
> contra-barra, tudo opcional - grupo1
>
> ([^\./|^\.\]+) # um ou mais caracteres, estes sendo qualquer coisa que não
> seja barra, contra-barra, pipe, ponto literal, grupo2
>
> (?:\.([^\]*)|) # grupo não salvável (?:), ponto literal, grupo3 zero ou
> mais caracteres que não sejam contra-barra ou nada
>
> Em 14 de junho de 2012 13:49, Amador Pahim <amador@...> escreveu:
>
>
> > "/(.*?/|.*?\\\\)?([^\\./|^\\.\\\\]+)(?:\\.([^\\\\]*)|)"
> >
>
> [As partes desta mensagem que não continham texto foram removidas]
>
>
>



--
Pahim


[As partes desta mensagem que não continham texto foram removidas]

Sempre que você abre um grupo usando o caracterere parentese (.*), o
conteudo deste
parêntese é salvo para ser usado na string de substituição.

Por padrão eles são salvos nas variaveis $1, $2, $3 etc. dependendo da
ordem em que forem abertos.

Porém quando você o declara como um grupo não salvável usando a sintaxe (?:
), o conteudo dentro
deste parêntese é agrupado, porém não será salvo para ser referenciado por
uma variavel após o casamento, isto pode ser úlil caso você necessite
agrupar padrões para usar na alternação mas não queira que este preencha
alguma variável da referênciamento, deixando as variáveis organizadas.

Existem outras formas de organizar estar variáveis como por exemplo dar
nome aos grupos (named groups) usando a sintaxe (?<nome>regex)  o padrão
casado por regex ficará salvo na variavel $nome.

Tudo depende da sua necessidade e disposição....


Jan Silva*
*


Em 15 de junho de 2012 08:49, Amador Pahim <amador@...> escreveu:

> Obrigado Jan, esclareceu muito.
>
> Só fiquei com uma dúvida... o que significa "grupo não salvável"?
>
> Abraco.
>
> 2012/6/14 Jan FRS <janfrs3@...>
>
> > **
> >
> >
> > Opa, vou tentar dismiuçar sua regex:
> >
> >
> > "/(.*?/|.*?\\\\)?([^\\./|^\\.\\\\]+)(?:\\.([^\\\\]*)|)"
> >
> > primeiro vamos assumir que cada contra-barra *leia-se: \ , precisa ser
> > escapada uma contra barra, para escapá-la, por isso
> > sempre se precisa de quatro contra-barras para representar uma (me
> corrijam
> > se eu estiver errado) vamos sumir com elas
> >
> >
> > "/(.*?/|.*?\)?([^\./|^\.\]+)(?:\.([^\]*)|)"
> >
> > agora vamos tentar ler da esquerda para a direita
> >
> > / # uma barra
> >
> > (.*?/|.*?\)? # qualquer coisa n vezes ou qualquer coisa n vezes mais
> > contra-barra, tudo opcional - grupo1
> >
> > ([^\./|^\.\]+) # um ou mais caracteres, estes sendo qualquer coisa que
> não
> > seja barra, contra-barra, pipe, ponto literal, grupo2
> >
> > (?:\.([^\]*)|) # grupo não salvável (?:), ponto literal, grupo3 zero ou
> > mais caracteres que não sejam contra-barra ou nada
> >
> > Em 14 de junho de 2012 13:49, Amador Pahim <amador@...> escreveu:
> >
> >
> > > "/(.*?/|.*?\\\\)?([^\\./|^\\.\\\\]+)(?:\\.([^\\\\]*)|)"
> > >
> >
> > [As partes desta mensagem que não continham texto foram removidas]
> >
> >
> >
>
>
>
> --
> Pahim
>
>
> [As partes desta mensagem que não continham texto foram removidas]
>
>
>
> ------------------------------------
>
> --
> para sair da lista: sed-br-unsubscribe@... do Yahoo!
> Grupos
>
>
>


[As partes desta mensagem que não continham texto foram removidas]

Estou tentando entender/dominar o sed e empaquei num dos exemplos do Thobias
(http://thobias.org/doc/sosed.html#toc48):

Imprimir N linhas antes, a linha da string e M linhas após uma string I:
sed -n '/quarto/{x;p;x;N;N;p;q;};1!{H;g;};1,2!s/[^\n]*\n//;h;'

Pelo que eu entendi, a coisa segue assim:

- A primeira linha é reservada no buffer space (BS).
- A segunda é anexada ao BS e o pattern space (PS) é substituído conteúdo do BS,
isto é, após o 1!{H;g;} o BS e PS estão iguais, contendo a primeira e a segunda
linha.
- A terceira linha é anexada ao BS e em seguida o PS é substituído pelo BS que
agora contém as três primeiras linhas, em seguida é aplicado o comando
1,2!s/[^\n]*\n// que vai apagar a terceira linha do PS deixando somente as duas
primeiras que logo em seguidas vão ser lançadas ao BS pelo último comando h

Ou seja, antes de chegar à linha do /quarto/, o BS deveria ter reservado apenas
a primeira e a segunda linhas do texto, então, segundo minha interpretação, ele
nunca poderia imprimir, de início, as duas linhas imediatamente anteriores
{x;p... reservadas no BS

Não sei se ficou claro, mas onde foi que eu comi mosca?

PS. Os exemplos são ótimos, mas a falta de uma explicação pontual de como os
comandos estão agindo deixa a gente às cegas.

Pessoal,

Estou tratando arquivos txt para posteriormente inser em um BD mysql.

Entretanto estou apanhando de um arquivo que tem palavra acentuada. Neste caso
não estou conseguindo filtrar a palavra com acento....

Se alguem puder ajudar, agradeço desde já !!

Segue a situação concreta:

arquivo base: probguai3.txt (na pasta de arquivos do grupo)

o comando sed para adequação do meu arquivo é o seguinte:

----
# substitui: dd-mm-aaaa /t hh:mm:ss POR aaaa-mm-dd hh:mm:ss
# substituição de 'localidade /t sentido' por codificação numérica

sed -e'
s:^\(..\)-\(..\)-\(....\)\t:\3-\2-\1 :;
s:Mundo Novo\tGuaira(PR):021:;
s:Mundo Novo\tGuaíra(PR):021:'
probguai3.txt > saida.txt
-----

Funciona tudo correto, exceto pelo fato de que as linhas em que aparem a palavra
"Guaíra" acentuada ele não faz a alteração pelo codigo 021. Já quando aparece a
palavra "Guaira" se acento, ele faz as alterações.

Qq. tipo de busca que tento fazer com as palavras acentuadas não está funcionado
no sed..... devo estar esquecendo de algo...

abraço !!!

Bom dia,
Seu script e seu texto estão no mesmo encoding?
Att,
Geraldo

Silvio <silviorf@...> wrote:

>Pessoal,
>
>Estou tratando arquivos txt para posteriormente inser em um BD mysql.
>
>Entretanto estou apanhando de um arquivo que tem palavra acentuada. Neste caso
não estou conseguindo filtrar a palavra com acento....
>
>Se alguem puder ajudar, agradeço desde já !!
>
>Segue a situação concreta:
>
>arquivo base: probguai3.txt (na pasta de arquivos do grupo)
>
>o comando sed para adequação do meu arquivo é o seguinte:
>
>----
># substitui: dd-mm-aaaa /t hh:mm:ss POR aaaa-mm-dd hh:mm:ss
># substituição de 'localidade /t sentido' por codificação numérica
>
>sed -e'
>s:^\(..\)-\(..\)-\(....\)\t:\3-\2-\1 :;
>s:Mundo Novo\tGuaira(PR):021:;
>s:Mundo Novo\tGuaíra(PR):021:'
>probguai3.txt > saida.txt
>-----
>
>Funciona tudo correto, exceto pelo fato de que as linhas em que aparem a
palavra "Guaíra" acentuada ele não faz a alteração pelo codigo 021. Já
quando aparece a palavra "Guaira" se acento, ele faz as alterações.
>
>Qq. tipo de busca que tento fazer com as palavras acentuadas não está
funcionado no sed..... devo estar esquecendo de algo...
>
>abraço !!!
>
>
>
>
>
>
>
>
>
>------------------------------------
>
>--
>para sair da lista: sed-br-unsubscribe@... do Yahoo! Grupos
>
>

2012/7/31 Silvio <silviorf@...>

> **
>
>
> Pessoal,
>
> Estou tratando arquivos txt para posteriormente inser em um BD mysql.
>
> Entretanto estou apanhando de um arquivo que tem palavra acentuada. Neste
> caso não estou conseguindo filtrar a palavra com acento....
>
> Se alguem puder ajudar, agradeço desde já !!
>
> Segue a situação concreta:
>
> arquivo base: probguai3.txt (na pasta de arquivos do grupo)
>
> o comando sed para adequação do meu arquivo é o seguinte:
>
> ----
> # substitui: dd-mm-aaaa /t hh:mm:ss POR aaaa-mm-dd hh:mm:ss
> # substituição de 'localidade /t sentido' por codificação numérica
>
> sed -e'
> s:^\(..\)-\(..\)-\(....\)\t:\3-\2-\1 :;
> s:Mundo Novo\tGuaira(PR):021:;
> s:Mundo Novo\tGuaíra(PR):021:'
> probguai3.txt > saida.txt
> -----
>
> Funciona tudo correto, exceto pelo fato de que as linhas em que aparem a
> palavra "Guaíra" acentuada ele não faz a alteração pelo codigo 021. Já
> quando aparece a palavra "Guaira" se acento, ele faz as alterações.
>
> Qq. tipo de busca que tento fazer com as palavras acentuadas não está
> funcionado no sed..... devo estar esquecendo de algo...
>
> abraço !!!
>

o Encoding do arquivo e do programa sed estão utilizando o mesmo encoding?

--
Bruno Coimbra
bbcoimbra@...

Existem 11 tipos de pessoas no mundo:
As que entendem binário,
as que acham que entendem
e as que não entendem.


[As partes desta mensagem que não continham texto foram removidas]

Boa Tarde

fiz aqui e deu certo

echo -e "dd-mm-aaaa\thh:mm:ss - Mundo Novo\tGuaíra(PR)" | sed -r
's/(..)-(..)-(.{4})\t/\3-\2-\1\t/;s/Mundo Novo\tGua[ií]ra\(PR\)/021/'
echo -e "dd-mm-aaaa\thh:mm:ss - Mundo Novo\tGuaira(PR)" | sed -r
's/(..)-(..)-(.{4})\t/\3-\2-\1\t/;s/Mundo Novo\tGua[ií]ra\(PR\)/021/'

ambos retornaram
aaaa-mm-dd      hh:mm:ss - 021

Agora vc pode fazer assim pra não esquentar muito a cabeça
sed -r 's/(..)-(..)-(.{4})\t/\3-\2-\1\t/;s/Mundo Novo\tGu.*ra\(PR\)/021/'

e desconsidera esse caracter estranho...

Atenciosamente

Robson Alexandre

Em 31 de julho de 2012 10:49, Bruno Coimbra <bbcoimbra@...> escreveu:

> **
>
>
> 2012/7/31 Silvio <silviorf@...>
>
> > **
>
> >
> >
> > Pessoal,
> >
> > Estou tratando arquivos txt para posteriormente inser em um BD mysql.
> >
> > Entretanto estou apanhando de um arquivo que tem palavra acentuada. Neste
> > caso não estou conseguindo filtrar a palavra com acento....
> >
> > Se alguem puder ajudar, agradeço desde já !!
> >
> > Segue a situação concreta:
> >
> > arquivo base: probguai3.txt (na pasta de arquivos do grupo)
> >
> > o comando sed para adequação do meu arquivo é o seguinte:
> >
> > ----
> > # substitui: dd-mm-aaaa /t hh:mm:ss POR aaaa-mm-dd hh:mm:ss
> > # substituição de 'localidade /t sentido' por codificação numérica
> >
> > sed -e'
> > s:^\(..\)-\(..\)-\(....\)\t:\3-\2-\1 :;
> > s:Mundo Novo\tGuaira(PR):021:;
> > s:Mundo Novo\tGuaíra(PR):021:'
> > probguai3.txt > saida.txt
> > -----
> >
> > Funciona tudo correto, exceto pelo fato de que as linhas em que aparem a
> > palavra "Guaíra" acentuada ele não faz a alteração pelo codigo 021. Já
> > quando aparece a palavra "Guaira" se acento, ele faz as alterações.
> >
> > Qq. tipo de busca que tento fazer com as palavras acentuadas não está
> > funcionado no sed..... devo estar esquecendo de algo...
> >
> > abraço !!!
> >
>
> o Encoding do arquivo e do programa sed estão utilizando o mesmo encoding?
>
> --
> Bruno Coimbra
> bbcoimbra@...
>
> Existem 11 tipos de pessoas no mundo:
> As que entendem binário,
> as que acham que entendem
> e as que não entendem.
>
> [As partes desta mensagem que não continham texto foram removidas]
>
>
>


[As partes desta mensagem que não continham texto foram removidas]

Pessoal,

Antes de mais nada muito obrigado pela rápida resposta !!!

ACHO que tem algo errado no meu bash... ou então tem algo a ver com a questão do
"encoding" do arquivo. Sei lá... vou tentar explicar

- usando a solução do Robson, não resolveu aqui....
- com relação ao encoding do script e do arquivo txt, não sei se é o caso, pois
mesmo qdo. digito direto do terminal tenho o mesmo problema.

Pra se ter uma ideia, segue o retorno, no meu terminal, quando eu apenas dou o
comando para excluir da saida as linhas que tenham o conteúdo "Gu.*ra" (conforme
sugerido pelo Robson). Pela lógica, usando aquele arquivo que mandei como teste,
não deveria sair NADA no retorno já que todas as linhas tem ou "Guaíra" ou
"Guaira". Porém.... segue o resultado:

-----
silvio@rednote:~/projeto-sinivem$ sed -e '/Gu.*ra/d' probguai3.txt | more
14-05-2010 00:02:13 HRG8150 Mundo Novo Gua�ra(PR)
14-05-2010 00:02:19 HRS6207 Mundo Novo Gua�ra(PR)
14-05-2010 00:02:19 HRS6207 Mundo Novo Gua�ra(PR)
14-05-2010 00:04:35 MAH8529 Mundo Novo Gua�ra(PR)
14-05-2010 00:06:23 ARF6229 Mundo Novo Gua�ra(PR)
14-05-2010 00:06:25 ARF6229 Mundo Novo Gua�ra(PR)
14-05-2010 00:06:25 ARF6229 Mundo Novo Gua�ra(PR)
14-05-2010 00:12:13 BAJ0707 Mundo Novo Gua�ra(PR)
14-05-2010 00:15:55 AAI4940 Mundo Novo Gua�ra(PR)
14-05-2010 00:15:56 ILY8018 Mundo Novo Gua�ra(PR)
14-05-2010 00:15:59 AAI4940 Mundo Novo Gua�ra(PR)
14-05-2010 00:15:59 AAI4940 Mundo Novo Gua�ra(PR)
14-05-2010 00:16:47 MFT0519 Mundo Novo Gua�ra(PR)
------

Estou com a impressão que meu bash não está conseguindo tratar arquivos com
letras acentuadas (o que seria muito estranho).
Ou então estou realmente apanhando da codificação do arquivo. A propósito,
tentei (via gedit) mudar a codificação do arquivo, mas tb. sem sucesso.

Abraço e agradeço novamente a ajuda.


--- Em sed-br@..., Robson Alexandre <alexandrerobson@...>
escreveu
>
> Boa Tarde
>
> fiz aqui e deu certo
>
> echo -e "dd-mm-aaaa\thh:mm:ss - Mundo Novo\tGuaíra(PR)" | sed -r
> 's/(..)-(..)-(.{4})\t/\3-\2-\1\t/;s/Mundo Novo\tGua[ií]ra\(PR\)/021/'
> echo -e "dd-mm-aaaa\thh:mm:ss - Mundo Novo\tGuaira(PR)" | sed -r
> 's/(..)-(..)-(.{4})\t/\3-\2-\1\t/;s/Mundo Novo\tGua[ií]ra\(PR\)/021/'
>
> ambos retornaram
> aaaa-mm-dd      hh:mm:ss - 021
>
> Agora vc pode fazer assim pra não esquentar muito a cabeça
> sed -r 's/(..)-(..)-(.{4})\t/\3-\2-\1\t/;s/Mundo Novo\tGu.*ra\(PR\)/021/'
>
> e desconsidera esse caracter estranho...
>
> Atenciosamente
>
> Robson Alexandre
>
> Em 31 de julho de 2012 10:49, Bruno Coimbra <bbcoimbra@...> escreveu:
> > o Encoding do arquivo e do programa sed estão utilizando o mesmo encoding?
> >
> > --
> > Bruno Coimbra
> > bbcoimbra@...

Complementando:

no meu terminal o "caractere" acentuado aparece como um sinal de interrogação
extranho e não como o código "�" que apareceu na msg que mandei ao usar o
copiar/colar.


--- Em sed-br@..., "Silvio" <silviorf@...> escreveu
>
> Pessoal,
>
> Antes de mais nada muito obrigado pela rápida resposta !!!
>
> ACHO que tem algo errado no meu bash... ou então tem algo a ver com a questão
do "encoding" do arquivo. Sei lá... vou tentar explicar
>
> - usando a solução do Robson, não resolveu aqui....
> - com relação ao encoding do script e do arquivo txt, não sei se é o caso,
pois mesmo qdo. digito direto do terminal tenho o mesmo problema.
>
> Pra se ter uma ideia, segue o retorno, no meu terminal, quando eu apenas dou o
comando para excluir da saida as linhas que tenham o conteúdo "Gu.*ra" (conforme
sugerido pelo Robson). Pela lógica, usando aquele arquivo que mandei como teste,
não deveria sair NADA no retorno já que todas as linhas tem ou "Guaíra" ou
"Guaira". Porém.... segue o resultado:
>
> -----
> silvio@rednote:~/projeto-sinivem$ sed -e '/Gu.*ra/d' probguai3.txt | more
> 14-05-2010 00:02:13 HRG8150 Mundo Novo Gua�ra(PR)
> 14-05-2010 00:02:19 HRS6207 Mundo Novo Gua�ra(PR)
> 14-05-2010 00:02:19 HRS6207 Mundo Novo Gua�ra(PR)
> 14-05-2010 00:04:35 MAH8529 Mundo Novo Gua�ra(PR)
> 14-05-2010 00:06:23 ARF6229 Mundo Novo Gua�ra(PR)
> 14-05-2010 00:06:25 ARF6229 Mundo Novo Gua�ra(PR)
> 14-05-2010 00:06:25 ARF6229 Mundo Novo Gua�ra(PR)
> 14-05-2010 00:12:13 BAJ0707 Mundo Novo Gua�ra(PR)
> 14-05-2010 00:15:55 AAI4940 Mundo Novo Gua�ra(PR)
> 14-05-2010 00:15:56 ILY8018 Mundo Novo Gua�ra(PR)
> 14-05-2010 00:15:59 AAI4940 Mundo Novo Gua�ra(PR)
> 14-05-2010 00:15:59 AAI4940 Mundo Novo Gua�ra(PR)
> 14-05-2010 00:16:47 MFT0519 Mundo Novo Gua�ra(PR)
> ------
>
> Estou com a impressão que meu bash não está conseguindo tratar arquivos com
letras acentuadas (o que seria muito estranho).
> Ou então estou realmente apanhando da codificação do arquivo. A propósito,
tentei (via gedit) mudar a codificação do arquivo, mas tb. sem sucesso.
>
> Abraço e agradeço novamente a ajuda.
>
>
> --- Em sed-br@..., Robson Alexandre <alexandrerobson@> escreveu
> >
> > Boa Tarde
> >
> > fiz aqui e deu certo
> >
> > echo -e "dd-mm-aaaa\thh:mm:ss - Mundo Novo\tGuaíra(PR)" | sed -r
> > 's/(..)-(..)-(.{4})\t/\3-\2-\1\t/;s/Mundo Novo\tGua[ií]ra\(PR\)/021/'
> > echo -e "dd-mm-aaaa\thh:mm:ss - Mundo Novo\tGuaira(PR)" | sed -r
> > 's/(..)-(..)-(.{4})\t/\3-\2-\1\t/;s/Mundo Novo\tGua[ií]ra\(PR\)/021/'
> >
> > ambos retornaram
> > aaaa-mm-dd      hh:mm:ss - 021
> >
> > Agora vc pode fazer assim pra não esquentar muito a cabeça
> > sed -r 's/(..)-(..)-(.{4})\t/\3-\2-\1\t/;s/Mundo Novo\tGu.*ra\(PR\)/021/'
> >
> > e desconsidera esse caracter estranho...
> >
> > Atenciosamente
> >
> > Robson Alexandre
> >
> > Em 31 de julho de 2012 10:49, Bruno Coimbra <bbcoimbra@> escreveu:
> > > o Encoding do arquivo e do programa sed estão utilizando o mesmo encoding?
> > >
> > > --
> > > Bruno Coimbra
> > > bbcoimbra@
>

Mais uma indicação de que o problema não é com o camando do sed:
usando o grep, seguem saídas do terminal:

-----
silvio@rednote:~/projeto-sinivem$ grep Guaira probguai3.txt
14-05-2010 00:00:55 HRO2458 Mundo Novo Guaira(PR)
14-05-2010 00:01:15 HRO2459 Mundo Novo Guaira(PR)
14-05-2010 00:04:40 CDM8632 Mundo Novo Guaira(PR)

silvio@rednote:~/projeto-sinivem$ grep 'Gua.*ra' probguai3.txt
14-05-2010 00:00:55 HRO2458 Mundo Novo Guaira(PR)
14-05-2010 00:01:15 HRO2459 Mundo Novo Guaira(PR)
14-05-2010 00:04:40 CDM8632 Mundo Novo Guaira(PR)

silvio@rednote:~/projeto-sinivem$ grep 'Gu.*ra' probguai3.txt
14-05-2010 00:00:55 HRO2458 Mundo Novo Guaira(PR)
14-05-2010 00:01:15 HRO2459 Mundo Novo Guaira(PR)
14-05-2010 00:04:40 CDM8632 Mundo Novo Guaira(PR)

silvio@rednote:~/projeto-sinivem$ grep 'Gua[ií]ra' probguai3.txt
14-05-2010 00:00:55 HRO2458 Mundo Novo Guaira(PR)
14-05-2010 00:01:15 HRO2459 Mundo Novo Guaira(PR)
14-05-2010 00:04:40 CDM8632 Mundo Novo Guaira(PR)

silvio@rednote:~/projeto-sinivem$ grep 'Guaíra' probguai3.txt
silvio@rednote:~/projeto-sinivem$
----


> --- Em sed-br@..., "Silvio" <silviorf@> escreveu
> >
> > Pessoal,
> >
> > Antes de mais nada muito obrigado pela rápida resposta !!!
> >
> > ACHO que tem algo errado no meu bash... ou então tem algo a ver com a
questão do "encoding" do arquivo. Sei lá... vou tentar explicar
> >