Correspondance regex non gourmande (réticente) dans sed?

J'essaie d'utiliser sed pour nettoyer les lignes d'URL pour extraire uniquement le domaine.

Donc à partir de:

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

Je voudrais:

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

(avec ou sans la barre oblique de fin, cela n'a pas d'importance)

J'ai essayé:

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

et (échapper au quantificateur non gourmand)

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

mais je n'arrive pas à faire fonctionner le quantifier non gourmand ( ?), donc il finit toujours par correspondre à la chaîne entière.

Ni regex Posix / GNU de base ni étendu ne reconnaît le quantificateur non gourmand; vous avez besoin d'une expression régulière ultérieure. Heureusement, l'expression rationnelle Perl pour ce contexte est assez facile à obtenir:

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

Dans ce cas spécifique, vous pouvez faire le travail sans utiliser une expression régulière non gourmande.

Essayez cette expression régulière non gourmande [^/]*au lieu de .*?:

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

Avec sed, j'implémente généralement la recherche non gourmande en recherchant autre chose que le séparateur jusqu'au séparateur:

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

Production:

http://www.suon.co.uk

c'est:

• ne pas sortir -n
• rechercher, faire correspondre le motif, remplacer et imprimer s/<pattern>/<replace>/p
• utilisez le ;séparateur de commande de recherche au lieu de /pour le rendre plus facile à taper afins;<pattern>;<replace>;p
• rappelez-vous la correspondance entre parenthèses \(... \), accessible plus tard avec \1, \2...
• rencontre http://
• suivi de quoi que ce soit entre parenthèses [], [ab/]signifierait soit aou bou/
• d' abord ^au []moyen not, donc suivi de quoi que ce soit , mais la chose dans la[]
• [^/]signifie donc tout sauf le /caractère
• *est à répéter groupe précédent si des [^/]*moyens , à l' exception des caractères /.
• jusqu'à présent sed -n 's;\(http://[^/]*\)signifie rechercher et mémoriser http://suivi de tous les caractères sauf /et rappelez-vous ce que vous avez trouvé
• nous voulons rechercher jusqu'à la fin du domaine, alors arrêtez-vous sur le suivant /, ajoutez-en un autre /à la fin: sed -n 's;\(http://[^/]*\)/'mais nous voulons faire correspondre le reste de la ligne après le domaine, alors ajoutez.*
• Maintenant, la correspondance mémorisée dans le groupe 1 ( \1) est le domaine, alors remplacez la ligne correspondante par des éléments enregistrés dans le groupe \1et imprimez:sed -n 's;\(http://[^/]*\)/.*;\1;p'

Si vous souhaitez également inclure une barre oblique inverse après le domaine, ajoutez une barre oblique inverse supplémentaire dans le groupe à retenir:

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

production:

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

sed ne prend pas en charge l'opérateur "non gourmand".

Vous devez utiliser l'opérateur "[]" pour exclure "/" de la correspondance.

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

PS il n'y a pas besoin de barre oblique inverse "/".

Simuler un quantificateur paresseux (non gourmand) dans sed

Et toutes les autres saveurs regex!

1. Recherche de la première occurrence d'une expression:

   • POSIX ERE (en utilisant l' -roption)

     Regex:

     (EXPRESSION).*|.

     Sed:

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

     Exemple (recherche de la première séquence de chiffres) Démo en direct :

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

     12

     Comment ça marche ?

     Ce regex bénéficie d'une alternance |. À chaque position, le moteur essaie de choisir la correspondance la plus longue (il s'agit d'un standard POSIX qui est également suivi par quelques autres moteurs), ce qui signifie qu'il continue .jusqu'à ce qu'une correspondance soit trouvée ([0-9]+).*. Mais l'ordre est également important.

     

     Puisque l'indicateur global est défini, le moteur essaie de continuer à faire correspondre caractère par caractère jusqu'à la fin de la chaîne d'entrée ou de notre cible. Dès que le premier et le seul groupe de capture du côté gauche de l'alternance est apparié(EXPRESSION) reste de la ligne est immédiatement consommé .*. Nous détenons désormais notre valeur dans le premier groupe de capture.

   • POSIX BRE

     Regex:

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

     Sed:

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

     Exemple (recherche de la première séquence de chiffres):

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

     12

     Celui-ci est comme la version ERE mais sans alternance impliquée. C'est tout. À chaque position, le moteur essaie de faire correspondre un chiffre.

     

     Si on le trouve, d' autres chiffres suivants sont consommés et capturés et le reste de la ligne est immédiatement appariées autrement puisque des *moyens plus ou zéro , il saute sur le deuxième groupe de capture\(\([0-9]\{1,\}\).*\)* et arrive à un point .pour correspondre à un seul caractère et ce processus se poursuit.

2. Recherche de la première occurrence d'un expression délimitée :

   Cette approche correspondra à la toute première occurrence d'une chaîne qui est délimitée. Nous pouvons l'appeler un bloc de chaîne.

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

   Chaîne d'entrée:

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

   -EDE: end

   -SDE: start

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

   Production:

   start block #1 end

   Le premier regex \(end\).*correspond et capture le premier délimiteur d'extrémité endet les substituants correspondent tous aux caractères capturés récents qui est le délimiteur d'extrémité. A ce stade , notre production est: foobar start block #1 end.

   

   Ensuite, le résultat est transmis à la deuxième expression régulière \(\(start.*\)*.\)*qui est identique à la version POSIX BRE ci-dessus. Il correspond à un seul caractère si le délimiteur de début startne correspond pas sinon il correspond et capture le délimiteur de début et correspond au reste des caractères.

   

Répondre directement à votre question

En utilisant l'approche # 2 (expression délimitée), vous devez sélectionner deux expressions appropriées:

• EDE: [^:/]\/

• SDE: http:

Usage:

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

Production:

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

Remarque: cela ne fonctionnera pas avec des délimiteurs identiques.

Solution non gourmande pour plus d'un seul personnage

Ce fil est vraiment ancien mais je suppose que les gens en ont encore besoin. Disons que vous voulez tout tuer jusqu'à la toute première occurrence de HELLO. Tu ne peux pas dire[^HELLO] ...

Donc, une bonne solution implique deux étapes, en supposant que vous pouvez épargner un mot unique que vous n'attendez pas dans l'entrée, par exemple top_sekrit .

Dans ce cas, nous pouvons:

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

Bien sûr, avec une entrée plus simple, vous pouvez utiliser un mot plus petit, ou peut-être même un seul caractère.

HTH!

sed - correspondance non gourmande par Christoph Sieghart

L'astuce pour obtenir une correspondance non gourmande dans sed est de faire correspondre tous les caractères à l'exception de celui qui met fin à la correspondance. Je sais, une évidence, mais j'ai perdu de précieuses minutes dessus et les scripts shell devraient être, après tout, rapides et faciles. Donc, au cas où quelqu'un d'autre en aurait besoin:

Correspondance gourmande

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

Correspondance non gourmande

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

Cela peut être fait en utilisant cut:

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

une autre façon, sans utiliser l'expression régulière, est d'utiliser la méthode des champs / délimiteurs, par exemple

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

sed a certainement sa place mais ce n'est pas l'un d'eux!

Comme l'a souligné Dee: utilisez simplement cut. C'est beaucoup plus simple et beaucoup plus sûr dans ce cas. Voici un exemple où nous extrayons divers composants de l'URL à l'aide de la syntaxe 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-)

vous donne:

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

Comme vous pouvez le voir, cette approche est beaucoup plus flexible.

(tout crédit à Dee)

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

sed -E interprète les expressions régulières comme des expressions régulières étendues (modernes)

Mise à jour: -E sur MacOS X, -r dans GNU sed.

Il y a encore de l'espoir de résoudre ce problème en utilisant pure (GNU) sed. Malgré cela, ce n'est pas une solution générique dans certains cas, vous pouvez utiliser des "boucles" pour éliminer toutes les parties inutiles de la chaîne comme ceci:

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

• -r: utilise l'expression régulière étendue (pour les parenthèses + et sans échappement)
• ": loop": Définissez une nouvelle étiquette nommée "loop"
• -e: ajouter des commandes à sed
• "t loop": Revenez à l'étiquette "loop" en cas de substitution réussie

Le seul problème ici est qu'il coupera également le dernier caractère séparateur ('/'), mais si vous en avez vraiment besoin, vous pouvez toujours le remettre une fois la "boucle" terminée, ajoutez simplement cette commande supplémentaire à la fin de la précédente ligne de commande:

-e "s,$,/,"

Parce que vous avez spécifiquement déclaré que vous essayez d'utiliser sed (au lieu de perl, cut, etc.), essayez de regrouper. Cela contourne l'identifiant non gourmand potentiellement non reconnu. Le premier groupe est le protocole (c'est-à-dire 'http: //', 'https: //', 'tcp: //', etc.). Le deuxième groupe est le domaine:

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

Si vous n'êtes pas familier avec le regroupement, commencez ici .

Je me rends compte que c'est une ancienne entrée, mais quelqu'un peut la trouver utile. Comme le nom de domaine complet ne peut pas dépasser une longueur totale de 253 caractères, remplacez. * Par. \ {1, 255 \}

Voici comment effectuer de manière robuste une correspondance non gourmande de chaînes multi-caractères à l'aide de sed. Supposons que vous souhaitiez tout changer foo...barpour <foo...bar>, par exemple, cette entrée:

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

devrait devenir cette sortie:

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

Pour ce faire, vous convertissez foo et bar en caractères individuels, puis utilisez la négation de ces caractères entre eux:

$ 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

Au dessus:

1. s/@/@A/g; s/{/@B/g; s/}/@C/gest en train de convertir {et }en chaînes d'espace réservé qui ne peuvent pas exister dans l'entrée, donc ces caractères sont alors disponibles pour convertir fooetbar vers.
2. s/foo/{/g; s/bar/}/gconvertit fooet barvers {et }respectivement
3. s/{[^{}]*}/<&>/geffectue l'opération que nous voulons - la conversion foo...baren<foo...bar>
4. s/}/bar/g; s/{/foo/gconvertit {et }revient à fooet bar.
5. s/@C/}/g; s/@B/{/g; s/@A/@/g convertit les chaînes d'espace réservé à leurs caractères d'origine.

Notez que ce qui précède ne repose sur aucune chaîne particulière qui n'est pas présente dans l'entrée car il fabrique de telles chaînes à la première étape, et il ne se soucie pas de l'occurrence de toute expression rationnelle particulière que vous souhaitez faire correspondre car vous pouvez utiliser {[^{}]*}autant de fois que nécessaire dans l'expression pour isoler la correspondance réelle que vous souhaitez et / ou avec l'opérateur de correspondance numérique seds, par exemple pour remplacer uniquement la 2e occurrence:

$ 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

Vous n'avez pas encore vu cette réponse, voici comment procéder avec viou vim:

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

Cela exécute la vi :%ssubstitution globalement (la fin g), s'abstient de générer une erreur si le modèle n'est pas trouvé ( e), puis enregistre les modifications résultantes sur le disque et se ferme. Les &>/dev/nullempêche l'interface graphique de brièvement clignoter sur l' écran, qui peut être gênant.

Je aime utiliser viparfois pour regexes super compliqué, parce que (1) perl est mort mort, (2) vim a un très avancé moteur de regex, et (3) Je suis déjà très familier avec les viexpressions rationnelles dans mon édition d'utilisation au jour le jour documents.

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

ne vous embêtez pas, je l'ai eu sur un autre forum :)

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

Voici quelque chose que vous pouvez faire avec une approche en deux étapes et un awk:

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

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

J'espère que cela pourra aider!

Une autre version sed:

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

Il correspond /suivi d'un caractère alphanumérique (donc pas d'une autre barre oblique) ainsi que du reste des caractères jusqu'à la fin de la ligne. Ensuite, il le remplace par rien (c'est-à-dire le supprime.)