Bem -vindo à segunda parte de nossa série, uma parte que se concentrará no SED, a versão GNU. Como você verá, existem várias variantes do SED, que estão disponíveis para algumas plataformas, mas vamos nos concentrar nas versões GNU sed 4.x. Muitos de vocês já ouviram falar de sed e já o usaram, principalmente como uma ferramenta de substituição. Mas isso é apenas um segmento do que o SED pode fazer, e faremos o possível para mostrar o máximo possível do que você pode fazer com isso. O nome significa Editor de fluxo, e aqui "Stream" pode ser um arquivo, um tubo ou simplesmente stdin. Esperamos que você tenha conhecimento básico do Linux e se você já trabalhou com expressões regulares ou pelo menos saiba o que é um regexp, melhor. Não temos espaço para um tutorial completo sobre expressões regulares, então, em vez disso, apenas lhe daremos uma ideia básica e muitos exemplos de sed. Existem muitos documentos que lidam com o assunto, e teremos algumas recomendações, como você verá em um minuto.

Instalação

Não há muito o que dizer aqui, porque é provável que você já tenha instalado o Sed, porque é usado em vários scripts do sistema e uma ferramenta inestimável na vida de um usuário Linux que deseja ser eficiente. Você pode testar qual versão você tem digitando

 $ sed -versão

No meu sistema, este comando me diz que eu tenho GNU sed 4.2.1 instalado, além de links para a página inicial e outras coisas úteis. O pacote é nomeado simplesmente 'sed', independentemente da distribuição, mas se o gentoo oferece sed implicitamente, acredito que isso significa que você pode ter certeza.

Conceitos

Antes de irmos mais longe, sentimos que é importante ressaltar o que exatamente é que sed, porque o "editor de fluxo" pode não tocar muitos sinos. O SED pega o texto de entrada, faz as operações especificadas em todas as linhas (a menos que especificado de outra forma) e imprime o texto modificado. As operações especificadas podem ser anexadas, inserir, excluir ou substituir. Isso não é tão simples quanto parece: esteja avisado que existem muitas opções e combinações que podem tornar um comando sed bastante difícil de digerir. Então, se você quiser usar sed, recomendamos que você aprenda o básico do regexps, e você pode pegar o resto enquanto vai. Antes de iniciarmos o tutorial, queremos agradecer a Eric Pement e outros pela inspiração e pelo que ele fez por todos que querem aprender e usar sed.

Expressões regulares

Como os comandos/scripts sed tendem a se tornar enigmáticos, sentimos que nossos leitores devem entender os conceitos básicos em vez de copiar e colar cegamente os comandos, eles não sabem o significado de. Quando alguém quer entender o que é um regexp, a palavra -chave é "combinando". Ou melhor ainda, “correspondência de padrões”. Por exemplo, em um relatório para o seu departamento de RH, você escreveu o nome de Nick ao se referir ao arquiteto de rede. Mas Nick seguiu em frente e John veio a tomar seu lugar, então agora você tem que substituir a palavra Nick por John. Se o arquivo for chamado Relatório.txt, você poderia fazer

 $ CAT Relatório.txt | sed 's/nick/John/g'> report_new.TXT

Por padrão, o sed usa o stdout, então você pode usar o operador de redirecionamento do seu shell, como no nosso exemplo abaixo. Este é um exemplo mais simples, mas ilustramos alguns pontos: combinamos com o padrão "Nick" e substituímos todas as instâncias por "John". Observe que o SED é sensível ao maiúsculas, então tenha cuidado e verifique seu arquivo de saída para ver se todas as substituições foram feitas. O exposto acima poderia ter sido escrito também assim:

 $ sed 's/nick/John/g' relatório.txt> report_new.TXT

Ok, mas onde estão as expressões regulares, você pergunta? Bem, primeiro queríamos molhar os pés com o conceito de correspondência e aqui vem a parte interessante.

Se você não tem certeza se você escreveu "Nick" por engano em vez de "Nick" e quer combinar isso também, você pode usar sed 's/nick | nick/John/g'. A barra vertical tem o mesmo significado que você deve saber se usou C, ou seja, sua expressão corresponderá à Nick ou usuario. Como você verá, o tubo também pode ser usado de outras maneiras, mas seu significado permanecerá. Outros operadores amplamente utilizados em regexps são '?', isso corresponde a zero ou uma instância do elemento anterior (flavou?r combinará com sabor e sabor), '*' significa zero ou mais e '+' corresponde a um ou mais elementos. '^' corresponde ao início da string, enquanto '$' faz o oposto. Se você é um usuário vi (m), algumas dessas coisas podem parecer familiares. Afinal, esses utilitários, juntamente com awk ou c, têm suas raízes nos primeiros dias do Unix. Não insistiremos mais sobre o assunto, pois as coisas se tornarão mais simples ao ler exemplos, mas o que você deve saber é que existem várias implementações de regexps: Posix, Posix estendido, Perl ou várias implementações de expressões regulares, garantidas para dar a dar Você é uma dor de cabeça.

Exemplos de sed

relatório sed 's/nick/John/g'.TXT

sed 's/nick | nick/John/g' relatório.TXT

arquivo sed 's/^/'.txt> file_new.TXT

sed -n '/, claro/,/atenção você \
Pay/P 'MyFile

arquivo de 12,18p sed -n.TXT

SED 12,18D Arquivo.TXT

arquivo g g.TXT 

script sed -f.arquivo sed.TXT

sed '5!s/ham/queijo/'arquivo.TXT

arquivo sed '$ d'.TXT

sed '/[0-9] \ 3 \/p' arquivo.TXT

sed '/boom/!arquivo s/aaa/bb/'.TXT

sed '17,/Disk/D 'Arquivo.TXT

eco um dois | sed "s/um/unos/i"

arquivo 'g; g'.TXT

sed 's/.$ // 'arquivo.TXT

sed 's/ ^[ ^t]*//' arquivo.TXT

sed 's/[ ^t]*$ //' arquivo.TXT

sed 's/ ^[ ^t]*//; s/[ ^]*$ //' arquivo.TXT

sed 's/foo/bar/' arquivo.TXT

sed 's/foo/bar/4' arquivo.TXT

arquivo sed 's/foo/bar/g'.TXT 

arquivo sed '/baz/s/foo/bar/g'.TXT

sed '/./,/^$/!arquivo d '.TXT

sed '/^$/n;/\ n $/d' arquivo.TXT

sed '/./, $!arquivo d '.TXT

sed -e: a -e '/^\ n*$/$ d; n;;/\ n $/ba' \
arquivo.TXT

sed -e: a -e '/\\ $/n; S/\\\\ n //; ta '\
arquivo.TXT

sed '/regex/,+5/expr/'

arquivo '1 ~ 3d'.TXT

arquivo sed -n '2 ~ 5p'.TXT

relatório sed 's/[nn] ick/John/g'.TXT

sed -n '/re/p; q;' arquivo.TXT

sed '0,/re/// d;' arquivo.TXT

sed '0,/re/s // para_that/' arquivo.TXT

sed 's/^[^,]*,/9999,/' arquivo.CSV

s/^ *\ (.*[^] \) *$/| \ 1 |/;
s/" *, */" |/g;
: laço
s/| *\ ([^", |] [^, |] *\) *, */| \ 1 |/g;
s/| *, */| \ 1 |/g;
T loop
s/ *|/|/g;
s/| */|/g;
s/^| \ (.*\) | $/\ 1/;

sed ': a; s/\ (^\ | [^0-9.] \) \ ([0-9] \+\) \\
([0-9] \ 3 \ \)/\ 1 \ 2, \ 3/g; ta 'arquivo.TXT

sed -r "s/\<(reg|exp)[a-z]+/\U&/g"

sed '1,20 s/Johnson/white/g' arquivo.TXT

sed '1,20 !Arquivo S/Johnson/White/G '.TXT

sed '/de/,/até/s/\/magenta/g; \
s/\/ciano/g; ' arquivo.TXT

sed '/endNotes:/, $ s/schaff/herzog/g; \
S/Kraft/Ebbing/G; ' arquivo.TXT

sed '/./H; $!d;; x;/regex/!arquivo d '.TXT

 sed -e '/./H; $!d; '-e' x;/re1/!d; \
/Re2/!d;/re3/!arquivo d '.TXT

 sed ': a; /\\ $/n; S/\\\\ n //; arquivo ta '.TXT

 sed 's/14 "/quatorze polegadas/g' arquivo.TXT

 sed 's/\/alguns \/unix \/path/\/a \/new \\
/Path/G 'Arquivo.TXT

 sed 's/[a g] // g' arquivo.TXT

sed 's/\ (.*\) foo/\ 1bar/'arquivo.TXT

sed '1!G; h; $!d ' 

sed '/\ n/!G; s/\ (.\) \ (.*\ n \)/& \ 2 \ 1 \
/; // d; s/.// '

arquivo 10q sed.TXT

sed -e: a -e '$ q; n; 11, $ d; ba' \
arquivo.TXT

sed '$!N; /^\ (.*\) \ n \ 1 $/!P; D '\
arquivo.TXT

sed '$!N; s/^\ (.*\) \ n \ 1 $/\ 1/; \
t; Arquivo d '.TXT

sed '$!N; $!Arquivo d '.TXT

arquivo sed -n '$ p'.TXT

sed '/regexp/!arquivo d '.TXT

sed -n '/regexp/g; 1!p;; h 'arquivo.TXT

sed -n '/regexp/n; p;' arquivo.TXT

Arquivo sed '/padrão/d'.TXT

sed '/./!arquivo d '.TXT

sed '/^$/n;/\ n $/n; // d' arquivo.TXT

sed -n '/^$/p; h;;/./x;/./p; '\
arquivo.TXT

sed 's/.\ x08 // G 'Arquivo

sed '/^$/q'

sed '1,/^$/d'

sed '/^Assunto: */!d; s ///; q '

sed 's/^/>/'

sed 's/^> //'

sed -e: a -e 's/]*> // g;/ 

sed '/./H; d;; x; s/\ n/= nl =/g '\
arquivo.txt | organizar \
| sed '1s/= nl = //; s/= nl =/\ n/g'

sed 's@/usr/bin@&/local@g' caminho.TXT

sed 's@^.*$@<<>> @g 'caminho.TXT

sed 's/\ (\/[^:]*\).*/\ 1/g 'caminho.TXT

sed 's/\ ([^:]*\).*/\ 1/'/etc/passwd

eco "Bem -vindo ao The Geek Stuff" | sed \
's/\ (\ b [a-z] \)/\ (\ 1 \)/g'
(W) elCome (t) o (t) ele (g) eek (s) tuff

sed -e '/^$/,/^end/s/hills/\
Montanhas/G 'Arquivo.TXT

sed -e '/^#/d'/etc/serviços | mais

sed '$ s@\ ([^:]*\): \ ([^:]*\): \ ([^:]*\
\)@\ 3: \ 2: \ 1@g 'caminho.TXT

sed -n -e '/regexp/=; x; 1!p; g; $!N; p; d; '\
-arquivo e h.TXT

sed '/regex/x; p; x;' arquivo.TXT

sed '/aaa/!d; /BBB/!d; /Ccc/!arquivo d '.TXT

sed '/aaa.*BBB.*CCC/!arquivo d '.TXT

sed -n '/^.\ 65 \/p 'arquivo.TXT

sed -n '/^.\ 65 \/!arquivo p '.TXT

arquivo sed '/regex/g'.TXT

sed '/regex/x; p; x; g;' arquivo.TXT

sed = arquivo.txt | sed 'n; s/\ n/\ t/'

sed -e: a -e 's/^.\ 1,78 \ $/\
&/; Ta 'arquivo.TXT

sed -e: a -e 's/^.\ 1,77 \ $/ &/; ta '-e \
's/\ ( *\) \ 1/\ 1/' arquivo.TXT

Conclusão

Isso é apenas uma parte do que pode ser informado sobre sed, mas esta série se entende como um guia prático, por isso esperamos que isso ajude você a descobrir o poder das ferramentas do Unix e se tornar mais eficiente em seu trabalho.

Tutoriais do Linux relacionados:

• Coisas para instalar no Ubuntu 20.04
• Coisas para fazer depois de instalar o Ubuntu 20.04 fossa focal linux
• Uma introdução à automação, ferramentas e técnicas do Linux
• Mint 20: Melhor que o Ubuntu e o Microsoft Windows?
• Coisas para fazer depois de instalar o Ubuntu 22.04 Jellyfish…
• Coisas para instalar no Ubuntu 22.04
• Ouça sua estação de rádio favorita com um único comando…
• Sistema Linux Hung? Como escapar para a linha de comando e…
• Ubuntu 20.04 Guia
• Mastering Bash Script Loops