O que é?
O Sed é um editor de textos não
interativo.
Ele pode editar automaticamente, sem
interação do usuário, vários arquivos seguindo um conjunto de
regras especificadas.
O que significa a palavra Sed
Vem do inglês "Stream EDitor",
ou seja, editor de fluxos (de texto).
Como saber se devo usar o Sed
Sendo um editor de textos não
interativo, o Sed é excelente para desempenhar algumas tarefas, mas
em outras seu uso não é aconselhado.
Quando usar o Sed
A característica principal do Sed é
poder editar arquivos automaticamente.
Então sempre que você precisar fazer
alterações sistemáticas em vários arquivos, o Sed é uma solução
eficaz.
Por exemplo, você tem um diretório
cheio de relatórios de vendas, e descobriu que por um erro na
geração, todas as datas saíram erradas, com o ano de 1999 onde era
para ser 2000. Num editor de textos normal, você tem que abrir os
relatórios um por um e alterar o ano em todas as ocorrências.
Certo, isso não é tão complexo se o
editor de textos possuir uma ferramenta de procura e troca, também
chamado de substituição.
Mas então suponhamos que o erro da
data não seja o ano, e sim o formato, tendo saído como mm/dd/aaaa
quando deveria ser dd/mm/aaaa. Aqui não é uma substituição e sim
uma troca de lugares, e uma ferramenta simples de procura e troca não
poderá ajudar.
Esse é um caso típico onde o Sed
mostra seu poder: alterações complexas em vários arquivos.
Utilizando o Sed, a solução para este
problema (que veremos adiante) é até simples, bastando definir uma
série de regras de procura e troca, e o programa se encarregará de
executá-las e arrumar os relatórios.
Quando não usar o Sed
Nenhuma ferramenta é ideal para todas
as tarefas, e o Sed não é uma exceção à regra.
Edição genérica de textos
Ele não é prático para ser utilizado
como editor de textos de uso genérico.
Para escrever textos, ou alterar coisas
simples, é mais rápido e fácil abrir um editor de textos
interativo como o vi ou o emacs e fazer a alteração "na mão".
Programação avançada
O Sed não é uma linguagem de
programação completa, pois não possui variáveis, funções
matemáticas, interação com o sistema operacional, entre outras
limitações. Mas bem, ele é um manipulador de texto e não uma
linguagem de uso geral.
Algumas estruturas complexas podem ser
simuladas com alguma técnica, mas se o seu programa em Sed começou
a inchar muito, é aconselhável reescrevê-lo numa linguagem com
mais recursos, como o perl.
Como ele funciona
O Sed funciona como um filtro, por onde
você passa um texto X e ele joga na saída um texto Y.
O texto X virou Y seguindo algumas
regrinhas que você determinou.
Pense no Sed como um processador de
alimentos, dependendo da lâmina utilizada, a batata sai cortada de
uma maneira diferente :)
o Sed funciona como um filtro, ou
conversor.
o Sed é orientado a linha, de cima
para baixo, da esquerda para a direita.
o Sed lê uma linha da entrada padrão
(STDIN) ou de um arquivo especificado, aplica os comandos de edição
e mostra o resultado na saída padrão (STDOUT). vai para a próxima
linha e repete o processo.
o Sed aceita endereços para os
comandos.
o Sed aplica os comandos para todas as
linhas caso um endereço não seja especificado.
o Sed faz uso intensivo de expressões
regulares.
Sua sintaxe
A sintaxe genérica de um comando Sed
é:
sed [opções] regras [arquivo]
Sendo que regras tem a forma genérica
de:
[endereço1 [, endereço2]] comando
[argumento]
Exemplo
Como notação tradicional, o que está
[entre colchetes] é opcional, então a sintaxe Sed mais simples que
existe é sed regra como em:
prompt$ cat
texto.txt | sed p
Ou seja, o Sed lendo da entrada padrão
o conteúdo do arquivo texto.txt via duto |, aplica o comando p para
todas as linhas do arquivo, ou seja, as duplica.
0.2.2. Outros exemplos
Um outro exemplo do Sed com opções e
recebendo um arquivo como parâmetro seria:
prompt$ sed -n p texto.txt
E ainda, agora especificando um
endereço para o comando p:
prompt$ sed -n 5p texto.txt
Ou seja, este comando imprime apenas a
linha 5 do texto.txt
Tornando arquivos Sed executáveis
O interpretador de comandos mais
utilizado (bash) sempre procura na primeira linha de um arquivo
instruções para executá-lo.
Se um arquivo é um programinha em
shell, basta colocar
#!/bin/sh
Na primeira linha para que o bash saiba
que deve executá-lo com o comando /bin/sh. O mesmo funciona para
qualquer outro interpretador, como o Sed. então para tornar um
arquivos de comandos Sed executável basta colocar como primeira
linha:
#!/bin/sed -f
E é claro, torná-lo executável:
prompt$ chmod +x programa.sed
E na linha de comando, chame-o
normalmente:
prompt$
./programa.sed texto.txt
prompt$ cat
texto.txt | ./programa.sed
Descrição de todos os comandos
prompt$ man sed
prompt$ pinfo sed
Ou num resumo rápido:
Legenda:
[ARQUIVO] arquivo ou fluxo de
texto (via pipe) original a ser modificado
[TEXTO] trecho de texto. pode
ser uma palavra, uma linha,
várias separadas por
\n, ou mesmo um vazio.
[PADRÃO] [TEXTO] contido no
ESPAÇO PADRÃO
= imprime o número da linha atual do
[ARQUIVO]
# inicia um comentário
! inverte a lógica do comando
; separador de comandos
, separador de faixas de endereço
{ início de bloco de comandos
} fim de bloco de comandos
s substitui um trecho de texto por
outro
y traduz um caractere por outro
i insere um texto antes da linha atual
c troca a linha atual por um texto
a anexa um texto após a linha atual
g restaura o [TEXTO] contido no ESPAÇO
RESERVA (sobrescrevendo)
G restaura o [TEXTO] contido no ESPAÇO
RESERVA (anexando)
h guarda o [PADRÃO] no ESPAÇO RESERVA
(sobrescrevendo)
H guarda o [PADRÃO] no ESPAÇO RESERVA
(anexando)
x troca os conteúdos dos ESPAÇO
PADRÃO e RESERVA
p imprime o [PADRÃO]
P imprime a primeira linha do [PADRÃO]
l imprime o [PADRÃO] mostrando
caracteres brancos
r inclui conteúdo de um arquivo antes
da linha atual
w grava o [PADRÃO] num arquivo
: define uma marcação
b pula até uma marcação
t pula até uma marcação, se o último
s/// funcionou (condicional)
d apaga o [PADRÃO]
D apaga a primeira linha do [PADRÃO]
n vai para a próxima linha
N anexa a próxima linha no [PADRÃO]
q finaliza o Sed imediatamente
Lista de todos os comandos por
categoria
informações =
marcadores :
comentários #
comandos de edição s i c
a y
comandos de registradores g G h H
x
comandos de impressão p P l
comandos de arquivo r w
modificadores g i !
separadores ; -e \n
controle de fluxo b t d D
n N q
endereço // ,
limitadores {} \(\)
registradores dinâmicos \1 \2
... \9
Sed e shell
Com o Sed sendo invocado na linha de
comando, deve-se ter alguns cuidados para evitar transtornos. O
interpretador de comandos (shell), interpreta a linha de comando
antes de processá-la, então alguns caracteres especiais como $, \ e
!, são interpretados pelo shell antes de chegarem ao Sed,
modificando o comportamento esperado.
Para evitar isso coloque os comandos
Sed sempre entre aspas simples:
prompt$ sed 's/isso/aquilo/' texto.txt
Salvo quando no meio do comando Sed,
existir algo que deva ser interpretado, como uma variável por
exemplo. Neste caso coloque os comandos entre aspas duplas:
prompt$ sed "s/$HOME/aquilo/"
texto.txt
Ou ainda, para evitar completamente a
interpretação do shell, sem se preocupar com aspas, coloque os
comandos Sed num arquivo. Veja o tópico Colocando comandos Sed num
arquivo.
Usando outros delimitadores
No comando s
É comum ao fazer um comando de
substituição s/// conter uma / num dos dois lados do comando, como
quando querendo substituir /usr/local/bin por /usr/bin.
Sendo a barra o delimitador do comando
s as outras barras comuns devem ser escapadas com a barra invertida
\, para não serem confundidas com os delimitadores normais, ficando
o monstro a seguir:
prompt$ sed
's/\/usr\/local\/bin/\/usr\/bin/' texto.txt
Para evitar ter que ficar se escapando
todas estas barras, basta lembrar que o comando s aceita qualquer
delimitador, sendo a barra apenas um padrão de referências
históricas. Então, neste caso, poderíamos escolher outro
delimitador como por exemplo a vírgula:
prompt$ sed
's,/usr/local/bin,/usr/bin,' texto.txt
Evitando-se de ter que ficar escapando
as barras. A mesma dica vale para o comando y.
E se precisássemos apagar as linhas
que contém o /usr/local/bin? Teríamos que colocar o nome do
diretório no endereço do comando d, voltando com a festa dos
escapes:
prompt$ sed
'/\/usr\/local\/bin/d' texto.txt
Para usarmos outro delimitador no
endereço, basta escaparmos o primeiro, que no caso abaixo é a
vírgula:
prompt$ sed
'\,/usr/local/bin,d' texto.txt
Confusão de delimitadores com o texto
a ser procurado é muito comum de acontecer, então se algo não está
funcionando como deveria, olhe com cuidado para ver se não há
conflitos entre eles.
Gravando o resultado no mesmo
arquivo
Problema inicial
O procedimento comum quando se quer
gravar num arquivo o resultado de um comando Sed, é o
redirecionamento:
prompt$ sed 'comando' texto.txt >
texto-alterado.txt
Mas é muito comum, ao alterarmos um
arquivo, queremos gravar estas alterações no próprio arquivo
original. A tentativa intuitiva seria:
prompt$ sed 'comando' texto.txt >
texto.txt
Mas é só fazer para ver. Além de não
dar certo, você ainda perderá todo o conteúdo do arquivo.
Isso acontece porque ao fazer o
redirecionamento >, o shell abre imediatamente o arquivo
referenciado, antes mesmo de começar a executar o comando Sed. E
como este é um redirecionamento destrutivo > e não incremental
>>, se o arquivo já existir, ele será truncado, e seu
conteúdo perdido. A essa altura, o Sed começará seu processamento
já lendo um arquivo texto.txt vazio, e aplicados qualquer comandos
Sed num arquivo vazio, o resultado será o próprio arquivo vazio.
Solução genérica
Para evitar isso, voltamos a primeira
tática de gravar o resultado num outro arquivo, e depois o mais
natural é mover o arquivo novo sobre o original:
prompt$ sed 'comando' texto.txt >
texto-alterado.txt
prompt$ mv texto-alterado.txt texto.txt
Para a grande maioria dos casos, isso é
suficiente, mas convém aqui lembrar que caso o arquivo 'texto.txt'
possua atributos especiais, grupo diferente do padrão do usuário,
ou referências (links, simbólicos ou não) para outros arquivos,
tudo isso será perdido. Ao mover o arquivo recém-criado, com os
atributos padrão do sistema, sobre o original, este perderá seus
atributos e ficará com os padrões do sistema, herdado do arquivo
novo.
Solução segura
Para evitar isso, a abordagem mais
ortodoxa e segura seria aplicar o comando Sed numa cópia e gravar o
resultado no arquivo original via redirecionamento:
prompt$ cp -a texto.txt texto-tmp.txt
prompt$ sed 'comando' texto-tmp.txt >
texto.txt
prompt$ rm texto-tmp.txt
Novamente, isso só é necessário com
arquivos especiais, senão a solução com o mv pode ser usada. Mas é
importante ter em mente esta outra maneira e principalmente saber o
porque de utilizá-la, sendo este conhecimento aplicável a qualquer
outro comando do sistema que leia e grave arquivos.
Como substituir alguma coisa por
uma quebra de linha
No Sed da GNU, a partir da versão
3.02.80(*), foi adicionado o \n como escape válido dos dois lados do
comando s///. Com isso a tarefa de colocar cada palavra numa linha
isolada, ou seja, trocar espaços em branco por quebras de linha,
fica trivial:
prompt$ sed 's/ /\n/g' texto.txt
Mas com outras versões do Sed que não
entendem este escape, a quebra de linha deve ser inserida
literalmente e deve ser escapada:
prompt$ sed 's/ /\
prompt$ /g'
texto.txt
Como curiosidade, a operação inversa,
de colocar todas as linhas de um arquivo numa linha só, já é mais
trabalhosa e utiliza o conceito de laço:
prompt$ sed ':a;$!N;s/\n/ /g;ta'
(*) veja o tópico Nota sobre os
adicionais GNU
Apagando linhas específicas
O comando para apagar linhas é o d.
O único detalhe nesta tarefa é
especificar quais linhas você vai querer apagar. Isso está
completamente coberto no tópico O endereço.
Como ignorar maiúsculas e
minúsculas
O jeito padrão do Sed ser
"ignore-case", é dizendo literalmente todas as
possibilidades, como em:
prompt$ sed
'/[Rr][Oo][Oo][Tt]/d' texto.txt
Para apagar todas as linhas que contêm
a palavra root, ROOT, RooT etc.
No Sed da GNU, a partir da versão
3.01-beta1(*), foi adicionado o modificador I no endereço e no
comando s///, fazendo com que o comando acima fique mais simples:
prompt$ sed
'/root/Id' texto.txt
Ou ainda:
prompt$ sed 's/root/administrador/Ig'
texto.txt
(*) veja o tópico Nota sobre os
adicionais GNU
Lendo e gravando em arquivos
externos
0.4.1. Lendo arquivos
Uma tarefa comum é incluir cabeçalho
e rodapé num arquivo qualquer. O Sed possui um comando específico
para ler arquivos, o r, então basta(*):
prompt$ sed -e '1r cabecalho.txt' -e
'$r rodape.txt' texto.txt
Para incluir o cabeçalho após a linha
1 e incluir o rodapé após a última linha.
(*) a explicação do porquê das
opções -e está no tópico Aplicando vários comandos de uma vez.
Gravando arquivos
O comando w grava num arquivo a linha
atual, ou melhor, o conteúdo do espaço padrão. Por exemplo, você
quer gravar num arquivo o resultado de uma busca por linhas que
contêm a palavra estorvo. A solução não-Sed seria:
prompt$ grep 'estorvo' texto.txt >
estorvos.txt
Nosso similar em Sed seria:
prompt$ sed '/estorvo/w estorvos.txt'
texto.txt
Gravar dados num arquivo também pode
servir de espaço auxiliar caso o espaço reserva não seja
suficiente. Mas esta é uma opção drástica, não tão flexível.
Mais informações sobre o espaço reserva no tópico Conhecendo os
registradores internos.
Trocando um trecho de texto por
outro
Uma tarefa que parece simples mas
confunde, é trocar um trecho de texto, como um parágrafo inteiro
por exemplo, por outro trecho, independente do número de linhas de
ambos.
Trocar várias linhas por uma
Essa é simples, basta usar o comando
c, que "Coloca" um texto no lugar da linha atual. A única
complicação é definir o endereço, para aplicar o comando apenas
nas linhas desejadas. Por exemplo, vamos colocar uma frase no lugar
de uma área de texto pré-formatado num documento HTML. Esta área é
delimitada pelos identificadores <pre> e </pre>:
prompt$ sed '/<pre>/,/<\/pre>/c
\
prompt$ aqui tinha texto pré-formatado'
texto.html
Note que o comando c (assim como o a e
o i) exige que o texto que ele recebe como parâmetro esteja na linha
seguinte, estando a quebra de linha escapada com a barra invertida \
No Sed da GNU, a partir da versão
3.02a(*), é permitido que se coloque o texto na mesma linha:
prompt$ sed '/<pre>/,/<\/pre>/c
aqui tinha texto pré-formatado' texto.html
(*) veja o tópico Nota sobre os
adicionais GNU
Trocar várias linhas por outras
Similarmente a trocar por apenas uma
linha, pode-se usar o comando c e passar várias linhas para ele. O
único detalhe é que todas as linhas devem ser escapadas no final,
menos a última:
prompt$ sed
'/<pre>/,/<\/pre>/c \
prompt$ aqui tinha texto
pré-formatado,\
prompt$ mas eu resolvi tirar.\
prompt$ porque?\
prompt$ porque sim' texto.html
É claro, quando o comando começa a
ficar grande desse jeito, é melhor colocá-lo num arquivo. Saiba
mais detalhes sobre isso no tópico Colocando comandos sed num
arquivo.
Mas melhor ainda é separar o comando
Sed do texto, colocando-o num arquivo separado. Assim, quando se
precisar alterar este texto, basta editá-lo, sem mudar o comando
Sed, e sem precisar ficar colocando \ no final de cada linha.
Supondo que nosso texto explicativo do
porquê da retirada do texto pré-formatado foi gravado no arquivo
desculpa.txt, utilizaremos o comando r para lê-lo e o comando d para
apagar o texto antigo:
prompt$ sed -e '/<\/pre>/r
desculpa.txt' -e '/<pre>/,/<\/pre>/d' texto.html
Então acompanhe o que acontece: o
primeiro comando será executado apenas na linha </pre> que é
o fechamento do trecho, então vamos esquecer dele por enquanto. O
segundo comando diz para apagar o trecho desde <pre> até
</pre>, então assim que começar o trecho, ele vai apagando,
linha por linha.
Ao chegar na linha que contém o
</pre>, o primeiro comando Sed entra em ação e lê o arquivo
desculpa.txt, colocando seu conteúdo imediatamente após a linha
atual. Em seguida, o segundo comando apaga a linha </pre>,
completando a tarefa.
Esta segunda solução é mais difícil
de entender e implementar, mas é muito mais prática caso a
alteração do texto a ser colocado seja freqüente, além destas
alterações poderem ser feitas por alguém que nem saiba o que é
Sed, pois será apenas um texto normal.
Note que sempre que o </pre> foi
referenciado nos endereços, a barra foi escapada, ficando <\/pre>.
A explicação desse escape está em Usando outros delimitadores.
obs.: talvez o <pre></pre>
não seja um exemplo dos mais didáticos, mas não me veio algo mais
comum à mente...
Emulando outros comandos
Aqui vão alguns exemplos de emulações
de outros comandos usando-se o Sed:
|
comando
|
emulação
|
cat
|
sed
:
|
head
|
sed
10q
|
grep
|
sed
/padrão/!d
|
grep
-v
|
sed
/padrão/d
|
tac
|
sed
1!G;h;$!d
|
tail
-1
|
sed
$!d
|
tr
A-Z a-z
|
sed
y/ABCDEF...UVWXYZ/abcdef...uvwxyz/
|
wc
-l
|
sed
-n $=
|
