Como inserir uma nova linha na frente de um padrão?

Como inserir uma nova linha antes de um padrão em uma linha?

Por exemplo, isso inserirá uma nova linha atrás do padrão regex.

sed 's/regex/&\n/g'

Como posso fazer o mesmo, mas na frente do padrão?

Dado esse arquivo de entrada de amostra, o padrão para combinar é o número de telefone.

some text (012)345-6789

Deve se tornar

some text
(012)345-6789

Isso funciona bashe é zshtestado no Linux e OS X:

sed 's/regexp/\'$'\n/g'

Em geral, para $seguido por uma string literal entre aspas simples bashrealiza a substituição da barra invertida no estilo C, por exemplo, $'\t'é traduzida para uma guia literal. Além disso, o sed deseja que seu literal de nova linha seja escapado com uma barra invertida, daí o \anterior $. E, finalmente, o próprio sinal de cifrão não deve ser citado para que seja interpretado pelo shell; portanto, fechamos a cotação antes da $e depois a abrimos novamente.

Edit : Como sugerido nos comentários por @ mklement0, isso também funciona:

sed $'s/regexp/\\\n/g'

O que acontece aqui é: todo o comando sed agora é uma string no estilo C, o que significa que a barra invertida que o sed precisa ser colocada antes que a nova linha literal agora seja escapada com outra barra invertida. Embora seja mais legível, nesse caso, você não poderá fazer substituições de string de shell (sem torná-lo feio novamente).

Algumas das outras respostas não funcionaram na minha versão do sed. Mudar a posição &e \nfuncionou.

sed 's/regexp/\n&/g' 

Editar: parece não funcionar no OS X, a menos que você instale gnu-sed.

No sed, você não pode adicionar novas linhas no fluxo de saída com facilidade. Você precisa usar uma linha de continuação, o que é estranho, mas funciona:

$ sed 's/regexp/\
&/'

Exemplo:

$ echo foo | sed 's/.*/\
&/'

foo

Veja aqui para detalhes. Se você quiser algo um pouco menos estranho, tente usar perl -pecom grupos de correspondência em vez de sed:

$ echo foo | perl -pe 's/(.*)/\n$1/'

foo

$1 refere-se ao primeiro grupo correspondente na expressão regular, onde os grupos estão entre parênteses.

No meu mac, o seguinte insere um único 'n' em vez de nova linha:

sed 's/regexp/\n&/g'

Isso substitui a nova linha:

sed "s/regexp/\\`echo -e '\n\r'`/g"

echo one,two,three | sed 's/,/\
/g'

Nesse caso, eu não uso sed. Eu uso tr.

cat Somefile |tr ',' '\012' 

Isso pega a vírgula e a substitui pelo retorno de carro.

Você pode usar one-liners perl da mesma forma que o sed, com a vantagem da expressão regular completa do perl suporte (que é muito mais poderoso do que o obtido com o sed). Também há muito pouca variação entre as plataformas * nix - o perl geralmente é o perl. Portanto, você pode parar de se preocupar em como fazer com que a versão do sed do seu sistema específico faça o que você deseja.

Nesse caso, você pode fazer

perl -pe 's/(regex)/\n$1/'

-pe coloca o perl em um loop "execute and print", bem como o modo normal de operação do sed.

' cita todo o resto para que o shell não interfira

()ao redor do regex é um operador de agrupamento. $1no lado direito da substituição, imprime o que foi encontrado dentro desses parênteses.

Finalmente, \né uma nova linha.

Independentemente de você estar usando parênteses como um operador de agrupamento, você precisa escapar dos parênteses que está tentando corresponder. Portanto, uma regex para corresponder ao padrão listado acima seria algo como

\(\d\d\d\)\d\d\d-\d\d\d\d

\(ou \)corresponde a um paren literal e \dcorresponde a um dígito.

Melhor:

\(\d{3}\)\d{3}-\d{4}

Eu imagino que você possa descobrir o que os números nos aparelhos estão fazendo.

Além disso, você pode usar delimitadores diferentes de / para seu regex. Portanto, se você precisar corresponder / não precisará escapar dela. Qualquer uma das opções abaixo é equivalente à regex no início da minha resposta. Em teoria, você pode substituir qualquer caractere pelos padrões.

perl -pe 's#(regex)#\n$1#'
perl -pe 's{(regex)}{\n$1}'

Algumas considerações finais.

usando em -nevez de -peagir da mesma forma, mas não é impresso automaticamente no final. Pode ser útil se você quiser imprimir sozinho. Por exemplo, aqui está um grep-alike ( m/foobar/é uma correspondência de regex):

perl -ne 'if (m/foobar/) {print}'

Se você acha que lidar com novas linhas é problemático e deseja que ele seja tratado magicamente por você, adicione -l. Não é útil para o OP, que estava trabalhando com novas linhas, no entanto.

Dica de bônus - se você tiver o pacote pcre instalado, ele vem com ele pcregrep, que usa expressões regulares compatíveis com perl.

Hmm, as novas linhas que escaparam parecem funcionar em versões mais recentes do sed(eu tenho o GNU sed 4.2.1),

dev:~/pg/services/places> echo 'foobar' | sed -r 's/(bar)/\n\1/;'
foo
bar

echo pattern | sed -E -e $'s/^(pattern)/\\\n\\1/'

funcionou bem no El Captitan com o ()apoio

Para inserir uma nova linha no fluxo de saída no Linux, usei:

sed -i "s/def/abc\\\ndef/" file1

Onde file1estava:

def

Antes da substituição no local sed e:

abc
def

Após a substituição no local sed. Observe o uso de \\\n. Se os padrões tiverem um "interior, escape usando \".

no sed, você pode fazer referência a grupos no seu padrão com "\ 1", "\ 2", .... portanto, se o padrão que você procura é "PATTERN" e deseja inserir "ANTES" na frente dele , você pode usar, sem escapar

sed 's/(PATTERN)/BEFORE\1/g'

ie

  sed 's/\(PATTERN\)/BEFORE\1/g'

Você também pode fazer isso com o awk, usando -vpara fornecer o padrão:

awk -v patt="pattern" '$0 ~ patt {gsub(patt, "\n"patt)}1' file

Isso verifica se uma linha contém um determinado padrão. Nesse caso, ele anexa uma nova linha ao início.

Veja um exemplo básico:

$ cat file
hello
this is some pattern and we are going ahead
bye!
$ awk -v patt="pattern" '$0 ~ patt {gsub(patt, "\n"patt)}1' file
hello
this is some 
pattern and we are going ahead
bye!

Observe que isso afetará todos os padrões em uma linha:

$ cat file
this pattern is some pattern and we are going ahead
$ awk -v patt="pattern" '$0 ~ patt {gsub(patt, "\n"patt)}1' d
this 
pattern is some 
pattern and we are going ahead

Isso funciona no MAC para mim

sed -i.bak -e 's/regex/xregex/g' input.txt sed -i.bak -e 's/qregex/\'$'\nregex/g' input.txt

Dono, se é o perfeito ...

Depois de ler todas as respostas para essa pergunta, ainda me levou muitas tentativas para obter a sintaxe correta para o seguinte script de exemplo:

#!/bin/bash
# script: add_domain
# using fixed values instead of command line parameters $1, $2
# to show typical variable values in this example
ipaddr="127.0.0.1"
domain="example.com"
# no need to escape $ipaddr and $domain values if we use separate quotes.
sudo sed -i '$a \\n'"$ipaddr www.$domain $domain" /etc/hosts

O script anexa uma nova linha \nseguida por outra linha de texto ao final de um arquivo usando um único sedcomando.

sed -e 's/regexp/\0\n/g'

\ 0 é nulo; portanto, sua expressão é substituída por nulo (nada) e depois ...
\ n é a nova linha

Em alguns sabores do Unix não funciona, mas acho que é a solução para o seu problema.

echo "Hello" | sed -e 's/Hello/\0\ntmow/g'
Hello
tmow

No vi da Red Hat, eu pude inserir retornos de carro usando apenas o caractere \ r. Acredito que isso execute internamente 'ex' em vez de 'sed', mas é semelhante e o vi pode ser outra maneira de fazer edições em massa, como patches de código. Por exemplo. Estou cercando um termo de pesquisa com uma instrução if que insiste em retornos de carro após as chaves:

:.,$s/\(my_function(.*)\)/if(!skip_option){\r\t\1\r\t}/

Observe que eu também pedi para inserir algumas guias para melhorar o alinhamento das coisas.