|
Documentation language LUA |
Modèles D'instruction |
Si vous êtes nouveau aux chaînes de caractères et aux modèles,
la lecture du StringsTutorial et du StringLibraryTutorial peut être
utile. Veuillez noter ce cours d'instruction est une
introduction aux concepts impliqués dans les modèles et quelques
exemples de la leur utilisation. Ce n'est pas un traitement
avançé de l'assortiment de modèle. Vous seriez très sage de
lire 5.3 du manuel de référence pour plus d'information. Pour
des exemples pratiques d'utilisation de corde et de modèle, allez
voir StringRecipes.
La bibliothèque de corde de Lua a une certaine
fonctionnalité très utile et flexible pour la modification de
chaîne de caractères. La flexibilité de ces fonctions se
situe en partie à l'utilisation des modèles, parfois (incorrectement) des expressions régulières appelées. C'est
une manière d'indiquer un modèle de caractère pour rechercher dans
une corde. Dans l'exemple suivant nous recherchons juste le
modèle de a (caractère) 'an' dans la corde 'banana'. string.find() La fonction renvoie la position de la première
occurrence 'an' de dedans 'banana'.
> = string.find('banana ', '') -- trouvez le 1er occurance
'des '2 3 > = string.find('banana ', 'lua ') -- un 'lua 'ne sera pas
zéro trouvé
C'est assez utile mais peu un rigide, par exemple ce qui si nous voulions rechercher environ mots de quatre lettres qui commencent par "W" :
> texte = 'un mot au sage '> = mot de string.sub(text, de string.find(text, 'de W...')) > = string.sub(text, string.find(text, 'W... ', 5)) -- mordu plus loin sur... sage
string.sub() pour montrer la sous-chaîne qui string.find() nous a
trouvés. Le modèle de recherche que nous avons employé les
deux fois était 'w...'. '.'représente un
caractère de wildcard, qui peut représenter n'importe quel
caractère. Les modèles contiennent des ordres des caractères
et des formateurs normaux de modèle qui ont des significations
spéciales.
Nous définirons une fonction utile pour ce cours d'instruction. Cette fonction juste prend une corde et un modèle et renvoie la sous-chaîne qui assortit le modèle dans cette corde :
> findpattern(text de fonction, modèle, début) > >
string.sub(text de retour, string.find(text, modèle, début)) > >
extrémité > > = mot de findpattern('a mot sage au ', 'de W... ') > =
mot de findpattern('a au sage ', 'W... ', 5) sage
Une classe de caractère représente un ensemble de caractères. Le wildcard
'.'caractère peut représenter n'importe quel caractère.
Il y a plusieurs autres classes représentant des sous-ensembles
de caractères, par exemple nombres, lettres, caractères majuscules,
minuscules etc... Ces ensembles ont le format %X où X est une lettre représentant la classe. Toutes les
classes de caractère disponibles sont entièrement documentées du
manuel de référence. Voyons quelques exemples :
> = le renard brun rapide de findpattern('The ', '%a ') --
%a est toutes les lettres T > = findpattern('it est 2003 ', '%d ') --
%d trouve des chiffres 2 > = findpattern('UPPER inférieur ', '%l ')
-- %l trouve les minuscules que l > = le findpattern('UPPER inférieur
', '%u ') -- %u trouve les caractères majuscules U
Juste comme nous pouvons rechercher des chaînes de caractères dans les chaînes de caractères , nous pouvons rechercher des ordres des caractères des classes de caractère, et nous pouvons mélanger ces derniers à des chaînes de caractères régulières, par exemple,
> = findpattern('UPPERlower ', 'chiffre 234 du
chiffre 3 de %u%l ') -- le haut a suivi de Rl inférieur > =
findpattern('123 234 345 ', '%d3%d ') --
Aussi bien que les classes prédéfinies de caractère, de la forme %X, nous pouvons également explicitement définir nos propres ensembles. Ceux-ci sont représentés comme [ placez ] où "placez" est une liste de caractères à rechercher.
> = findpattern('banana ', '[ xyjkn ] ') -- recherchez un
de "xyjkn" n
Employez le trait d'union '-'pour
dénoter une gamme des caractères.
> = findpattern('banana ', '[ j-q ] ') -- équivalent au
"jklmnopq" n
Nous pouvons employer des classes de caractère dans les ensembles :
> = le findpattern('it est 2003 ', '[ %dabc ] ') 2
Des ensembles peuvent également être employés sous la forme [ ^set ] qui signifie la trouvaille des caractères pas dans l'ensemble énuméré, par exemple,
> = findpattern('banana ', '[ ^ba ] ') -- nous ne
voulons pas a ou b n > = les findpattern('bananas, '[ ^a-n ] ') --
oubliez qu'a à n s > = findpattern('it est 2003 ', '[ ^%l%s ] ') --
pas une lettre minuscule ou espace 2
Parfois nous voulons rechercher des modèles et
nous ne savons pas le nombre de caractères dans eux. Le soutien
de rechercher des modèles de longueur variable est assuré en
utilisant les caractères : * +, - et ?. Ceux-ci sont décrits bien dans le
manuel de référence ainsi nous donnerons un récapitulatif rapide et
quelques exemples ici :
* recherche 0 répétitions ou plus de l'élément
précédent de modèle, par exemple,
> = findpattern('bananas, 'az * ') a > =
findpattern('bananas, '* ') > = findpattern('bannnnnanas, '* ') un
annnnn
+ recherche 1 répétitions ou plus de l'élément
précédent de modèle, par exemple,
> = string.find('banana ', 'az+ ') -- ne seront
pas zéro trouvé > = les findpattern('bananas, 'an+ ') > = l'annnnn
des findpattern('bannnnnanas, 'de l'an+ ')
- recherche 0 répétitions ou plus de l'élément
précédent de modèle. Mais, d'où ceci diffère * est qu'il recherche l'ordre le plus court des éléments, tandis que * recherche le plus long ordre, par exemple,
> = findpattern('bananas, 'az - ') a > =
findpattern('bananas, '- ') a > = findpattern('bannnnanas, '- ') un a
? recherche les occurrences 0 ou 1 de l'élément
précédent de modèle.
> = findpattern('bananas, 'az?') a > =
findpattern('bananas, '?') > = findpattern('bannnnanas, '?')
Des captures peuvent être
marquées dans un modèle à l'aide des parenthèses, par exemple, "w(...)" capturerait les trois dernières lettres du mot de quatre
lettres que nous avons employé dans un exemple précédent :
> = mot de string.find('a au sage ', 'w(...)') -- trois
dernier ord des lettres 3 6 > = mot de string.find('a au sage ',
'(w.)(..) ') -- deux ! OE 3 6 rd > = mot de string.find('a
au sage ', '(w(..).) ') -- mot 3 6 niché ou
string.find() renvoie les
index de début et de finition du modèle entier et des captures que nous avons faits à
l'aide des parenthèses dans le modèle.
Ceci peut être très utile en même temps que string.gsub() la fonction, parce qu'aussi bien que faire la recherche
simple et remplace, nous peut traiter la capture que nous trouvons
avant d'exécuter le remplacement, par exemple,
> = mot de string.gsub('a au sage ', '(t%a+) ',
'banane ') -- simple remplacez une banane 2 sages de banane de mot > >
= mot de string.gsub('a au sage ', '(t%a+) ', > > print(x) de
function(x) ; renvoyez string.upper(x) l'extrémité) à un mot
aux 2 sages > > = mot de string.gsub('a au sage ', '(w%l+) ', > > le
retour '_ '..x..'_ 'extrémité de function(x)) _ un mot _ _ _ aux 2
sages
 www.loriotpro.com |
|