Sed - Introdução a SED - Parte III

Julho 2017


Este documento é uma introdução a pratica da utilização do editor de flux "SED", que tenta cobrir certas funcionalidades bastante desconhecidas, para não dizer « " quase desconhecidas ", que fazem de "SED" uma ferramenta indispensável na caisa de ferramentas de qualquer luxiniano que deseja romper com os maniamentos do tratamento de arquivos via console e um shell.

Parte I
Parte II

Os exemplos

Substituições

nona ocorrência


1a ocorrência:
$ echo "azerty azerty azerty" | sed 's/az/qw/' 
qwerty azerty azerty 

2a ocorrência :
$ echo "azerty azerty azerty" | sed 's/az/qw/2' 
azerty qwerty azerty 

3ème ocorrência :
$ echo "azerty azerty azerty" | sed 's/az/qw/3' 
azerty azerty qwerty

Todas as ocorrências :
$ echo "azerty azerty azerty" | sed 's/az/qw/g' 
qwerty qwerty qwerty 

Substituir os finais de linhas por um espaço


sed ' 
:s  # etiqueta 
N  # adiciona-se a seguinte linha  
s/\n/ /  # se substitue os finais  de linha por um espaço 
b s  # conecta-se à etiqueta  
'
Em uma linha :
sed ':s;N;s/\n/ /;bs'

Afixar um intervalo entre 2 motivos sem os motivos


sed -n '/foo/,/bar/{//d;p}' arquivo
sed -n '/Mandriva/,/RedHat/{//d;p}'endereços.txt

Guloseima das expressões regulares


$ echo "azerty azerty azerty" | sed 's/a.*z/qw/' 
qwerty 

$ echo "azerty azerty azerty" | sed 's/a[^a]*z/qw/' 
qwerty azerty azerty

O comando "n"


Localizar uma linha por um motivo (/222/), carregar a linha seguinte no espaço de trabalho e substituir a 2ª ocorrência do número "3" por um "4" :
$ echo -e "111\n222\n333\n444" | sed  '/222/{n; s/3/4/2}' 
111 
222 
343 
444

Ao aficar a linha concernida na saída standard :
$ echo -e "111\n222\n333\n444" | sed -n '/222/{n; s/3/4/2p}' 
343

A mesma com letras:
$ echo -e "AAA\nBBB\nCCC\nDDD" | sed '/BBB/ {n;s/C/Z/2}' 
AAA 
BBB 
CZC 
DDD

Indentação do script com "sedsed" e explicações sumárias:
$ echo -e "AAA\nBBB\nCCC\nDDD" | sedsed -i '/BBB/ {n;s/C/Z/2}' 
/BBB/ {  # Seleciona-se a a linha com este motivo   
    n  # Coloca-se a linha seguinte no espaço de trabalho 
    s/C/Z/2 # Troca-se o 2° C por um Z  
}


É claro que estes 2 exemplos não estão lá somente por uma simples demonstração e não são nem um pouco otimizados nem adaptados no que se refere as substituições, que poderiam ter sido feitos visando diretamente a linha concernida.

Inverter 2 linhas


sed ' 
6 { # seleção da linha 
h # copia na memória anexa  
N # adiciona na memória principal da linha seguinte 
G # adição do conteúdo  da memória anexa à  memória principal 
 #+ a memória principal contem neste momento  #++ Linha n° 6\nLinha n°7\nLinha n° 6\n 
D # apagamento até o 1° caractere de fim de linha (\n) 
} 
'

Emu ma linha :
sed '6 {h;N;G;D}'

Apagamento de uma linha e inserção mais


#! /bin/sed -f 

1 h  # carregamento 1a linha memória sec=undária 
1 d  # apagamento 1a linha 
5 {   # selecionar a linha 5 
G  # adicionar o conteúdo da  memória secundária  à memória principal 
N  # adicionar linha seguinte (la 6) 
s/\n/ /g # substituir todos os status de linha (\n) por um espaço 
}

Sobre uma só linha :
sed -n '1 h; 1 d; 5 { G; N; s/\n/ /g};P' fich.txt 

Desassociar os comentários dos comandos


Passar todas as linhas de comentários que se encontram na mesma linha que o comando associado, sobre uma linha só em cima do comando:
sed ' 
/^#\|^$/! {  # Excluir as  linhas debutando por um quadrado e as linhas vazias 
/#/ {   # Se a linha contém um quadrado « # »  
h   # Cpoií-lo no espaço anexo. O otiginal está ainda no espaço de trabalho trabalho 
s/.*\(#.*\)/\1/  # Conserve spmente aqilo que se encontra depois do quadrado (incliusive o quadrado) 
x   # Trocar o espaço de trabalho com o espaço anexo 
s/\(.*\)#.*/\1/  # Conserve somente aquilo que se encontra antes do quadrado  
x   # Trocar o espaço de trabalho com o espaço anexo 
G   # Adicionar o conteúdo do espaço anexo ao espaço de trabalho 
} 
} 
' prog.sed

Somente sobre uma linha :
sed '/^#\|^$/!{/#/{h; s/.*\(#.*\)/\1/;x;s/\(.*\)#.*/\1/;x;G;}};' prog.sed

Afixagem condicionada


Afixar uma linha de comentário unicamente se a linha precedente estiver vazia.
sed -n ' 
/^$/ { 
n 
/^#/p 
} 
' fich2.txt

Somente sobre uma linha:
sed -n '/^$/{n;/^#/p}' fich2.txt

Emulação de grep

Exemplo 1


Emulação de: grep -A3 -B5 "motivo" arquivo

#!/bin/sh 

# Emulação de grep -A3 -B5 "motivo" arquivo
# Amplamente inspirada do script grep4.sh 
#no site: http://www.grymoire.com/Unix/Sed.html#uh-56 

casa "$#" in 
        1) ;; 

  • ) echo "Usage: $0 \motivo\" < arquivo";exit;;
esac; sed -n ' '/$1/' !{ # Motivo não satisfeito- adicionar a linha na memória anexa H # Recoloque-o na memória principal (espaço de trabalho) x # Conserve somnete 3 linhas no tamp memória tampão # 2 linhas correspondendo à .*\n.* # 3 linhas à .*\n.*\n.* # Apaga-se as linhas excedentes s/^.*\n\(.*\n.*\n.*\)$/\1/ # Colocar as 3 linhas (ou mais) na memória anexa de novo x } '/$1/' { # O motivo está satisfeito - Adicionar o conteúdo na memória principal # na memória secundária H # Tomar al inha seguinte (n) e adicionar as 4 outras (N) n;N;N;N;N # Adicionar tudo na memória anexa H # Trocar com a memória principal x # Afixar as linhas p }'

Sobre uma só linha :
sed -n '/ERROR/! {H;x;s/^.*\n\(.*\n.*\n.*\)$/\1/;x;}; /ERROR/ {H;n;N;N;N;N;H;x;p}'

Exemplo 2 - Comando "x"


Eis 2 maneiras de como fazer para emular "grep -A1 -B1" (justo afixar a linha precedente e a linha seguinte de uma linha que contém um motivo), ao utikizar um 1er tempo justo em troca entre as 2 memórias tampão com o Comando "x" e num 2nd tempo o emprego de cópia e de adição com os comandos "h" e "H" combinados ao Comando "x".

<soulinha>Comando "x"</soulinha>
#! /bin/bash 

sed -n ' # afixagem com pedido unicamente  
/indice7/! { # motivo ausente 
x  # coloca-se a linha na memória anexa (de fato troca-se o conteúdo)  
d  # apaga-se o espaço de trabalho 
} 
/indice7/ { # motivo presente 
x  # troca-se com o conteúdo da memória anexa que contém a linha precedente 
p  # afixa-se  
x  # troca-se de novo o conteúdo das 2 memórias 
p  # afixa-se a linha que contém o motivo 
n  # troca-se a linha seguinte 
p  # afixa-se  
x  # on la replace dans la memória anexa 
} 
' fich3.txt 

Somente sobre uma linha :
sed -n '/indice7/! {x;d;}; /indice7/{x;p;x;p;n;p;x;}' fich3.txt

Exemplo 3 - Comandos "h" "H" "x"


#! /bin/bash 

sed -n ' # afixagem com pedido unicamente 
/indice7/! { # motivo ausente 
h  # guarda-se a linha na memória anexa 
} 
/indice7/{ # motivo presente 
H  # adiciona-se a memória anexa 
n  # troca-se a  linha seguinte 
H  # adiciona-se o conteúdo na memória anexa 
x  # troca-se o conteúdo das 2 memórias 
p  # afixa-se 
} 
' fich3.txt 

Sobre somente uma linha :
sed -n '/indice7/! {h;}; /indice7/{H;n;H;x;p;}' fich3.txt

Etiquetas, laços e memórias tampão


Seja o arquivo seguinte(fich3.txt) :
Agrupar em uma mesma linha, a linha contendo "motivo" e as linhas seguintes que não comportam este motivo.
#! /bin/sed -f 

:notag  # etiqueta " sem motivo" 
/tag/!{  # se a linha não contém o motivo 
1!H  # addo à memória anexa, salvo a 1a linha 
1h  # copie a 1a linha aa memória anexa 
x  # trocar o conteúdo das 2 memórias tampons 
s/\n/ /g # suprimir todos os caracteres da nova linha (\n) 
x  # trocar de novo o conteúdo 2 memórias tampão 
$b lastline # se conectar à etiqueta "última  linha" 
d  # apagar o conteúdo do espaço de trabalho 
} 
/tag/{  # se a linha contém o  motivo 
x  # trocar o conteúdo das 2 memórias tampão 
/^$/!p  # se a linha não estiver vazia, afixar  
$b lastline # se conectar à etiqueta "última  linha" 
d  # apagar o conteúdo do espaço de trabalho 
b notag  # se conectar à etiqueta "sem motivo " 
} 
:lastline # etiqueta "última  linha" 
x  # trocar o conteúdo das 2 memórias tampons 
p  # afixar o conteúdo do espaço de trabalho 

Somente sobre uma linha:
 
sed -n ':notag;/tag/!{1!H;1h;x;s/\n/ /g;x;$b lastline;d;};/tag/{x;/^$/!p;$b lastline;d;b notag;};:lastline;x;p;'

Suprimir duas linhas precedentes um motivo dado


Suprimir as 2 linhas precedentes um motivo dado.

<soulinha>O arquivo de referência:</soulinha> plop
Pattern 
blablabla 
blablabla 
blu 
ToDelete << Linha a apagar 
ToDelete << Linha a pagar 
Pattern 
blablabla 
blablabla 
blo 
ToDelete << Linha a pagar  
ToDelete << Linha a pagar  
Pattern 
blablabla 
blablabla 
bly 
ToDelete << Linha a pagar  
ToDelete << Linha a pagar  
Pattern 
blablabla 
blablabla


<soulinha>O Comando :</soulinha>
sed ' 
/Pattern/ !{   # A  linha não contém o motivo 
    :z    # Etiqueta 
    h    # Copia-se o espaço de trabalho dans la  
        #+ na memória anexa 
    N    # Adiciona-se a linha seguinte 
    /Pattern$/ !b z  # O espaço de trabalho não se termina por 
        #+ o  motivo buscado
        #++ então se conecta-se a etiqueta 
    s/.*\n//   # A  linha se termina pelo motivo, devemos 
        #+ suprimir tudo até o último caractere        #++ representando um salto de  
    x    # Troca-se o conteúdo das 2 memórias 
    s/\(.*\)\n.*\n.*$/\1/ # Apaga-se as 2 últimas linhas 
    G    # Adiciona-se o conteúdo da  memória anexa 
        #+ o espaço de trabalho 
}' plop

Apagar os n últimas linhas


Eliminar os n últimas linhas sem conhecer o número de linhas (aqui os 4 últimos)
seq 10 | # gera-se10 linhas a partir do Comando "seq" 
sed -n ' # afixagem com pedido unicamente 
:s  # etiqueta 
1,3 {  # enquanto não tivermos  3 linhas no espaço de trabalho 
N  # adicion-se a linha seguinte 
b s  # conecta-se a etiqueta até preencher a condição  
} 
4,$ {  # enquanto não for atingida a última linha  
N  # adiciona-se a linha seguinte 
P  # afixa-se a linha contida no espaço de trabalho até o 1° caractere caractere 
  #+ simbolizando um fim de linha (\n) 
D  # depois apaga-se o espaço de trabalho 
} 
' 

Sobre uma linha somente:
seq 10 | sed  -n ':s;1,3{N;bs};4,${N;P;D}'

Emulação de "tac" (inverter as linhas de um arquivo)


#!/bin/sed -nf 

# Afora a 1a linha 
1!G     # Adicionar o conteúdo da  memória anexa ao espaço de trabalho 

# Se a última linha for atingida  
$p      # Afixar o resultado  

# Copiar o conteúdo do espaço de trabalho na memória anexa 
h 

Em uma só linha :
sed -n '1! G;$ p;h' 

Exemplo de conexão incondicional


Substituir todos os finais de linha par hífens
sed -e ' 
:boucle  # etiqueta 
N    # adicione a linha seguinte 
$! b laço # enquanto que a última linha não for atingida  
    #+ conecta-se à etiqueta 
s/\n/--/g  # substitui-se todos os fins de linha por 2 hífens(--) 
' fich.txt 

Sobre uma só linha :
sed -e ':laço;N;$! b laço; s/\n/--/g'

Exemplo de conexão (t)


(se uma substituição foi operada, então laço-se)
Centrar o texte em 20 colunad e adicionar um espaço antes e depois
sed -e ' 
:laço    # etiqueta 
s/^.\{1,20\}$/ & / # substitui-se o conteúdo da linha por ela mesma(&) e adicionar  
   #+ un espaço antes e depois  
t laço  # enquanto que uma substituição tenha acontecido, se conectar à etiqueta  
' fich.txt 

#Em uma só linha:
#
sed -e ':laço;s/^.\{1,20\}$/ & /; t boucle'

Outro exemplo de conexão condicional


Transformar "AABBCCDDEEFF" em "AA:BB:CC:DD:EE:FF"

Fica-se tentado em utilizar um simples:
echo "AABBCCDDEEFF" | sed 's/../&:/g'

Mas o problema é que esta sintaxe adiciona também um ":" em fim de linha :
AA:BB:CC:DD:EE:FF:


A solução consiste então em fazer um laço utilizando a sintaxe das experssões regulares e principalmente os limites de caracter ou de palavra (word boundary) :
echo "AABBCCDDEEFF" | sed ':z;s/\<..\B/&:/;tz'

Exemplo de conexão condicional (T)


(se uma substituição não foi operada, então laço-se)
Eliminar um intervalo de linhas cujo inicio é representado por um motivo (C) e no final sendo o 3° "Y".
$ var="A\nY\nB\nY\nC\nY\nD\nY\nE\nY\nF\nG" 

echo -e "$var" |\ 
sed ' 
/C/ { 
    :laço 
    N 
    s/.*Y.*Y.*Y// 
    T laço
} 
' 

Emu ma só linha:
sed  '/C/{:boucle;N;s/.*Y.*Y.*Y//;T boucle};'



Para a portabilidade melhor utilizar:
 
sed ' 
/C/ { 
    :laço 
    N 
    s/.*Y.*Y.*Y// 
    t 
    b laço
} 
' 

Emu ma sú linha:
sed -e '/C/{:laço' -e 'N;s/.*Y.*Y.*Y//;t' -e 'b laço' -e '}'


 
sed '   # busca o motivo /* ... */ 
s!/\*.*\*/!!  # em uma linha 
/;[ ]*\/\*/ {  # em várias linhas, mas que não comecem no início da linha  (depois 
   #+ um ponto seguido eventualmente de um (ou mais ) espaço(s) 
    :z   # etiqueta para o laço 
    N   # adiciona-se a linha seguinte 
    s!/\*.*\*/!! # suprime-se tudo entre /* e */ 
    T z   # testa-se se uma substituto aconteceu. Caso contário laço  
} 
/\/\*/,/\*\// d  # em diversas linhas 
' 

Substituição com tampão


Substituição das 2 primeiras ocorrências de uma expressão que emprega os tampões
echo $A 
2007:10:07 16:34:05 

echo $A | 
sed -e ' 
h   # copia-se o espaço de trabalho na memória anexa 
s/\(.*\) .*/\1/  # guardamos somente a 1a parte da expressão (a data) 
s/:/-/g   # substitui-se todos os dois pontos por hífens  
x   # troca-se o conteúdo das 2 memórias 
s/.*\( .*\)/\1/  # guarda-se somente a 2a parte da expressão  (a hora) 
H   # adiciona-se ao conteúdo da memória anexa 
g   # on copie le conteúdo  de la memória anexa dans l'espaço de trabalho 
s/\n//   # suprime-se o caractere fim de linha 
' 

Em uma só linha :
echo $A |sed -e 'h;s/\(.*\) .*/\1/;s/:/-/g;x;s/.*\( .*\)/\1/;H;g;s/\n//'

Decomentar as diretivas de um arquivo


Seja um arquivo de configuração com suas diretivas, suas linhas de comentários e suas instruções comentadas. Cada parágrafo é separado do seguinte por uma linha vazia.
Como decumentar um jogo de instruções que começa por uma linha comentada (contendo uma palavra colchete ) seguido pelas diretivas comentadas elas também.
sed ' 
/# mot-clé/ {  # motivo buscado 
:label   # etiqueta 
/^$/q   # se a linha for vazia laço-se  
n   # carrega-se o espaço de trabalho a linha seguinte 
s/^#//   # suprime-se o quadrado no inicio da linha 
t label   # se uma substituição aconteceu, conecta-se à etiqueta 
} 
' arquivo 

Somente sobre uma linha :
sed '/# mot-clé/{:label;/^$/q;n;s/^#//;t label;}'

Conversão de caracteres


Convertir seulement les 12 premiers caracteres accentués de chaque linha :
$ cat plop 
àaéeèeôoùuïiàaéeèeôoùuïiàaéeèeôoùuïiàaéeèeôoùuïié 
ÀaéeÈeôoùuïiàaéeèeôoùuïiàaéeèeôoùuïiàaéeèeôoùuïié 
àaéeèeôoùuïiàaéeèeôoùuïiàaéeèeôoùuïiàaéeèeôoùuïié 
àaéeèeÔoùuïiàaéeèeôoùuïiàaéeèeôoùuïiàaéeèeôoùuïié 
àaÉeèeôoùuïiàaéeèeôoùuïiàaéeèeôoùuïiàaéeèeôoùuïié 

 
sed ' 
h     # copia-se o espaço de trabalho na memória anexa 
s/\(^.\{12\}\).*/\1/   # recupera-se os 12 primeiros caracteres do espaço de trabalho 
y/àâéèêëîïôöùûü/aaeeeeiioouuu/  # converte-se as minúsculas  
y/ÀÂÉÈÊËÎÏÔÖÙÛÜ/AAEEEEIIOOUUU/  # converte-se as maiúsculas  
x     # troca-se o conteúdo das 2 memórias 
s/^.\{12\}\(.*\)/\1/   # recupera-se todos os caracteres depois da 12 a 
x     # troca-se o conteúdo das 2 memórias 
G     # adiciona-se o conteúdo  da memória anexa 
s/\n//     # suprime-se os caracteres fim de linha 
' plop

Layout do texte 1


Eis um exemplo que ilustra com 2 métodos bem diferentes, o layout de um texto de acordo com os seguintes critérios :
A partir da 6ª vírgula, suprimir cada entre aspas que enquadram cada campo, exceto o último.
O texto de referência:
$ cat plop 
{"88","6","Trademark2","Model6","6OD","7","false","null","null","1","30","1","40","1","60","1","65","1","65","1","70","1","70","1","70"}, 
{"89","6","Trademark2","Model6","6PD","7","false","null","null","10","30","10","50","10","70","15","75","25","75","25","80","25","80","25","80"}, 

Com os laços condicionados


Método com um laço condicionado:
 
sed ' 
s/,/,\n/5  # Substitui-se a 5a  vírgula por ela mesma  
   #+ acompanhamento de um salto de linha  
:s   # etiqueta 
s/\(\n.*\)"/\1/  # ali a gente joga com a guloseima dos regex, a 
   #+ sub-expressão englobando tudo aquilo que se encontra  
   #++ antes da última aspa que se quer substituir então      #+++ pela mesma com a exceção da aspa  
t s   # enquanto que uma substituição aconteceu, laço-se  
s/\n\(.*\)}/"\1"}/ # e para terminar substitui-se tudo aquilo que se encontra
   #+ depois do salto de linha até o colchete do laço 
   #++ pelo conteúdo mais uma aspa e uma colchete
   #+++ a vírgula que não está na LHS é 
   #++++ reconduzida naturalmente  
' 
plop 

Somente sobre uma linha/
sed 's/,/,\n/5;:s;s/\(\n.*\)"/\1/;ts;s/\n\(.*\)}/"\1"}/'

Com memória tampão


Métodos com memória tampão :
 
sed ' 
s/\"/§/12 # substitui-se a 12a aspa por um caractere qualquer 
h  # copia-se a memória principal a memória anexa 
s/§.*//  # apaga-se este caractere e tudo aquilo que se encontra depois  
x  # troca-se o conteúdo  das 2 memórias 
s/.*§,// #apaga-se a parte correspondente  à  memória anexa 
s/\"//g  # suprime-se todas as aspas  
x  # troca-se de novo o conteúdo  das 2 memórias 
G  # adiciona-se o conteúdo  da memória anexa à principal 
s/\n/,/  # substitui-se o salto de linha separando as 2 memórias por 
  #+ uma vírgula 
s/}/\"}/ # adiciona-se a última aspa  
' 
plop 

Somente sobre uma linha :
sed -e 'h;s/\"/§/12;s/§.*//;x;s/\"/§/12;s/.*§,//;s/\"//g;x;G;s/\n/,/;s/}/\"}/' plop

Layout do texto 2


No mesmo espírito que anteriormente, mas é preciso substituir os espaços vazios de conteúdo no inicio do 1° campo (e unicamente neste aqui ) por 0 (zeros).
2 métodos também, um com laço e um utilizando as memórias tampão.

Arquivo de referência:
$ cat plop 
 1023 LOGS blabla 
12333 LOGS blabla 
   44 LOGS blabla 
 2580 LOGS blabla 
 1458 LOGS blabla 
    5 LOGS blabla 

Método com laço


 
sed ' 
/^ / {    # somente as linhas que comecem por um  
    :boucle   # etiqueta 
    s/^ [^[:alnum:]]*/&\n/ # adiciona-se um salto de de linha depois do último espaço do 1o campo 
    s/\([ ]\?\) \{1\}\n/\10/ # substitui-se um espaço por ele mesmo seguido de um 0 (zero) 
    


t laço   # quando uma substituição aconteceu, fecha-se  
} 
'

Somente uma linha:
sed '/^ / {:boucle; s/^ [^[:alnum:]]*/&\n/; s/\([ ]\?\) \{1\}\n/\10/; t boucle}' plop

Método com memória tampão


 
sed ' 
/^ / {    # somente as linhas que começam por um espaço 
    s/^ [^[:alnum:]]*/&\n/ # adiciona-se um salto de linha depois do último espaço do 1+ campo  
    h    # copia-se a memória principal na memória anexa 
    s/\n.*$//   # apaga-se da memória principal tudo o que segue o salto de        #+ linha (salto de linha incluído) 
    s/ /0/g   # substitui-se todos os espaços por on 0 (zeros) 
    x    # troca-se o conteúdo  das 2 memórias 
    s/.*\n//   # apaga-se desta vez tudo o que precede o salto de linha  
    #+ (salto de linha incluido) 
    x    # troca-se denovo o conteúdo  das 2 memórias 
    G    # copia-se conteúdo  da memória anexa na continuidade da 
        #+ memória principal 
    s/\n//   # e suprime-se o salto de linha 
} 
'

Sur une seule linha :
sed '/^ / {s/^ [^[:alnum:]]*/&\n/;h;s/\n.*$//;s/ /0/g;x;s/.*\n//;x;G;s/\n//}' plop

Post en référence

O Comando "c"


echo -e "A\nB\nC\nD\nE\nF\nG" | sed '/B/,/F/ c\DELETED'

Os arquivos de referência para os exemplos


Você encontrara abaixo a maioria dos arquivos utilzados ao longo deste documento par ilustrar os diferentes exemplos vistos, para lhe permitir entender melhor os comandos.

fich.txt


 
Linha n° 1 
Linha n° 2 
Linha n° 3 
Linha n° 4 
Linha n° 5 
Linha n° 6 
Linha n° 7 
Linha n° 8 
Linha n° 9 
Linha n° 10 

fich2.txt


 
Linha n° 1 
Linha n° 2 
# comentário1 # Linha n° 3 
Linha n° 4 
Linha n° 5 # A próxima linha está vazia (6) 

# comentário 2 # Linha n° 7, a linha precedente está vazia (6) 
Linha n° 8 
Linha n° 9 # A próxima linha está vazia(11) 

Linha n° 11 # A linha precedente e vazia (10) 
Linha n° 12 
Linha n° 13 
Linha n° 14 

fich3.txt


 
Linha n° 1 tag : 
indice1 indice2 
indice3 
Linha n° 2 tag : 
Linha n° 3 tag : 
Linha n° 4 tag : 
indice4 indice5 
Linha n° 5 tag : 
Linha n° 6 tag: 
indice6 
Linha n° 7 tag : 
Linha n° 8 tag : 
indice7 
indice8 indice9 
indice10 
Linha n° 9 tag : 
Linha n° 10 tag : 

endereços.txt


 
Ubuntu  31000 Toulouse 
Mandriva 34000 Montpellier 
SuSE  66000 Perpignan 
Debian  31130 Balma 
Gentoo  34500 Béziers 
Slackware 66100 Collioure 
Fedora  31400 Muret 
RedHat  34200 Agde 
Kaella  66500 Elne 

assinatura.txt


 
--  
Para as correspondências, queira endereçá-las à: 
(substitua "<moderador>" pelo nome do moderador adequado) 
<moderador>@commentcamarche.com 
Obrigada pela atenção 
A equipe CCM 

prog.sed


 
#! /bin/sed -f 


1 h  # carregar a 1a linha memória secundária 
1 d  # apagamento 1a linha 
5 {   # selecionar sobre alinha 5 
G  # adicionar o conteúdo  da memória secundária à memória principal 
N  # adicionar a linha seguinte (la 6) 
s/\n/ /g # substituir todos os saltos de linha (\n) por um espaço 
} 

#Em uma única  linha : 
# sed -n '1 h; 1 d; 5 { G; N; s/\n/ /g};P' fich.txt 



Trdaução feita por Ana Spadari

Veja também

Artigo original publicado por . Tradução feita por ninha25. Última modificação: 8 de setembro de 2011 às 16:53 por ninha25.
Este documento, intitulado 'Sed - Introdução a SED - Parte III', está disponível sob a licença Creative Commons. Você pode copiar e/ou modificar o conteúdo desta página com base nas condições estipuladas pela licença. Não se esqueça de creditar o CCM (br.ccm.net) ao utilizar este artigo.