¿Cómo insertar una nueva línea delante de un patrón?

¿Cómo insertar una nueva línea antes de un patrón dentro de una línea?

Por ejemplo, esto insertará una nueva línea detrás del patrón regex.

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

¿Cómo puedo hacer lo mismo pero delante del patrón?

Dado este archivo de entrada de muestra, el patrón para coincidir es el número de teléfono.

some text (012)345-6789

Debe convertirse

some text
(012)345-6789

Esto funciona bashy zsh, probado en Linux y OS X:

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

En general, para $seguido de un literal de cadena entre comillas simples, se bashrealiza una sustitución de barra diagonal inversa de estilo C, por ejemplo, $'\t'se traduce a una pestaña literal. Además, sed quiere que su literal de nueva línea se escape con una barra diagonal inversa, de ahí lo \anterior $. Y, por último, el signo de dólar en sí no debe citarse para que sea interpretado por el shell, por lo tanto, cerramos la cotización antes del $y luego la abrimos nuevamente.

Editar : como se sugiere en los comentarios de @ mklement0, esto también funciona:

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

Lo que sucede aquí es: todo el comando sed ahora es una cadena de estilo C, lo que significa que la barra invertida que sed requiere que se coloque antes de que la nueva línea literal se escape con otra barra invertida. Aunque es más legible, en este caso no podrá realizar sustituciones de cadenas de shell (sin volver a hacerlo feo).

Algunas de las otras respuestas no funcionaron para mi versión de sed. Cambiando la posición de &y \nfuncionó.

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

Editar: Esto no parece funcionar en OS X, a menos que lo instale gnu-sed.

En sed, no puede agregar nuevas líneas en la secuencia de salida fácilmente. Necesita usar una línea de continuación, que es incómoda, pero funciona:

$ sed 's/regexp/\
&/'

Ejemplo:

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

foo

Ver aquí para más detalles. Si quieres algo un poco menos incómodo, puedes intentar usarlo perl -pecon grupos de coincidencias en lugar de sed:

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

foo

$1 se refiere al primer grupo coincidente en la expresión regular, donde los grupos están entre paréntesis.

En mi Mac, lo siguiente inserta una 'n' en lugar de una nueva línea:

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

Esto reemplaza con nueva línea:

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

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

En este caso, no uso sed. Yo uso tr.

cat Somefile |tr ',' '\012' 

Esto toma la coma y la reemplaza con el retorno de carro.

Puede usar perl one-liners como lo hace con sed, con la ventaja de una expresión regular perl completa soporte (que es mucho más poderoso que lo que obtiene con sed). También hay muy poca variación en las plataformas * nix: perl es generalmente perl. Por lo tanto, puede dejar de preocuparse por cómo hacer que la versión particular de sed de su sistema haga lo que desea.

En este caso, puedes hacer

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

-pe pone a Perl en un bucle de "ejecutar e imprimir", muy parecido al modo de operación normal de sed.

' cita todo lo demás para que el caparazón no interfiera

()Alrededor de la expresión regular hay un operador de agrupación. $1en el lado derecho de la sustitución imprime lo que coincida dentro de estos parens.

Finalmente, \nes una nueva línea.

Independientemente de si está utilizando paréntesis como operador de agrupación, debe escapar de cualquier paréntesis que intente hacer coincidir. Entonces, una expresión regular para que coincida con el patrón que enumeras arriba sería algo así como

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

\(o \)coincide con un par literal, y \dcoincide con un dígito.

Mejor:

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

Me imagino que puedes descubrir qué están haciendo los números entre llaves.

Además, puede usar delimitadores que no sean / para su expresión regular. Entonces, si necesitas unir / no tendrás que escapar. Cualquiera de los siguientes es equivalente a la expresión regular al comienzo de mi respuesta. En teoría, puede sustituir cualquier carácter por el estándar / 's.

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

Un par de pensamientos finales.

usar en -nelugar de -peactuar de manera similar, pero no se imprime automáticamente al final. Puede ser útil si desea imprimir por su cuenta. Por ejemplo, aquí hay un grep-like ( m/foobar/es una coincidencia de expresiones regulares):

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

Si le resulta problemático lidiar con las nuevas líneas y desea que se maneje mágicamente por usted, agregue -l. Sin embargo, no fue útil para el OP, que estaba trabajando con nuevas líneas.

Sugerencia adicional: si tiene instalado el paquete pcre, viene con él pcregrep, que utiliza expresiones regulares compatibles con perl.

Hmm, las líneas nuevas escapadas parecen funcionar en versiones más recientes de sed(Tengo 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/'

funcionó bien en El Captitán con ()apoyo

Para insertar una nueva línea para transmitir en Linux, utilicé:

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

Donde file1estaba:

def

Antes del reemplazo de sed in situ, y:

abc
def

Después del reemplazo de sed en el lugar. Tenga en cuenta el uso de \\\n. Si los patrones tienen un "interior, escapa usando \".

en sed puede hacer referencia a grupos en su patrón con "\ 1", "\ 2", ... así que si el patrón que está buscando es "PATRÓN", y desea insertar "ANTES" delante de él , puedes usar, sin escapar

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

es decir

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

También puede hacer esto con awk, usando -vpara proporcionar el patrón:

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

Esto verifica si una línea contiene un patrón dado. Si es así, agrega una nueva línea al comienzo.

Vea un ejemplo 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!

Tenga en cuenta que afectará a todos los patrones en una línea:

$ 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

Esto funciona en MAC para mí

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

Dono si es perfecto ...

Después de leer todas las respuestas a esta pregunta, todavía me llevó muchos intentos obtener la sintaxis correcta para el siguiente script de ejemplo:

#!/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

El script agrega una nueva línea \nseguida de otra línea de texto al final de un archivo usando un solo sedcomando.

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

\ 0 es nulo, por lo que su expresión se reemplaza por nulo (nada) y luego ...
\ n es la nueva línea

En algunos sabores de Unix no funciona, pero creo que es la solución a su problema.

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

En vi en Red Hat, pude insertar retornos de carro usando solo el carácter \ r. Creo que esto ejecuta internamente 'ex' en lugar de 'sed', pero es similar, y vi puede ser otra forma de hacer ediciones masivas, como parches de código. Por ejemplo. Estoy rodeando un término de búsqueda con una declaración if que insiste en retornos de carro después de las llaves:

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

Tenga en cuenta que también tuve que insertar algunas pestañas para que las cosas se alineen mejor.