Regex não ganancioso (relutante) correspondente no sed?

Estou tentando usar o sed para limpar linhas de URLs para extrair apenas o domínio.

Então de:

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

Eu quero:

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

(com ou sem a barra à direita, não importa)

Eu tentei:

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

e (escapando do quantificador não ganancioso)

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

mas não consigo fazer com que o quantificador não ganancioso ( ?) funcione, portanto ele sempre corresponde à seqüência inteira.

Nem o Regex Posix / GNU básico nem estendido reconhece o quantificador não ganancioso; você precisa de uma regex posterior. Felizmente, o regex Perl para esse contexto é muito fácil de obter:

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

Nesse caso específico, você pode fazer o trabalho sem usar uma regex não gananciosa.

Experimente este regex não ganancioso em [^/]*vez de .*?:

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

Com o sed, eu geralmente implemento uma pesquisa não gananciosa procurando qualquer coisa, exceto o separador até o separador:

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

Resultado:

http://www.suon.co.uk

isto é:

• não produza -n
• pesquisar, corresponder padrão, substituir e imprimir s/<pattern>/<replace>/p
• use o ;separador de comandos de pesquisa em vez de/ facilitar a digitação,s;<pattern>;<replace>;p
• lembre-se da correspondência entre colchetes \(... \), mais tarde acessível com \1, \2...
• partida http://
• seguido por qualquer coisa em colchetes [], [ab/]significaria tanto aou bou/
• primeiro ^em []meios not, então seguido por qualquer coisa, menos a coisa no[]
• isso [^/]significa qualquer coisa, exceto /caráter
• *é repetir o grupo anterior, o que [^/]*significa caracteres, exceto /.
• até agora sed -n 's;\(http://[^/]*\)significa pesquisar e lembrar http://seguido por qualquer caractere, exceto /e lembrar o que você encontrou
• queremos pesquisar até o final do domínio, para parar no próximo /e adicionar outro /no final: sed -n 's;\(http://[^/]*\)/'mas queremos corresponder ao restante da linha após o domínio, para adicionar.*
• agora que a correspondência lembrada no grupo 1 ( \1) é o domínio, substitua a linha correspondente pelas coisas salvas no grupo \1e imprima:sed -n 's;\(http://[^/]*\)/.*;\1;p'

Se você deseja incluir barra invertida também após o domínio, adicione mais uma barra invertida no grupo para lembrar:

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

resultado:

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

O sed não suporta o operador "não ganancioso".

Você precisa usar o operador "[]" para excluir "/" da correspondência.

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

PS: não há necessidade de barra invertida "/".

Simulando um quantificador preguiçoso (não guloso) no sed

E todos os outros sabores de regex!

1. Localizando a primeira ocorrência de uma expressão:

   • POSIX ERE (usando a -ropção)

     Regex:

     (EXPRESSION).*|.

     Sed:

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

     Exemplo (localizando a primeira sequência de dígitos) Demonstração ao vivo :

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

     12

     Como isso funciona ?

     Esse regex se beneficia de uma alternância |. Em cada posição, o mecanismo tenta escolher a correspondência mais longa (este é um padrão POSIX que também é seguido por outros dois mecanismos), o que significa que continua .até que uma correspondência seja encontrada ([0-9]+).*. Mas a ordem também é importante.

     

     Como o sinalizador global está definido, o mecanismo tenta continuar correspondendo caractere por caractere até o final da string de entrada ou nosso destino. Assim que o primeiro e único grupo de captura do lado esquerdo da alternância for correspondido, o (EXPRESSION)restante da linha também será consumido imediatamente .*. Agora mantemos nosso valor no primeiro grupo de captura.

   • POSIX BRE

     Regex:

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

     Sed:

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

     Exemplo (localizando a primeira sequência de dígitos):

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

     12

     Este é como a versão ERE, mas sem alternância envolvida. Isso é tudo. Em cada posição única, o mecanismo tenta corresponder a um dígito.

     

     Se for encontrado, outros dígitos a seguir serão consumidos e capturados e o restante da linha corresponderá imediatamente, caso contrário, *significa que mais ou zero pula sobre o segundo grupo de captura \(\([0-9]\{1,\}\).*\)*e chega a um ponto .para corresponder a um único caractere e esse processo continua.

2. Localizando a primeira ocorrência de um delimitado expressão :

   Essa abordagem corresponderá à primeira ocorrência de uma sequência delimitada. Podemos chamá-lo de um bloco de string.

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

   String de entrada:

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

   -EDE: end

   -SDE: start

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

   Resultado:

   start block #1 end

   O primeiro regex \(end\).*corresponde e captura o primeiro delimitador final ende substitui todos com caracteres capturados recentes, que é o delimitador final. Nesta fase, a nossa saída é: foobar start block #1 end.

   

   Em seguida, o resultado é passado para o segundo regex \(\(start.*\)*.\)*igual à versão POSIX BRE acima. Ele corresponde a um único caractere se o delimitador inicial startnão for correspondido, caso contrário ele corresponderá e captura o delimitador inicial e o restante dos caracteres.

   

Respondendo diretamente à sua pergunta

Usando a abordagem nº 2 (expressão delimitada), você deve selecionar duas expressões apropriadas:

• EDE: [^:/]\/

• SDE: http:

Uso:

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

Resultado:

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

Nota: isso não funcionará com delimitadores idênticos.

Solução não gananciosa para mais de um único caractere

Este tópico é realmente antigo, mas eu suponho que as pessoas ainda precisem. Digamos que você queira matar tudo até a primeira ocorrência de HELLO. Você não pode dizer [^HELLO]...

Portanto, uma boa solução envolve duas etapas, supondo que você possa poupar uma palavra única que não está esperando na entrada, digamos top_sekrit.

Nesse caso, podemos:

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

Obviamente, com uma entrada mais simples, você poderia usar uma palavra menor, ou talvez até um único caractere.

HTH!

sed - correspondência não gananciosa de Christoph Sieghart

O truque para obter uma correspondência não gananciosa no sed é corresponder a todos os caracteres, exceto aquele que termina a correspondência. Eu sei, um acéfalo, mas desperdicei minutos preciosos e os scripts de shell devem ser, afinal, rápidos e fáceis. Portanto, caso alguém mais precise:

Correspondência gananciosa

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

Correspondência não gananciosa

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

Isso pode ser feito usando o cut:

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

outra maneira, não usando regex, é usar o método de campos / delimitadores, por exemplo

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

sed certamente tem o seu lugar, mas este não é um deles!

Como Dee apontou: Basta usar cut. É muito mais simples e muito mais seguro nesse caso. Aqui está um exemplo em que extraímos vários componentes da URL usando a sintaxe do 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-)

da-te:

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

Como você pode ver, essa é uma abordagem muito mais flexível.

(todo o crédito para Dee)

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

sed -E interpreta expressões regulares como expressões regulares estendidas (modernas)

Atualização: -E no MacOS X, -r no GNU sed.

Ainda há esperança de resolver isso usando puro (GNU) sed. Apesar de essa não ser uma solução genérica, em alguns casos, você pode usar "loops" para eliminar todas as partes desnecessárias da string como esta:

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

• -r: use regex estendido (para parênteses + e sem escape)
• ": loop": define um novo rótulo chamado "loop"
• -e: adiciona comandos ao sed
• "t loop": volte ao rótulo "loop" se houver uma substituição bem-sucedida

O único problema aqui é que ele também cortará o último caractere separador ('/'), mas se você realmente precisar, pode simplesmente colocá-lo de volta depois que o "loop" terminar, basta acrescentar este comando adicional no final do anterior linha de comando:

-e "s,$,/,"

Como você declarou especificamente que está tentando usar sed (em vez de perl, cut, etc.), tente agrupar. Isso evita que o identificador não ganancioso potencialmente não seja reconhecido. O primeiro grupo é o protocolo (ou seja, 'http: //', 'https: //', 'tcp: //', etc). O segundo grupo é o domínio:

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

Se você não está familiarizado com o agrupamento, comece aqui .

Sei que essa é uma entrada antiga, mas alguém pode achar útil. Como o nome completo do domínio não pode exceder um comprimento total de 253 caracteres, substitua. * Por. \ {1, 255 \}

É assim que se faz uma correspondência não gananciosa de seqüências de caracteres múltiplos usando sed. Digamos que você queira alterar todos os itens foo...barpara <foo...bar>, por exemplo, esta entrada:

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

deve se tornar esta saída:

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

Para fazer isso, você converte foo e barra em caracteres individuais e, em seguida, use a negação desses caracteres entre eles:

$ 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

No exemplo acima:

1. s/@/@A/g; s/{/@B/g; s/}/@C/gestá convertendo {e }em seqüências de espaço reservado que não podem existir na entrada, para que esses caracteres estejam disponíveis para conversão fooebar para.
2. s/foo/{/g; s/bar/}/gestá convertendo fooe barpara {e} respectivamente
3. s/{[^{}]*}/<&>/gestá realizando a operação que queremos - convertendo foo...barpara<foo...bar>
4. s/}/bar/g; s/{/foo/gestá convertendo {e de }volta para fooebar .
5. s/@C/}/g; s/@B/{/g; s/@A/@/g está convertendo as seqüências de caracteres do espaço reservado em seus caracteres originais.

Observe que o acima exposto não depende de nenhuma string em particular não estar presente na entrada, pois ela fabrica essas strings na primeira etapa, nem se importa com a ocorrência de qualquer regexp em particular que você deseja corresponder, pois você pode usar {[^{}]*}quantas vezes for necessário. na expressão para isolar a correspondência real desejada e / ou com o operador de correspondência numérica seds, por exemplo, para substituir apenas a 2ª ocorrência:

$ 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

Ainda não vi essa resposta, então veja como você pode fazer isso com viou vim:

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

Isso executa a vi :%ssubstituição globalmente (a direita g), evita gerar um erro se o padrão não for encontrado ( e) e salva as alterações resultantes no disco e sai. Os &>/dev/nullimpede a GUI a partir brevemente piscando na tela, que pode ser irritante.

Eu gosto de usar vialgumas vezes para regexes super-complicado, porque (1) perl é morto morte, (2) vim tem um muito motor regex avançado, e (3) Eu já estou intimamente familiarizado com viexpressões regulares na minha edição de uso do dia-a-dia documentos.

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

não se preocupe, eu o comprei em outro fórum :)

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

Aqui está algo que você pode fazer com uma abordagem em duas etapas e o awk:

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

Saída: http://www.suepearson.co.uk

Espero que ajude!

Outra versão sed:

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

Corresponde /seguido por um caractere alfanumérico (não outra barra), assim como o restante dos caracteres até o final da linha. Depois, o substitui por nada (ou seja, exclui-o.)