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

407

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.

Joel
la source
54
Une remarque: si vous délimitez vos expressions régulières avec "|", vous n'avez pas besoin d'échapper aux "/". En fait, la plupart des gens délimitent avec "|" au lieu de "/" pour éviter les "palissades".
AttishOculus
12
@AttishOculus Le premier caractère après le «s» dans une expression de remplacement dans sed est le délimiteur. D'où ^ foo ^ bar ^ 'ou' s! Foo! Bar! ' fonctionnent également
Squidly
1
Pour l'expression régulière étendue, utilisez sed -E 's.... Pourtant, aucun opérateur réticent.
Ondra Žižka
Pas de réponse au titre de la question mais dans ce cas précis des cut -d'/' -f1-3œuvres simples .
Petr Javorik

Réponses:

422

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|'
le chaos
la source
13
Pour le faire sur place, utilisez des options -pi -e.
reallynice
12
Holy smokes Je ne peux pas croire que ça a fonctionné :-) La seule chose qui craint, c'est que mon script a une dépendance Perl :-( Du côté positif, pratiquement chaque distribution Linux a déjà Perl, donc ce n'est probablement pas un problème :-)
Freedom_Ben
7
@Freedom_Ben: IIRC perlest requis par POSIX
MestreLion
4
@ dolphus333: "Ni regex Posix / GNU de base ni étendu ne reconnaît le quantificateur non gourmand" signifie "vous ne pouvez pas utiliser le quantificateur non gourmand dans sed".
chaos
3
@ Sérgio, c'est la façon dont vous faites la chose demandée, ce qui est impossible en sedutilisant une syntaxe fondamentalement identique à celle dused
chaos
251

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'
Gombo
la source
3
Comment faire correspondre sed à une phrase non gourmande en utilisant cette technique?
user3694243
6
Malheureusement, vous ne pouvez pas; voir la réponse du chaos .
Daniel H
Merci beaucoup ... car perl n'est plus dans la base d'installation par défaut dans de nombreuses distributions Linux!
st0ne
@DanielH En fait, il est possible de faire correspondre des phrases sans avidité en utilisant cette technique comme demandé. L'écriture de l'un ou l'autre motif avec une précision suffisante peut prendre un peu de temps. Par exemple, lors de l'analyse d'une affectation de valeur-clé dans la requête d'une URL, il peut être nécessaire de rechercher l'affectation à l'aide de ([^&=#]+)=([^&#]*). Il y a des cas qui ne fonctionnent pas de cette façon, par exemple lors de l'analyse de l'URL de sa partie hôte et du chemin avec la barre oblique finale supposée facultative pour être exclue de la capture:^(http:\/\/.+?)/?$
Thomas Urban
121

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/
stefanB
la source
8
Concernant les modifications récentes: Les parenthèses sont une sorte de caractère entre crochets, il n'est donc pas incorrect de les appeler crochets, surtout si vous suivez le mot avec les caractères réels, comme l'a fait l'auteur. De plus, c'est l'utilisation préférée dans certaines cultures, donc le remplacer par l'utilisation préférée dans votre propre culture semble un peu grossier, bien que je suis sûr que ce n'est pas ce que l'éditeur voulait. Personnellement, je pense qu'il est préférable d'utiliser des noms purement descriptifs comme des crochets , des crochets et des crochets .
Alan Moore
2
Est-il possible de remplacer le séparateur par une chaîne?
Calculemus
37

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 "/".

andcoz
la source
pas vraiment. si le délimiteur peut être l'un des nombreux caractères possibles (disons une chaîne de chiffres uniquement), votre correspondance de négation peut devenir de plus en plus complexe. c'est bien mais ce serait certainement bien d'avoir une option à faire. * non gourmand
gesell
1
La question était plus générale. Ces solutions fonctionnent pour les URL mais pas (par exemple) pour mon cas d'utilisation de suppression des zéros de fin. s/([[:digit:]]\.[[1-9]]*)0*/\1/ne fonctionnerait évidemment pas bien pour 1.20300. Étant donné que la question d'origine concernait les URL, elles doivent cependant être mentionnées dans la réponse acceptée.
Daniel H
33

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.

      entrez la description de l'image ici

      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.

      entrez la description de l'image ici

      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.

    entrez la description de l'image ici

    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.

    entrez la description de l'image ici


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.

revo
la source
3) tout en suggérant des sites comme regex101 pour la démo, veuillez ajouter qu'il n'est pas toujours adapté aux outils cli en raison de différences de syntaxe et de fonctionnalités
Sundeep
1
@Sundeep Merci. J'ai transformé toutes ces citations en guillemets simples. J'ai également considéré la règle de correspondance la plus longue à gauche à mentionner. Cependant, dans sedet tous les autres moteurs suivant le même ordre standard , c'est important en matière d'égalité. N'a echo 'foo 1' | sed -r 's/.|([0-9]+).*/\1/g'donc pas de match mais le echo 'foo 1' | sed -r 's/([0-9]+).*|./\1/g'fait.
revo
@Sundeep également la solution de contournement pour les expressions délimitées ne fonctionnait pas pour les délimiteurs de début et de fin identiques pour lesquels j'ai ajouté une note.
revo
bon point sur ce qui se passe lorsque différentes alternances commencent au même endroit et ont la même longueur, devinez qui suivra l'ordre gauche-droite comme les autres moteurs .. besoin de rechercher si cela est décrit dans le manuel
Sundeep
il y a un cas étrange ici cependant: stackoverflow.com/questions/59683820/…
Sundeep
20

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!

ishahak
la source
4
Pour le rendre encore meilleur, utile dans une situation où vous ne pouvez pas vous attendre à un caractère non utilisé: 1. remplacez ce caractère spécial par un mot vraiment inutilisé, 2. remplacez la séquence de fin par le caractère spécial, 3. faites la recherche se terminant par un caractère spécial, 4 remplacer le caractère spécial en arrière, 5. remplacer le mot spécial en arrière. Par exemple, vous voulez un opérateur gourmand entre <hello> et </hello>:
Jakub
3
Voici un exemple: echo "Find: <hello> fir ~ st <br> yes </hello> <hello> sec ~ ond </hello>" | sed -e "s, ~, VERYSPECIAL, g" -e "s, </hello>, ~, g" -e "s,. * Find: <hello> ([^ ~] *). *, \ 1 , "-e" s, \ ~, </hello>, "-e" s, TRÈS SPÉCIAL, ~, "
Jakub
2
Je suis d'accord. belle solution. Je reformulerais le commentaire en disant: si vous ne pouvez pas compter sur ~ inutilisé, remplacez d'abord ses occurrences actuelles en utilisant s / ~ / VERYspeciaL / g, puis faites l'astuce ci-dessus, puis retournez l'original ~ en utilisant s / VERYspeciaL / ~ / g
ishahak
1
J'ai tendance à aimer utiliser des "variables" plus rares pour ce genre de chose, donc au lieu de `, j'utiliserais <$$>(puisque se $$développe dans votre ID de processus dans le shell, bien que vous deviez utiliser des guillemets doubles plutôt que des guillemets simples, et que pourrait casser d'autres parties de votre expression rationnelle) ou, si unicode est disponible, quelque chose comme <∈∋>.
Adam Katz
À un moment donné, vous devez vous demander pourquoi vous n'utilisez pas simplement perlou pythonou une autre langue à la place. perlle fait de manière moins fragile en une seule ligne ...
ArtOfWarfare
18

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
gresolio
la source
17

Cela peut être fait en utilisant cut:

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

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="/"
ghostdog74
la source
5

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)

peterh
la source
3
sed 's|(http:\/\/[^\/]+\/).*|\1|'
Lucero
la source
1
Si vous utilisez "|" comme séparateur, il n'est pas nécessaire d'échapper à "/".
Michael Back
3

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.

stepancheg
la source
4
Non, ce n'est pas le cas ... Du moins pas GNU sed.
Michel de Ruiter
7
Plus largement, -Eest propre à BSD sedet donc à OS X. Liens vers les pages de manuel. -rapporte des expressions régulières étendues à GNUsed comme indiqué dans la correction de @ stephancheg. Méfiez-vous lorsque vous utilisez une commande de variabilité connue entre les distributions de 'nix. J'ai appris ça à la dure.
fny
1
C'est la bonne réponse si vous souhaitez utiliser sed, et c'est la plus applicable à la question initiale.
Will Tice
8
L' -roption de GNU sed ne change que les règles d'échappement, en fonction Appendix A Extended regular expressionsdu fichier info et de quelques tests rapides; il n'ajoute en fait pas de qualificatif non gourmand ( GNU sed version 4.2.1au moins.)
eichin
1
GNU sed a été reconnu -Ecomme une option non documentée pendant un certain temps, mais dans la version 4.2.2.177 , la documentation a été mise à jour pour refléter cela, donc ça -Eva pour les deux maintenant.
Benjamin W.
3

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,$,/,"
mTUX
la source
2

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 .

BrianB
la source
1

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 \}

Iain Henderson
la source
1

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
Ed Morton
la source
1

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.

Luke Davis
la source
0
echo "/home/one/two/three/myfile.txt" | sed 's|\(.*\)/.*|\1|'

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

Dee
la source
4
de sorte que vous obtenez correspondance gourmand: /home/one/two/three/si vous ajoutez un autre /comme /home/one/two/three/four/myfile.txtvous correspondront avidement fourainsi: /home/one/two/three/four, la question est sur le non-gourmand
stefanB
0

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

GL2014
la source
0

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!

VINAY NAIR
la source
0

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.)

sycomorex
la source
1
Je suppose que ça devrait l'être "[[:alnum:]]", non "[:alphanum:]".
oli_arborum