Lua
Correspondance de motif

Syntaxe

• string.find (str, pattern [, init [, plain]]) - Retourne l'index de début et de fin de la correspondance dans str

• string.match (str, pattern [, index]) - Correspond à un modèle une fois (à partir de l'index)

• string.gmatch (str, pattern) - Retourne une fonction qui parcourt toutes les correspondances dans str

• string.gsub (str, pattern, repl [, n]) - Remplace les sous-chaînes (jusqu'à un maximum de n fois)

• . représente tous les caractères

• %a représente toutes les lettres

• %l représente toutes les lettres minuscules

• %u représente toutes les lettres majuscules

• %d représente tous les chiffres

• %x représente tous les chiffres hexadécimaux

• %s représente tous les caractères d'espacement

• %p représente tous les caractères de ponctuation

• %g représente tous les caractères imprimables à l' exception de l'espace

• %c représente tous les caractères de contrôle

• [set] représente la classe qui est l'union de tous les caractères de l'ensemble.

• [^set] représente le complément de l'ensemble

• * greedy correspond à 0 ou plusieurs occurrences de la classe de caractères précédente

• + greedy match 1 ou plusieurs occurrences de la classe de caractères précédente

• - lazy match 0 ou plusieurs occurrences de la classe de caractères précédente

• ? correspond exactement à 0 ou 1 occurrence de la classe de caractères précédente

Remarques

Lua correspondance des modèles

Au lieu d'utiliser l'expression rationnelle, la bibliothèque de chaînes Lua possède un ensemble spécial de caractères utilisé dans les correspondances de syntaxe. Les deux peuvent être très similaires, mais la correspondance de modèle Lua est plus limitée et a une syntaxe différente. Par exemple, la séquence de caractères %a correspond à n'importe quelle lettre, tandis que sa version majuscule représente tous les caractères autres que des lettres , toutes les classes de caractères (une séquence de caractères pouvant correspondre à un ensemble d'éléments).

Comme mentionné ci-dessus, toute version majuscule de ces classes représente le complément de la classe. Par exemple, %D correspondra à toute séquence de caractères autre que des chiffres:

string.match("f123", "%D")          --> f

En plus des classes de caractères, certains caractères ont des fonctions spéciales comme motifs:

( ) % . + - * [ ? ^ $

Le caractère % représente un caractère échappé, faisant %? correspond à une interrogation et %% correspond au symbole de pourcentage. Vous pouvez utiliser le caractère % avec tout autre caractère non alphanumérique. Par conséquent, si vous devez échapper, par exemple, à une citation, vous devez utiliser \\ avant celle-ci, qui échappe à tout caractère d'une chaîne lua.

Un jeu de caractères, représenté entre crochets ( [] ), vous permet de créer une classe de caractères spéciaux, combinant différentes classes et caractères uniques:

local foo = "bar123bar2341"
print(foo:match "[arb]")            --> b

Vous pouvez obtenir le complément du jeu de caractères en le démarrant avec ^ :

local foo = "bar123bar2341"
print(string.match(foo, "[^bar]"))  --> 1

Dans cet exemple, string.match trouvera la première occurrence qui n'est pas b , a ou r .

Les patterns peuvent être plus utiles à l'aide de modificateurs de répétition / facultatifs, les patterns de lua offrent ces quatre caractères:

Le caractère + représente un ou plusieurs caractères correspondants dans la séquence et restituera toujours la séquence correspondante la plus longue:

local foo = "12345678bar123"
print(foo:match "%d+")  --> 12345678

Comme vous pouvez le voir, * est similaire à + , mais il accepte les occurrences de caractères et est généralement utilisé pour faire correspondre des espaces facultatifs entre différents modèles.

Le caractère - est également similaire à * , mais au lieu de renvoyer la plus longue séquence correspondante, elle correspond à la plus courte.

Le modificateur ? correspond à un caractère facultatif, ce qui vous permet de faire correspondre, par exemple, un chiffre négatif:

local foo = "-20"
print(foo:match "[+-]?%d+")

Le moteur d'appariement de motifs Lua fournit quelques éléments de correspondance de motifs supplémentaires:

string.find (Introduction)

La fonction de find

Tout d'abord, regardons la fonction string.find en général:

La fonction string.find (s, substr [, init [, plain]]) renvoie l'index de début et de fin d'une sous-chaîne si elle est trouvée et nulle sinon, à partir de l'index init si elle est fournie (la valeur par défaut est 1).

("Hello, I am a string"):find "am" --> returns 10 11
-- equivalent to string.find("Hello, I am a string", "am") -- see remarks

Introduire des Patterns

("hello world"):find ".- " -- will match characters until it finds a space
    --> so it will return 1, 6

Tous sauf les caractères suivants représentent eux-mêmes ^$()%.[]*+-?) . N'importe lequel de ces caractères peut être représenté par un % suivant le caractère lui-même.

("137'5 m47ch s0m3 d1g175"):find "m%d%d" -- will match an m followed by 2 digit
    --> this will match m47 and return 7, 9

("stack overflow"):find "[abc]" -- will match an 'a', a 'b' or a 'c'
    --> this will return 3 (the A in stAck)

("stack overflow"):find "[^stack ]"
    -- will match all EXCEPT the letters s, t, a, c and k and the space character
    --> this will match the o in overflow

("hello"):find "o%d?" --> matches o, returns 5, 5
("hello20"):find "o%d?" --> matches o2, returns 5, 6
    -- the ? means the character is optional

("helllllo"):find "el+" --> will match elllll
("heo"):find "el+" --> won't match anything

("helllllo"):find "el*" --> will match elllll
("heo"):find "el*" --> will match e

("helelo"):find "h.+l" -- + will match as much as it gets
    --> this matches "helel"
("helelo"):find "h.-l" -- - will match as few as it can
    --> this wil only match "hel"

("hello"):match "o%d*"
    --> like ?, this matches the "o", because %d is optional
("hello20"):match "o%d*"
    --> unlike ?, it maches as many %d as it gets, "o20"
("hello"):match "o%d"
    --> wouldn't find anything, because + looks for 1 or more characters

La fonction `gmatch`

Comment ça marche

La fonction string.gmatch prendra une chaîne d'entrée et un motif. Ce modèle décrit ce qu'il faut réellement récupérer. Cette fonction renverra une fonction qui est en réalité un itérateur. Le résultat de cet itérateur correspondra au motif.

type(("abc"):gmatch ".") --> returns "function"

for char in ("abc"):gmatch "." do
    print char -- this prints:
    --> a
    --> b
    --> c
end

for match in ("#afdde6"):gmatch "%x%x" do
    print("#" .. match) -- prints:
    --> #af
    --> #dd
    --> #e6
end

Présentation des captures:

Ceci est très similaire à la fonction normale, mais elle ne renverra que les captures au lieu de la correspondance complète.

for key, value in ("foo = bar, bar=foo"):gmatch "(%w+)%s*=%s*(%w+)" do
    print("key: " .. key .. ", value: " .. value)
    --> key: foo, value: bar
    --> key: bar, value: foo
end

La fonction gsub

ne confondez pas avec la fonction string.sub, qui retourne une sous-chaîne!

Comment ça marche

argument de chaîne

("hello world"):gsub("o", "0")
    --> returns "hell0 w0rld", 2
    -- the 2 means that 2 substrings have been replaced (the 2 Os)

("hello world, how are you?"):gsub("[^%s]+", "word")
    --> returns "word word, word word word?", 5

("hello world"):gsub("([^%s])([^%s]*)", "%2%1")
    --> returns "elloh orldw", 2

argument de fonction

local word = "[^%s]+"

function func(str)
    if str:sub(1,1):lower()=="h" then
        return str
    else
        return "no_h"
    end
end
("hello world"):gsub(word, func)
    --> returns "hello no_h", 2

argument de table

local word = "[^%s]+"

sub = {}
sub["hello"] = "g'day"
sub["world"] = "m8"

("hello world"):gsub(word, sub)
    --> returns "g'day m8"

("hello world, how are you?"):gsub(word, sub)
    --> returns "g'day m8, how are you?"
    -- words that are not in the table are simply ignored