tcl
Expressions régulières

Syntaxe

• regexp? commutateurs? Chaîne d'exp? matchVar? ? subMatchVar subMatchVar ...?
• Regsub? commutateurs? chaîne exp sous subSpec? varName?

Remarques

Correspondant à

La commande regexp est utilisée pour faire correspondre une expression régulière à une chaîne.

# This is a very simplistic e-mail matcher.
# e-mail addresses are extremely complicated to match properly.
# there is no guarantee that this regex will properly match e-mail addresses.
set mydata "send mail to [email protected] please"
regexp -expanded {
    \y           # word boundary
    [^@\s]+      # characters that are not an @ or a space character
    @            # a single @ sign
    [\w.-]+      # normal characters and dots and dash
    \.           # a dot character
    \w+          # normal characters.
    \y           # word boundary
    } $mydata emailaddr
puts $emailaddr
[email protected]

La commande regexp renvoie une valeur 1 (true) si une correspondance a été faite ou 0 (false) si ce n'est pas le cas.

set mydata "hello wrld, this is Tcl"
# faster would be to use: [string match *world* $mydata] 
if { [regexp {world} $mydata] } {
   puts "spelling correct"
} else {
   puts "typographical error"
}

Pour faire correspondre toutes les expressions de certaines données, utilisez le commutateur -all et le commutateur -inline pour renvoyer les données. Notez que la valeur par défaut consiste à traiter les nouvelles lignes comme toutes les autres données.

# simplistic english ordinal word matcher.
set mydata {
    This is the first line.
    This is the second line.
    This is the third line.
    This is the fourth line.
    }
set mymatches [regexp -all -inline -expanded {
    \y                  # word boundary
    \w+                 # standard characters
    (?:st|nd|rd|th)     # ending in st, nd, rd or th
                        # The ?: operator is used here as we don't
                        # want to return the match specified inside
                        # the grouping () operator.
    \y                  # word boundary
    } $mydata]
puts $mymatches
first second third fourth
# if the ?: operator was not used, the data returned would be:
first st second nd third rd fourth th

Manipulation Newline

# find real numbers at the end of a line (fake data).
set mydata {
    White 0.87 percent saturation.
    Specular reflection: 0.995
    Blue 0.56 percent saturation.
    Specular reflection: 0.421
    }
# the -line switch will enable newline matching.
# without -line, the $ would match the end of the data.
set mymatches [regexp -line -all -inline -expanded {
    \y                  # word boundary
    \d\.\d+             # a real number
    $                   # at the end of a line.
    } $mydata]
puts $mymatches
0.995 0.421

Unicode ne nécessite aucune manipulation particulière.

% set mydata {123ÂÃÄÈ456}
123ÂÃÄÈ456
% regexp {[[:alpha:]]+} $mydata match
1
% puts $match
ÂÃÄÈ
% regexp {\w+} $mydata match
1
% puts $match
123ÂÃÄÈ456

Documentation: regexp re_syntax

Mélange de quantificateurs avides et non gourmands

Si vous avez une correspondance gourmande en tant que premier quantificateur, le RE entier sera gourmand,

Si vous avez une correspondance non gourmande en tant que premier quantificateur, la totalité du RE sera non gourmande.

set mydata {
    Device widget1: port: 156 alias: input2
    Device widget2: alias: input1 
    Device widget3: port: 238 alias: processor2
    Device widget4: alias: output2
    }
regexp {Device\s(\w+):\s(.*?)alias} $mydata alldata devname devdata
puts "$devname $devdata"
widget1 port: 156 alias: input2
regexp {Device\s(.*?):\s(.*?)alias} $mydata alldata devname devdata
puts "$devname $devdata" 
widget1 port: 156 

Dans le premier cas, le premier \ w + est gourmand, donc tous les quantificateurs sont marqués comme gourmands et les. *? correspond plus que prévu.

Dans le second cas, le premier. *? est non gourmand et tous les quantificateurs sont marqués comme non gourmands.

D'autres moteurs d'expression régulière peuvent ne pas avoir de problème avec les quantificateurs gourmands / non gourmands, mais ils sont beaucoup plus lents.

Henry Spencer a écrit : ... Le problème est qu’il est très, très difficile d’écrire une généralisation de ces déclarations qui recouvre des expressions régulières de cupidité mixte - une définition correcte, indépendante de la mise en œuvre, de ce que les expressions régulières de cupidité mixte doivent correspondre - - et leur fait faire "ce que les gens attendent". J'ai essayé. J'essaie toujours Pas de chance jusqu'à présent. ...

Substitution

La commande regsub est utilisée pour la correspondance et la substitution d'expressions régulières.

set mydata {The yellow dog has the blues.}
# create a new string; only the first match is replaced.
set newdata [regsub {(yellow|blue)} $mydata green]
puts $newdata
The green dog has the blues.
# replace the data in the same string; all matches are replaced
regsub -all {(yellow|blue)} $mydata red mydata
puts $mydata
The red dog has the reds.
# another way to create a new string
regsub {(yellow|blue)} $mydata red mynewdata
puts $mynewdata
The red dog has the blues.

Utiliser des références arrière pour référencer les données appariées.

set mydata {The yellow dog has the blues.}
regsub {(yellow)} $mydata {"\1"} mydata
puts $mydata
The "yellow" dog has the blues.

Documentation: regsub re_syntax

Différences entre le moteur RE de Tcl et les autres moteurs RE.

• \ m: début d'un mot.
• \ M: Fin d'un mot.
• \ y: limite de mot.
• \ Y: un point qui n'est pas une limite de mot.
• \ Z: correspond à la fin des données.

Documentation: re_syntax

Faire correspondre une chaîne littérale à une expression régulière

Parfois, vous devez faire correspondre une chaîne (sous-) littérale avec une expression régulière malgré cette sous-chaîne contenant des métacaractères RE. Alors que oui, il est possible d'écrire du code pour insérer des barres obliques inverses appropriées (en utilisant string map ), il est plus simple de préfixer le motif avec ***= , , désactivant tous les autres métacaractères.

set sampleText "This is some text with \[brackets\] in it."
set searchFor {[brackets]}

if {[ regexp ***=$searchFor $sampleText ]} {
    # This message will be printed
    puts "Found it!"
}

Notez que cela signifie également que vous ne pouvez utiliser aucune des ancres.