No codicioso (reacio) coincidencia de expresiones regulares en sed

Estoy tratando de usar sed para limpiar líneas de URL para extraer solo el dominio.

Entonces de:

http://www.suepearson.co.uk/product/174/71/3816/

Quiero:

http://www.suepearson.co.uk/

(ya sea con o sin la barra inclinada, no importa)

Yo he tratado:

 sed 's|\(http:\/\/.*?\/\).*|\1|'

y (escapando del cuantificador no codicioso)

sed 's|\(http:\/\/.*\?\/\).*|\1|'

pero parece que no puedo hacer que el cuantificador no codicioso ( ?) funcione, por lo que siempre termina haciendo coincidir toda la cadena.

Ni la expresión regular Posix / GNU básica ni extendida reconoce el cuantificador no codicioso; Necesitas una expresión regular posterior. Afortunadamente, la expresión regular de Perl para este contexto es bastante fácil de obtener:

perl -pe 's|(http://.*?/).*|\1|'

En este caso específico, puede hacer el trabajo sin usar una expresión regular no codiciosa.

Pruebe esta expresión regular no codiciosa en [^/]*lugar de .*?:

sed 's|\(http://[^/]*/\).*|\1|g'

Con sed, generalmente implemento la búsqueda no codiciosa buscando cualquier cosa excepto el separador hasta el separador:

echo "http://www.suon.co.uk/product/1/7/3/" | sed -n 's;\(http://[^/]*\)/.*;\1;p'

Salida:

http://www.suon.co.uk

esto es:

• no salga -n
• buscar, unir patrones, reemplazar e imprimir s/<pattern>/<replace>/p
• use el ;separador de comando de búsqueda en lugar de /hacerlo más fácil para escribirs;<pattern>;<replace>;p
• recuerda coincidencia entre paréntesis \(... \), luego accesible con \1, \2...
• partido http://
• seguido de cualquier cosa entre paréntesis [], [ab/]significaría ao bo/
• primero ^en los []medios not, seguido por cualquier cosa menos la cosa en el[]
• por lo que [^/]significa otra cosa que /el carácter
• *es repetir el grupo anterior, entonces [^/]*significa caracteres excepto /.
• hasta ahora sed -n 's;\(http://[^/]*\)significa buscar y recordar http://seguido de cualquier carácter excepto /y recordar lo que has encontrado
• queremos buscar hasta el final del dominio, así que deténgase en el siguiente, /agregue otro /al final: sed -n 's;\(http://[^/]*\)/'pero queremos hacer coincidir el resto de la línea después del dominio, así que agregue.*
• ahora la coincidencia recordada en el grupo 1 ( \1) es el dominio, así que reemplace la línea coincidente con cosas guardadas en el grupo \1e imprima:sed -n 's;\(http://[^/]*\)/.*;\1;p'

Si también desea incluir una barra diagonal inversa después del dominio, agregue una barra diagonal inversa más en el grupo para recordar:

echo "http://www.suon.co.uk/product/1/7/3/" | sed -n 's;\(http://[^/]*/\).*;\1;p'

salida:

http://www.suon.co.uk/

sed no es compatible con el operador "no codicioso".

Debe utilizar el operador "[]" para excluir "/" de la coincidencia.

sed 's,\(http://[^/]*\)/.*,\1,'

PD: no hay necesidad de barra diagonal inversa "/".

Simulación de cuantificador perezoso (no codicioso) en sed

¡Y todos los demás sabores regex!

1. Encontrar la primera aparición de una expresión:

   • POSIX ERE (usando la -ropción)

     Regex:

     (EXPRESSION).*|.

     Sed:

     sed -r ‍'s/(EXPRESSION).*|./\1/g' # Global `g` modifier should be on

     Ejemplo (encontrar la primera secuencia de dígitos) Demostración en vivo :

     $ sed -r 's/([0-9]+).*|./\1/g' <<< 'foo 12 bar 34'

     12

     ¿Cómo funciona ?

     Esta expresión regular se beneficia de una alternancia |. En cada posición, el motor intenta elegir la coincidencia más larga (este es un estándar POSIX que es seguido por un par de otros motores también), lo que significa que continúa .hasta que se encuentre una coincidencia ([0-9]+).*. Pero el orden también es importante.

     

     Como se establece el indicador global, el motor intenta continuar haciendo coincidir carácter por carácter hasta el final de la cadena de entrada o nuestro objetivo. Tan pronto como se empareja el primer y único grupo de captura del lado izquierdo de la alternancia, el (EXPRESSION)resto de la línea también se consume de inmediato .*. Ahora mantenemos nuestro valor en el primer grupo de captura.

   • POSIX BRE

     Regex:

     \(\(\(EXPRESSION\).*\)*.\)*

     Sed:

     sed 's/\(\(\(EXPRESSION\).*\)*.\)*/\3/'

     Ejemplo (encontrar la primera secuencia de dígitos):

     $ sed 's/\(\(\([0-9]\{1,\}\).*\)*.\)*/\3/' <<< 'foo 12 bar 34'

     12

     Esta es como la versión ERE pero sin alternar. Eso es todo. En cada posición, el motor intenta hacer coincidir un dígito.

     

     Si se encuentra, se consumen y capturan otros dígitos siguientes y el resto de la línea se empareja inmediatamente de lo contrario, ya que *significa más o cero se salta sobre el segundo grupo de captura \(\([0-9]\{1,\}\).*\)*y llega a un punto .para que coincida con un solo carácter y este proceso continúa.

2. Encontrar la primera aparición de una expresión delimitada :

   Este enfoque coincidirá con la primera aparición de una cadena delimitada. Podemos llamarlo un bloque de cuerda.

   sed 's/\(END-DELIMITER-EXPRESSION\).*/\1/; \
        s/\(\(START-DELIMITER-EXPRESSION.*\)*.\)*/\1/g'

   Cadena de entrada:

   foobar start block #1 end barfoo start block #2 end

   -EDE: end

   -SDE: start

   $ sed 's/\(end\).*/\1/; s/\(\(start.*\)*.\)*/\1/g'

   Salida:

   start block #1 end

   First regex \(end\).*coincide y captura el delimitador de primer extremo endy sustituye todos los caracteres coincidentes con caracteres capturados recientemente, que es el delimitador de final. En esta etapa nuestra salida es: foobar start block #1 end.

   

   Luego, el resultado se pasa a la segunda expresión regular \(\(start.*\)*.\)*que es la misma que la versión POSIX BRE anterior. Coincide con un solo carácter si el delimitador de inicio startno coincide, de lo contrario, coincide y captura el delimitador de inicio y coincide con el resto de caracteres.

   

Responde directamente tu pregunta

Usando el enfoque # 2 (expresión delimitada) debe seleccionar dos expresiones apropiadas:

• EDE: [^:/]\/

• SDE: http:

Uso:

$ sed 's/\([^:/]\/\).*/\1/g; s/\(\(http:.*\)*.\)*/\1/' <<< 'http://www.suepearson.co.uk/product/174/71/3816/'

Salida:

http://www.suepearson.co.uk/

Nota: esto no funcionará con delimitadores idénticos.

Solución no codiciosa para más de un personaje.

Este hilo es muy antiguo pero supongo que la gente todavía lo necesita. Digamos que quieres matar todo hasta la primera aparición de HELLO. No puedes decir[^HELLO] ...

Entonces, una buena solución implica dos pasos, suponiendo que puede ahorrar una palabra única que no espera en la entrada, digamos top_sekrit .

En este caso podemos:

s/HELLO/top_sekrit/     #will only replace the very first occurrence
s/.*top_sekrit//        #kill everything till end of the first HELLO

Por supuesto, con una entrada más simple, puede usar una palabra más pequeña o incluso un solo carácter.

HTH!

sed - correspondencia no codiciosa por Christoph Sieghart

El truco para obtener una coincidencia no codiciosa en sed es hacer coincidir todos los caracteres, excepto el que termina la coincidencia. Lo sé, es obvio, pero perdí unos minutos preciosos y los scripts de shell deberían ser, después de todo, rápidos y fáciles. Entonces, en caso de que alguien más lo necesite:

Emparejamiento codicioso

% echo "<b>foo</b>bar" | sed 's/<.*>//g'
bar

Emparejamiento no codicioso

% echo "<b>foo</b>bar" | sed 's/<[^>]*>//g'
foobar

Esto se puede hacer usando cortar:

echo "http://www.suepearson.co.uk/product/174/71/3816/" | cut -d'/' -f1-3

Otra forma, no usar expresiones regulares, es usar el método de campos / delimitador, por ejemplo

string="http://www.suepearson.co.uk/product/174/71/3816/"
echo $string | awk -F"/" '{print $1,$2,$3}' OFS="/"

sed Ciertamente tiene su lugar, pero este no es uno de ellos.

Como Dee ha señalado: solo úsalo cut. Es mucho más simple y mucho más seguro en este caso. Aquí hay un ejemplo donde extraemos varios componentes de la URL usando la sintaxis Bash:

url="http://www.suepearson.co.uk/product/174/71/3816/"

protocol=$(echo "$url" | cut -d':' -f1)
host=$(echo "$url" | cut -d'/' -f3)
urlhost=$(echo "$url" | cut -d'/' -f1-3)
urlpath=$(echo "$url" | cut -d'/' -f4-)

te dio:

protocol = "http"
host = "www.suepearson.co.uk"
urlhost = "http://www.suepearson.co.uk"
urlpath = "product/174/71/3816/"

Como puede ver, este es un enfoque mucho más flexible.

(todo crédito a Dee)

sed 's|(http:\/\/[^\/]+\/).*|\1|'

sed -E interpreta las expresiones regulares como expresiones regulares extendidas (modernas)

Actualización: -E en MacOS X, -r en GNU sed.

Todavía hay esperanza de resolver esto usando sed puro (GNU). A pesar de que esta no es una solución genérica, en algunos casos puede usar "bucles" para eliminar todas las partes innecesarias de la cadena como esta:

sed -r -e ":loop" -e 's|(http://.+)/.*|\1|' -e "t loop"

• -r: Usar expresiones regulares extendidas (para + y paréntesis sin escape)
• ": loop": define una nueva etiqueta llamada "loop"
• -e: agrega comandos a sed
• "t loop": Vuelve a la etiqueta "loop" si hubo una sustitución exitosa

El único problema aquí es que también cortará el último carácter separador ('/'), pero si realmente lo necesita, simplemente puede volver a colocarlo después de que finalice el "ciclo", simplemente agregue este comando adicional al final del anterior línea de comando:

-e "s,$,/,"

Debido a que declaró específicamente que está tratando de usar sed (en lugar de perl, cut, etc.), intente agrupar. Esto evita que el identificador no codicioso no sea reconocido. El primer grupo es el protocolo (es decir, 'http: //', 'https: //', 'tcp: //', etc.). El segundo grupo es el dominio:

echo "http://www.suon.co.uk/product/1/7/3/" | sed "s | ^ \ (. * // \) \ ([^ /] * \). * $ | \ 1 \ 2 |"

Si no está familiarizado con la agrupación, comience aquí .

Me doy cuenta de que esta es una entrada antigua, pero alguien puede encontrarla útil. Como el nombre de dominio completo no puede exceder una longitud total de 253 caracteres, reemplace. * Con. \ {1, 255 \}

Así es como hacer una coincidencia no codiciosa de cadenas de caracteres múltiples usando sed. Digamos que desea cambiar cada foo...bara, <foo...bar>por ejemplo, esta entrada:

$ cat file
ABC foo DEF bar GHI foo KLM bar NOP foo QRS bar TUV

debería convertirse en esta salida:

ABC <foo DEF bar> GHI <foo KLM bar> NOP <foo QRS bar> TUV

Para hacer eso, convierte foo y bar en caracteres individuales y luego usa la negación de esos caracteres entre ellos:

$ sed 's/@/@A/g; s/{/@B/g; s/}/@C/g; s/foo/{/g; s/bar/}/g; s/{[^{}]*}/<&>/g; s/}/bar/g; s/{/foo/g; s/@C/}/g; s/@B/{/g; s/@A/@/g' file
ABC <foo DEF bar> GHI <foo KLM bar> NOP <foo QRS bar> TUV

En lo anterior:

1. s/@/@A/g; s/{/@B/g; s/}/@C/gse está convirtiendo {y }a cadenas de marcador de posición que no pueden existir en la entrada para que esos caracteres estén disponibles para convertir fooy bara.
2. s/foo/{/g; s/bar/}/ges convertir fooy bara {y }respectivamente
3. s/{[^{}]*}/<&>/gestá realizando la operación que queremos: convertir foo...bara<foo...bar>
4. s/}/bar/g; s/{/foo/gestá convirtiendo {y de }vuelta a fooy bar.
5. s/@C/}/g; s/@B/{/g; s/@A/@/g está convirtiendo las cadenas de marcador de posición a sus caracteres originales.

Tenga en cuenta que lo anterior no se basa en que ninguna cadena particular no esté presente en la entrada, ya que fabrica tales cadenas en el primer paso, ni le importa qué ocurrencia de una expresión regular particular que desee hacer coincidir, ya que puede usar {[^{}]*}tantas veces como sea necesario en la expresión para aislar la coincidencia real que desea y / o con el operador de coincidencia numérica seds, por ejemplo, para reemplazar solo la segunda aparición:

$ sed 's/@/@A/g; s/{/@B/g; s/}/@C/g; s/foo/{/g; s/bar/}/g; s/{[^{}]*}/<&>/2; s/}/bar/g; s/{/foo/g; s/@C/}/g; s/@B/{/g; s/@A/@/g' file
ABC foo DEF bar GHI <foo KLM bar> NOP foo QRS bar TUV

Todavía no he visto esta respuesta, así que así es como puedes hacer esto con vio vim:

vi -c '%s/\(http:\/\/.\{-}\/\).*/\1/ge | wq' file &>/dev/null

Esto ejecuta la vi :%ssustitución globalmente (el final g), se abstiene de generar un error si no se encuentra el patrón ( e), luego guarda los cambios resultantes en el disco y se cierra. Esto &>/dev/nullevita que la GUI parpadee brevemente en la pantalla, lo que puede ser molesto.

Me gusta usar via veces por expresiones regulares muy complicado, debido a que (1) Perl es muertos moribundos, (2) vim tiene una muy motor de expresiones regulares avanzada, y (3) ya estoy íntimamente familiarizado con viexpresiones regulares en mi edición de uso del día a día documentos.

echo "/home/one/two/three/myfile.txt" | sed 's|\(.*\)/.*|\1|'

no te molestes, lo tengo en otro foro :)

sed 's|\(http:\/\/www\.[a-z.0-9]*\/\).*|\1| funciona tambien

Aquí hay algo que puede hacer con un enfoque de dos pasos y awk:

A=http://www.suepearson.co.uk/product/174/71/3816/  
echo $A|awk '  
{  
  var=gensub(///,"||",3,$0) ;  
  sub(/\|\|.*/,"",var);  
  print var  
}'  

Salida: http://www.suepearson.co.uk

¡Espero que ayude!

Otra versión sed:

sed 's|/[:alnum:].*||' file.txt

Coincide /seguido de un carácter alfanumérico (por lo que no es otra barra diagonal), así como el resto de los caracteres hasta el final de la línea. Luego lo reemplaza con nada (es decir, lo elimina).