Lua
Patroonaanpassing

Syntaxis

• string.find (str, pattern [, init [, plain]]) - Retourneert de begin- en eindindex van de overeenkomst in str

• string.match (str, patroon [, index]) - Komt één keer overeen met een patroon (beginnend bij index)

• string.gmatch (str, patroon) - Retourneert een functie die alle overeenkomsten in str doorloopt

• string.gsub (str, pattern, repl [, n]) - Vervangt substrings (maximaal n keer)

• . vertegenwoordigt alle karakters

• %a staat voor alle letters

• %l vertegenwoordigt alle kleine letters

• %u vertegenwoordigt alle hoofdletters

• %d staat voor alle cijfers

• %x staat voor alle hexadecimale cijfers

• %s vertegenwoordigt alle witruimtetekens

• %p staat voor alle leestekens

• %g staat voor alle afdrukbare tekens behalve de spatie

• %c vertegenwoordigt alle controletekens

• [set] vertegenwoordigt de klasse die de unie van alle tekens in set is.

• [^set] vertegenwoordigt het complement van set

• * hebzuchtige match 0 of meer voorkomen van vorige karakterklasse

• + hebzuchtige match 1 of meer voorvallen uit de vorige karakterklasse

• - luie match 0 of meer keren voorkomen uit vorige karakterklasse

• ? komen exact overeen met 0 of 1 exemplaar van vorige tekenklasse

Opmerkingen

Lua-patroonovereenkomst

In plaats van regex te gebruiken, heeft de Lua-tekenreeksbibliotheek een speciale set tekens die worden gebruikt in syntaxisovereenkomsten. Beide kunnen erg op elkaar lijken, maar Lua-patroonovereenkomst is beperkter en heeft een andere syntaxis. De tekenreeks %a komt bijvoorbeeld overeen met elke letter, terwijl de hoofdletterversie alle niet-letters bevat , alle tekenklassen (een tekenreeks die, als patroon, kan overeenkomen met een set items) hieronder worden weergegeven.

Zoals hierboven vermeld, vertegenwoordigt elke hoofdletterversie van die klassen het complement van de klasse. %D komt bijvoorbeeld overeen met elke niet-cijferige tekenreeks:

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

Naast tekenklassen hebben sommige tekens speciale functies als patronen:

( ) % . + - * [ ? ^ $

Het teken % vertegenwoordigt een tekenontsnapping, waardoor %? match een ondervraging en %% overeen met het percentagesymbool. U kunt het % -teken gebruiken met elk ander niet-alfanumeriek teken, dus als u bijvoorbeeld een aanhalingsteken wilt laten ontsnappen, moet u daarvoor \\ gebruiken, dat elk teken uit een lua-reeks ontsnapt.

Met een tekenset, weergegeven tussen vierkante haken ( [] ), kunt u een speciale tekenklasse maken, die verschillende klassen en afzonderlijke tekens combineert:

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

Je kunt het complement van de tekenset krijgen door het te beginnen met ^ :

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

In dit voorbeeld vindt string.match het eerste exemplaar dat geen b , a of r is .

Patronen kunnen nuttiger zijn met behulp van herhaling / optionele modificaties, patronen in lua bieden deze vier tekens:

Het teken + vertegenwoordigt een of meer overeenkomende tekens in de reeks en retourneert altijd de langste overeenkomende reeks:

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

Zoals u kunt zien, is * vergelijkbaar met + , maar het accepteert nul tekens en wordt vaak gebruikt om optionele spaties tussen verschillende patronen te matchen.

Het teken - lijkt ook op * , maar in plaats van de langste overeenkomende reeks terug te geven, komt deze overeen met de kortste.

De modifier ? komt overeen met een optioneel teken, zodat u bijvoorbeeld een negatief cijfer kunt vinden:

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

De Lua-engine voor het matchen van patronen biedt een paar extra items voor het matchen van patronen:

string.find (Introductie)

De find functie

Laten we eerst de functie string.find in het algemeen bekijken:

De functie string.find (s, substr [, init [, plain]]) retourneert de start- en string.find (s, substr [, init [, plain]]) van een substring indien gevonden, en nihil anders, beginnend bij de index init als deze is opgegeven (standaardwaarde 1).

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

Patronen introduceren

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

Alle behalve de volgende tekens vertegenwoordigen ^$()%.[]*+-?) . Elk van deze tekens kan worden weergegeven met een % na het teken zelf.

("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

De `gmatch` functie

Hoe het werkt

De string.gmatch functie neemt een invoertekenreeks en een patroon. Dit patroon beschrijft wat u daadwerkelijk terugkrijgt. Deze functie retourneert een functie die eigenlijk een iterator is. Het resultaat van deze iterator komt overeen met het patroon.

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

Introductie van vastleggingen:

Dit lijkt erg op de normale functie, maar in plaats daarvan worden alleen de vastleggingen geretourneerd.

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

De gsub-functie

verwar niet met de string.sub-functie, die een substring teruggeeft!

Hoe het werkt

string argument

("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

functie argument

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

tabel argument

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