Sed - Introdução à SED - Parte II

Dezembro 2016


SED - The Stream EDitor - Parte II

Este texto é uma introdução à prática e à utilização do editor de fluxo "SED", que tenta criar algumas funcionalidades bastante desconhecidas que fazem de "SED" uma ferramenta indispensável na caixa de ferramentas de qualquer Linuxiano que deseja acabar com as dificuldades do tratamento de arquivos via um console ou um Shell.

Sumário parte II


Parte I
Parte III

Os delimitadores

Delimitador de comando

Convencionalmente, Sed usa como caractere delimitador para seu mecanismo de substituição o caractere "/" (slash - barra obliqua) :
sed 's/motivo/substituição/' arquivo


Na maioria dos casos, a opção padrão é bastante satisfatória, mas pode ser rapidamente uma verdadeira dor de cabeça se o padrão da cadeia ou da substituição também contenham uma ou mais slashs (barras (s)), como é frequentemente o caso por exemplo, para um caminho de uma arborescência (PATH).

Você pode proteger estes slashs prefixando um entre aspas "\" ( - backslash - anti-slash - barra oblíqua invertida) processo muito complicado, se o motivo ( ou a cadeia de substituição ) é equipado por vários, tornando difícil a legibilidade:

sed 's/\/home\/jp\/Docs\/CCM\/SED/\/mnt\/servidor\/docs/' arquivo

Pode até mesmo ser impossível quando o motivo (ou a cadeia de substituição ) for uma variável que deve ser interpretada:
var="/home/jp/Documents/CCM/SED/"     
sed 's/'$var'/\/mnt\/servidor \/docs/' arquivo


ou (expressão entre duplas aspas)
sed "s/$var/\/mnt\/servidor \/docs/" arquivo


Felizmente, Sed permite substituir o delimitador padrão pelo caractere de sua escolha (#,|,!,§,etc.) a partir do momento onde ele não se encontra na composição do motivo (ou a cadeia de substituição):

sed 's#/home/jp/Docs/CCM/SED#/mnt/servidor /docs#' arquivo


Este caractere pode também ser uma letra qualquer se esta letra não faz parte do motivo (ou a cadeia de substituição):

echo "bom dia" | sed 'sZbZBZ'


Note que se você usa o caractere "!" (ponto de exclamação) como separador, deve contornar a expressão por aspas clássicas para prevenir qualquer interpretação pelo Shell do caractere "!" (empregado normalmente para gerenciar o histórico dos comandos ).

Delimitador de motivo

Como vimos, Sed usa motivos, emoldurado pelo caractere "/" (slash </ ital>) para procurar (<ital>colocar em correspondência</ ital>) algumas linhas de um documento . O slash é usado por convenção, no entanto, também pode ser alterado em favor de outro caractere precedendo a primeira ocorrência deste caractere por "\" (<ital> backslash ).

Sempre você seguir o exemplo de um caminho como um critério de pesquisa, deve admitir que não é muito legível:

sed -n '/\/home\/jp\/Docs\/CCM\/SED/p' arquivo


Enquanto escolhendo como caractere delimitador "#" (quadrado), por exemplo, ficaria assim:

sed -n '\#/home/jp/Docs/CCM/SED#p' arquivo

O meta caractere &

Muitas vezes o mecanismo de substituição é limitado pela procura de um motivo, para substituí-lo pela adição de uma parte sucinta, por exemplo, procurar a cadeia "Sed the Stream Editor" em um documento e desejar adicionar sistematicamente "Sed the Stream Editor (editor de fluxo) ".

Poderíamos, então, escrever

sed 's/Sed the Stream EDitor/Sed the Stream EDitor (Editor de flux)/g' arquivo


O meta caractere"&" (ampersand ou comercial) vai permitir substituir todas as cadeias de caracteres colocadas em correspondência pelo motivo (ou a expressão regular) fornecida em 1° argumento.


Aqui a noção do 1° argumento não é muito explicita e pouco legível, mas ele assumirá toada a importância com as expressões regulares e no capítulo seguinte nas «sub- expressões".

Então nosso comando se escreverá desta forma :

sed 's/Sed the Stream EDitor/& (Editor de flux)/g' arquivo

Imaginemos que nós tenhamos que buscar todas as cadeias digitais (1 ou diversos números consecutivos ) em um arquivo e que nos queiramos fazer preceder cada uma destas cadeias por "n° " (note o espaço depois do "°"). O comando se pareceria à isto:

sed 's/[0-9][0-9]*/n° &/g' arquivo



É preciso, imperativamente, usar a expressão "\&" para obter um "&" literalmente na cadeia de substituição senão você corre o risco de gerar erros incompreensíveis de vez em quando.

As sub expressões e referências antecedentes

[Image: http://www.commentcamarche.net/faq/images/0-TZdhVxem-sous-expressão-sed-s-.png|500px|]

As sub-expressões

\(...\)

Uma sub expressão é uma parte de uma expressão regular, enquadrada por parêntese, que se deseja reutilizar na cadeia de substituição. Os parênteses devem ser protegidos por backslashes, a não ser que a opção "-r" tenha sido empregada.

As referências antecedentes

\1 \2 \5

Para se referir a cada bloco mapeado na cadeia de substituição, designamos por um número correspondente pela ordem de aparecimento na expressão regular. Este número também deve ser protegido por uma backslash (barra oblíqua invertida). Podemos nos referir apenas à 9 sub-expressões numeradas \ 1 a \ 9. Estas referências também são chamadas de "referências de volta atrás".


Eis alguns exemplos com os nomes de cidades e seu código postal associado :
Arquivo de referência:
$ cat plop     
31000 Toulouse
34000 Montpellier
66000 Perpignan


Neste exemplo, a sub-expressão "\([0-9]*\)" é colocada em correspondência com toda cadeia exclusivamente digital e referenciada pela referência antecedente"\1" :

$ sed 's/\([0-9]*\).*/\1/' plop     
31000
34000
66000


Desta vez, estamos conectando duas sub-expressões, uma exclusivamente digital e a outra que compõem o resto da linha, sem incluir o caractere de tabulação que separa o código postal do nome da cidade. Em seguida, usamos back-referencias "\ 1" (CEP) e "\ 2" (nome da cidade) para mostrar o resultado como: nome da cidade> código postal

$ sed 's/\([0-9]*\)\t\(.*\)/\2 > \1/' plop     
Toulouse > 31000
Montpellier > 34000
Perpignan > 66000


Neste terceiro e último exemplo, nós faremos corresponder uma sub-expressão a cada parte da linha, como o código postal (\1), a tabulação (\2) e o nome da cidade (\3)

$ sed 's/\([0-9]*\)\(\t\)\(.*\)/\3\2\1/' plop     
Toulouse 31000
Montpellier 34000
Perpignan 66000


A referência antecedente pode apelar para uma sub-expressão quantas vezes você quiser na Cadeia de Substituição. Tomando o exemplo anterior, aqui tem a demonstração com a repetição das tabulações em vários locais:
$ sed 's/\([0-9]*\)\(\t\)\(.*\)/\2\3\2\2\1/' plop     
Toulouse 31000
Montpellier 34000
Perpignan 66000

Expressão regular precedente

Quando se coloca em correspondência uma cadeia com a expressão regular, sed coloca na sua memória tampão a dita cadeia e assim, é possível se referir a esta cadeia na 1a parte do comando de substituição "s" (LHS) sem fazer sua menção literalmente. Dizendo de outro modo, um comando do tipo //cadeia_de_substituição/' substituirá a última expressão regular colocada em correspondência por Sed pela cadeia_de_substituição.

Para ilustrar este estado de fato, retomemos nosso arquivo com as cidades e os códigos postais.
Nós iremos mostrar a (s) linha (s) contendo o motivo "Montpellier", Os outros serão apagados (d) e nós substituiremos "Montpellier" por "Béziers" :

$ cat plop     
31000 Toulouse
34000 Montpellier
64000 Perpignan

$ sed '/Montpellier/!d; s//Béziers/' plop
34000 Béziers


Para rever toda a questão de sub-expressões, referências antecedentes e Expressão regular precedente, eis, sempre de acordo com o exemplo acima, outra faceta das oportunidades oferecidas por Sed. Se o Motivo procurado é emoldurado por um parêntese, ele se torna assim uma sub-Expressão que pode ser chamada na parte direita do comando "s":

$ sed '/\(Montpellier\)/!d;s//Béziers-\1/' plop     
34000 Béziers-Montpellier

$ sed '/\(Mon\)tpellier/!d;s//Béziers-\1blanc/' plop
34000 Béziers-Monblanc

A negação

Às vezes pode ser útil excluir uma linha jogando com um motivo (ou intervalo de linha</ ital>) antes do tratamento. Para fazer isso, o Sed usa o caractere "!" (<ital> Ponto de exclamação </ ital>), que, como na maioria das ferramentas do mundo Unix, descreve a "negação", assim como faz o comando "grep-v".

Basta para tanto seguir o motivo (<ital> ou o número de linha ou ainda o intervalo de linha
) de caráter "!" como se segue:


sed -n '3 !p' fich.txt
sed -n '3,8 !p' fich.txt
sed -n '/índice/! p' fich3.txt

Frequentemente encontrado nos scripts sed, a Expressão "$!" que pode ser traduzida como "enquanto que a última linha não foi atingida" e que permite efetuar um ou mais comandos (s) se esta condição for verdadeira.

Pode ser divertido comparar as diferentes maneiras de escrever a sintaxe de um comando para o mesmo resultado.


eco -e 'a\nb\n\nc\nd\ne\n\nf\ng' | sed '/./! d'
echo -e 'a\nb\n\nc\nd\ne\n\nf\ng' | sed '/^$/ d'
echo -e 'a\nb\n\nc\nd\ne\n\nf\ng' | sed -n '/^$/! p'
echo -e 'a\nb\n\nc\nd\ne\n\nf\ng' | sed -n '/./ p'

O agrupamento de comando s

/adresse/{...}
(intervalo de endereçamento autorizado)


Chaves são usadas para agrupar alguns comandos a serem executados em um endereço ou campo de endereços. Podem ser encontradas dentro destes comandos agrupados, Outras seleções de endereços como também outros comandos agrupados, entre chaves podem ser feitas.

Este é sua função principal, definir a linha de destino (ou mais) e aplicar um ou mais comando (s) sucessível (s) bem específico (s). Note que o tratamento age sobre o conteúdo da memória tampão e não na linha original e, portanto, as mudanças podem trazer os critérios de seleção adicional.

sed '
/a/{ # somente a linha que contém "a"
s/a/c/g # substituir os "a" par "c"
/c/{ # somente a linha contendo "c" da linha alvo
s/c/A/g # substituir os "c" par "A"
}
}
' < <(echo -e "aaa\nbbb\nccc\nddd")


AAA
bbb
ccc
ddd


$ echo -e "aaa\nbbb\nccc\nddd" | sed '/a/{s/a/c/g;/c/{s/c/A/g}}'

AAA
bbb
ccc
ddd


Em um grupo de comando s (um script), cada comando deve começar em sua própria linha, as chaves e o conjunto dos comandos "s" deve estar em linhas separadas. A chave de abertura deve ser o fim da linha, enquanto que a chave de fechamento deve imperativa ficar sozinha em uma linha. Atenção deve haver um espaço após as chaves.

A Substituição de variáveis

Pode acontecer que dentro de um script sed tenhamos a necessidade de passar uma variável como um parâmetro, quer como Motivo ou em qualquer das partes (LHS ou RHS) em uma substituição. Como falei anteriormente, temos que prestar muita atenção aos caracteres na variável para ajustar as aspas ao usá-las

Na verdade, o sed, por padrão, usa aspas (1) para cercar sua expressão, ora esse mecanismo shell bloqueia justamente a expansão de variáveis e, portanto, o uso de aspas com uma haste simplesmente impedirá a interpretação da variável.



var=A; echo 'azerty' | sed 's/a/$var/'
$varzerty


Em um primeiro momento, é muito possível substituir estas aspas por aspas duplas, o que, na maioria dos casos, bastará para permitir a interpretação da variável como é preciso.

var=A; echo 'azerty' | sed "s/a/$var/"
Azerty

Mas pode mostrar-se boa antes esta:

var=A; echo 'azerty' | sed 's/a/'"$var"'/'
Azerty


Neste caso, não é muito fácil compreender porque o melhor é usar uma mistura de aspas com uma ou duas hastes. Na verdade, a palavra "mistura" não é o termo apropriado, teria sido mais correto usar a palavra "excluir" porque, na verdade, para esta sintaxe, excluímos a variável de Expressão, que permite a sua interpretação pelo shell, mas protege na Expressão se a interpretação for de qualquer caracteres shell específicos. Para entender melhor esta distinção, considere o seguinte exemplo:

A exibição pelo shell de seis letras do alfabeto, cada um em uma linha e que a letra "A" seja repetida duas vezes. Depois de atribuir a letra (A) a uma variável ($ var), vamos pedir ao SED para não mostrar as linhas que contém esta variável, portanto, usando o sintaxe evocando a negação, que é o ponto de exclamação (!).

Primeiro, escreva a Expressão com uma aspas:

var=A; echo -e "A\nB\nC\nA\nD\nE" | sed -n '/$var/!p'
A
B
C
A
D
E

Nós constatamos que todas as letras são exibidas e é normal visto que a variável não foi interpretada pelo shell por causa das aspas com uma haste.
Agora, contornemos a expressão com as aspas duplas:

var=A; echo -e "A\nB\nC\nA\nD\nE" | sed -n "/$var/!p"
-l: !p": event not found


O shell envia-nos uma mensagem de erro! De fato, o "!" é um caractere reservado do shell usado especialmente para a história e comando 's' que não poderia ser interpretado como tal.

Portanto, dissociamos a variável da Expressão própria do Sed, fechando a Expressão pouco antes da variável e a reabrindo logo depois com a ajuda das aspas de uma só haste (note que as aspas duplas em torno da variável é opcional, mas é preferível deixar, porque é um bom hábito para se proteger dos erros, provocados pelos espaços na variável):

$ var=A; echo -e "A\nB\nC\nA\nD\nE" | sed -n '/'"$var"'/!p'
B
C
D
E

As expressões regulares

O conhecimento de expressão regular ( regex abreviado) é um pouco mais significativa na prática da Sed ( e muitas outras linguagens).

A Expressão regular é um Motivo ( padrão em Inglês ) que entrará em correspondência, da esquerda para a direita, com uma cadeia de caracteres.

As expressões regulares recebem a energia de sua capacidade de incluir alternativas e repetições no desenvolvimento do modelo que constitui o Motivo. Estas características são desenvolvidas utilizando caracteres especiais que não são interpretados em um sentido literal, mas de uma maneira específica.


Eis uma rápida descrição da sintaxe das expressões regulares utilizadas no Sed.

caractere (um caractere qualquer )

Correspondência com um "caractere" único

Corresponde a uma seqüência de zero, uma ou diversas ocorrências de expressão precedente, que pode ser um caractere comum, um caractere especial protegido por um \, um ponto (.), um grupo de expressão regular ou uma sub-expressão

\+


Idêntica à *, que corresponde a uma ou várias ocorrência (s) de expressão precedente

\?

Idêntica à *, que corresponde à zero ou uma ocorrência da expressão precedente.
\{i\}

Idêntica à *, mas que corresponde exatamente a seqüência da ocorrência de expressão precedente (i representa um inteiro)
\{i,j\}


Corresponde a uma seqüência inclusive compreendida entre i e j

\{i,\}

Corresponde a uma seqüência mais ou menos igual a i

\(regexp\)


Corresponde a um conjunto de expressão regular, chamado também sub-expressão e podendo ser endereçada por referência antecedente (back reference)
. um ponto

Qualquer caractere, exceto uma nova linha.

^

Corresponde a uma cadeia nula em início de lenha, quer dizer que se encontra depois do acento circunflexo deve aparecer em início de linha ou início de uma sub expressão.
$

O mesmo que ^ mas a correspondência de faz no fim da linha ou sub-Expressão.

[ Lista</ ital>]


Corresponde a qualquer caractere da lista. A lista pode se consistir de uma seqüência como [a-z] que é equivalente a uma correspondência com qualquer caractere compreendido entre a e z incluído. Para incluir um "]" faça aparecer em primeiro na lista. Para incluir um - colocá-o em primeiro ou em último na lista. Para incluir um ^ coloque-o após depois do primeiro caractere da lista.

Os caracteres $, *,., [ e \ normalmente não são considerados caracteres especiais dentro de uma lista. Assim Expressão [\ *] irá corresponder tanto ao caractere \ como ao caractere * o \ não é visto como um caractere de escape servindo para proteger o caráter *.

[<ital>liste
]


Correspond a qualquer caractere da lista. Uma lista pode ser constituída de uma sequência como [a-z] o que equivalera á uma instalação de correspondência com qualquer caractere compreendido entre a e z incluído. Para incluir um [ fala-o figurar em primeira posição na lista. Para incluir um - coloque-o em primeiro ou última posição na lista. Para incluir um ^ coloque-o depois do primeiro caractere da lista.

Os caracteres $, *, ., [, e \ não são normalmente considerados como caracteres especiais no interior de uma lista. assim a expressão [\*] corresponderá tanto ao caractere \ que ao caractere *, O \ não sendo visto como um caractere de escape servindo a proteger o caractere caractere *.

[^liste]


Ao contrário, um ^ no alto da lista, fará corresponder qualquer caractere exceto a lista. Para incluir um ] faça-o figurar em primeira posição na lista justo depois do ^.

regexp1\|regexp2


Correspondência com regexp1 OU regexp2. O processo de correspondência tenta cada alternativa por sua vez, da esquerda para à direita e a primeira que tem sucesso é utilizada. Note o caractere de escape (\) para proteger o caractere "pipa" (|).

\número


Corresponde à última sub-expressão \(...\) utilizada na expressão regular. As sub- expressões, chamadas também «referências antecedentes» são implicitamente numeradas da esquerda para à direita contando o número de ocorrências de "\(", com um mínimo de 9.

\n


Corresponde ao caractere nova linha (LF)

\metacaractere


Corresponde à um metacaractere entre $, *, ., [, \, ou ^, devendo ser protegido por uma interpretação literal.

Nota :


Cuidado, as expressões regulares são gulosas. Quando você colocá-las em correspondência, estas são efetuadas da esquerda para a direita, e se duas ou mais expressões tem o mesmo caractere de início, a correspondência será feita sobre a expressão mais longa.

Os caracteres de escape

\a


alerta (sino bip) (BEL, Ctrl-G, 0x07)
\b


apagamento antecedente (BS, Ctrl-H, 0x08)
\f


fim de página (FF, Ctrl-L, 0x0C)
\n


fim de linha (LF, Ctrl-J, 0x0A)
\r


volta do cursor (CR, Ctrl-M, 0x0D)
\t


tabulação horizontal (HT, Ctrl-I, 0x09)
\v


tabulação vertical (VT, Ctrl-K, 0x0B)
\o000


o caractere cujo valor em octal é 000 (um a três números ) [0-7]
\dDDD


o caractere d cujo valor em hexadecimal é DDD (um a três números) [0-9]
\xHH


o caractere cujo valor em hexadecimal é HH [0-9A-F]

Os extras

\'


corresponde a uma cadeia nula em início de linha (idêntica à ^)
'

corresponde a uma cadeia nula em fim de linha (idêntica à $)
\b


corresponde a uma cadeia vazia na extremidade de uma palavra. Limite entre uma palavra e uma cadeia vazia na extremidade de uma palavra. Limite entre uma palavra e caractere que não seja uma palavra
\B


corresponde a uma cadeia vazia que não se encontra na extremidade da palavra. Limite entre caractere que não seja uma palavra e uma palavra
\w


qualquer palavra da classe : [A-Za-z0-9_] (underscore _ incluído)
\W


qualquer palavra fora da classe : [^A-Za-z0-9_] (underscore _ incluído)
\s


qualquer caractere de espaçamento: espaço, tabulação horizontal ou vertical
\S


um ou vários caracteres de espaçamento
\<


corresponde a uma cadeia vazia no início da palavra
\>


corresponde a uma cadeia vazia no final da palavra
\e


fim da conversão de quebra
\l


conversão do próximo caractere em minúsculo
\L


conversão dos caracteres que ficam em minúsculo
\u


conversão do próximo caractere em maiúscula
\U


conversão dos caracteres que ficam em maiúscula

As classe de caracteres

[:alnum:]


caracteres alfanuméricos [A-Za-z0-9]
[:alpha:]


caracteres alfabéticos [A-Za-z]
[:digit:]


números [0-9]
[:lower:]


caracteres minúsculos[a-z]
[:upper:]


caracteres maiúsculos [A-Z]
[:print:]


caracteres imprimíveis [ -~]
[:punct:]


caracteres de pontuação [!-/:-@[-'{-~]
[:space:]


espaços, tabulações e qualquer caractere vazio [ \t\v\f]
[:blank:]

espaço e tabulação [ \x09]
[:graph:]


qualquer caractere imprimível [!-~] (exceto os espaços vazios)
[:cntrl:]


caracteres de controle [\x00-\x19\x7F]
[:xdigit:]


números hexadecimais [0-9a-fA-F]

As diferentes versões

Unix

GNU sed v4.0.5 (Gsed) Download

Última versão oficial de GNU sed oferecendo a edição local (-i)

Ssed v3.60 Download

(Small/Stupid Stream EDitor) Versão recomendada

BSD multi-byte sed Download

(Japonesa) Baseada na última versão de GNU Sed

Windows

GnuWin32-Sed v4.1.5 Download

A versão executável para MS Windows 95 / 98 / ME / NT / 2000 et XP

Debuggers

Eis dois debuggers que te permitirão melhor compreender o funcionamento de sed e, em alguns casos particulares, economizar numerosas horas de trabalho na tentativa de encontrar onde se encontra o grão de areia que obstruía o filtro que se tornou de repente impermeável...


sd.ksh e sd.sh.txt são 2 pequenos scripts escritos respectivamente em Korn shell e Bourne shell que incluem um manual com as instruções de utilização no final do arquivo.

sedsed é escrito em Python (que deve ser desta forma instalada em seu sistema) e te permite visualizar o estado dos tampões e os comandos s interpretados no andamento.

Eis aqui um mini tutorial para o emprego de "sedsed".

Uso: sedsed OPTION [-e sedscript] [-f sedscriptfile] [inputfile]

Opções:

-f, --file leitura dos comandos s a partir do arquivo designado
-e, --expressão permite encadear diversos comandos s na continuidade
-n, --quieto solicitação implícita para não afixar o estado da memória principal
--silent clone para --quiet

-d, --debug ativa o modo debogagem
--hide esconde algumas opções de debogagem (opções : PATT,HOLD,COMM)
--color ativa a saída do debogagem colorido (ativado como padrão)
--nocolor desativa a saída do debogagem colorido
--dump-debug listagem do débogagem na tela

-i, --indent indentation do script, um comando por linha
--prefix indentação por espaços ou tabulações (4 espaços padrão)

-t, --tokenize modo verbal, afixa cada comando com mais
-H, --htmlize converte um script sed em uma linda página HTML colorida

-V, --version afixa a versão do programa e
-h, --help afixa uma página de ajuda e fecha


Significação em saída:
PATT: exibe o conteúdo do espaço de trabalho (memória principal)
HOLD: exibe o conteúdo do espaço anexo (memória secoundária)
COMM: o comando SED devendo ser executado
$ Limita o conteúdo de PATT e HOLD



A sintaxe mais comum é o modo de debogagem simples (-d) :
echo -e "AAA\nBBB\nCCC\nDDD" | sed '/BBB/ {n;s/C/Z/2}'     
echo -e "AAA\nBBB\nCCC\nDDD" | sedsed -d '/BBB/ {n;s/C/Z/2}'

<a href='http://www.commentcamarche.net/faq/images/0-B4IoZAnt-debogage-d.png'><a href='http://www.commentcamarche.net/faq/images/0-B4IoZAnt-debogage-d.png'><a href='http://www.commentcamarche.net/faq/images/0-B4IoZAnt-debogage-d.png'>
</a></a></a>
Esquema: debogage_-d.png

sedsed -i -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;'

Esquema: debogage_indent.png

Esconder a exibição do espaço anexo:
echo -e "AAA\nBBB\nCCC\nDDD" | sedsed -d --hide=HOLD -n '/BBB/ {n;s/C/Z/2p}'

Quando é que eu não devo utilizar Sed?

Quando as ferramentas específicas existem e já efetuam a tarefa mais rapidamente e mais simplesmente , (sintaticamente falando ).


Busca de motivo simples:

grep "motivo" arquivo # sed -n "/motivo/p' arquivo

Exclusão de motivo simples

grep -v "motivo" arquivo # sed "/motivo/!d' arquivo

Busca de motivos e afixagem de linhas de contexto antes/depois

grep -A1 -B1 "motivo" arquivo # sed -n '/motivo/! {x;d;}; /motivo/{x;p;x;p;n;p;x;}' arquivo

Nueração das linhas

cat -n arquivo # sed -e '=' arquivo | sed 'N;s/\n/\t/'

nl arquivo

Supressão dos saltos de linha

tr '\n' ' ' < arquivo # sed ':laço; N; $! b laço; s/\n//g' arquivo

Supressão de caracteres individuais

tr -d "[w-z]" < arquivo # sed 's/[w-z]//g' arquivo

Repetição de caracteres

echo "Booom diiiaaaa" | tr -s "ou" # echo " Booom diiiaaaa " | sed 's/oo*/o/g;s/uu*/u/'

Transposição de caracteres

echo "ABCDEF" | tr "[A-F]" "[a-f]" # echo "ABCDEF" | sed 'y/ABCDEF/abcdef/'

Formatação de arquivos, preferir os comandos s :

fold

fmt

par

Para algumas tarefas como "awk" e "perl" se fazem de maneira simples e rápida, como por exemplo :


Contar campos e caracteres

Contar linhas de um bloco ou dos objetos de um arquivo

Operações matemáticas

Calcular o cumprimento de uma cadeia

Manipular os dados binários

Loops nos quadros ou listas

etc.

Limites conhecidos das diferentes versões

Aqui estão algumas limitações conhecidas nas versões distribuídas da Sed, dependência naturalmente, de seus equipamentos, sua memória, de seu sistema operacional e das bibliotecas C utilizadas na compilação de Sed.


Comprimento máximo de uma linha

GNU sed : sem limitação

ssed : sem limitação

Tamanho máximo das memórias tampão (principal + secundária)

GNU sed : sem limitação

ssed : sem limitação

Número máximo de arquivos podendo ser lido pelo comando "r"

GNU sed v3+ : sem limitação

ssed : sem limitação

GNU sed v2.05 : o total das leituras (r) e escrituras (w) não deve ultrapassar 32

Número máximo de arquivos podendo ser escritor pelo comando "w"

GNU sed v3+ : sem limitação

ssed : sem limitação

GNU sed v2.05 : o total das leituras (r) e escrituras (w) não deve ultrapassar 32

Tamanho limite do nome de etiqueta

GNU sed : sem limitação

ssed : sem limitação

BSD sed : 8 caracteres

Tamanho limite do nome de arquivo em escritura

GNU sed : sem limitação

ssed : sem limitação

BSD sed : 8 caracteres

Número limite de conexões

GNU sed : sem limitação

ssed : sem limitação

As referências

Você encontrará aqui abaixo os livros bem como os sites que servirão para elaborar este documento.

Livres

UNIX Shell : Guia de formação com 160 exercícios corrigidos

Linguagens de ecript no sous Linux

sed & awk, Second Edition)

sed et awk, programação avançada

Os links

Debutantes e iniciados

SED

info sed

man sed

Sed - An Introduction and Tutorial

THE SED FAQ

sed, a stream editor

HANDY ONE-LINERS FOR SED

Versão afrancesada

Gurus

scripts

tutoriais

IRC

Freenode

irc://irc.freenode.net/#sed

SED - The Stream EDitor - Parte III

Continuação e fim => SED - The Stream EDitor - Part III

Veja também :
Este documento, intitulado « Sed - Introdução à SED - Parte II »a partir de CCM (br.ccm.net) está disponibilizado sob a licença Creative Commons. Você pode copiar, modificar cópias desta página, nas condições estipuladas pela licença, como esta nota aparece claramente.