Lua
Mönstermatchning

Syntax

• string.find (str, mönster [, init [, vanlig]]) - Returnerar start- och slutindex för matchning i str

• string.match (str, mönster [, index]) - Matchar ett mönster en gång (börjar vid index)

• string.gmatch (str, mönster) - Returnerar en funktion som iterates genom alla matchningar i str

• string.gsub (str, mönster, repl [, n]) - Ersätter underlag (upp till max n gånger)

• . representerar alla tecken

• %a representerar alla bokstäver

• %l representerar alla små bokstäver

• %u representerar alla stora bokstäver

• %d representerar alla siffror

• %x representerar alla hexadecimala siffror

• %s representerar alla blankstegstecken

• %p representerar alla skiljetecken

• %g representerar alla utskrivbara tecken utom utrymme

• %c representerar alla kontrolltecken

• [set] representerar klassen som är föreningen mellan alla tecken i uppsättningen.

• [^set] representerar komplementet till set

• * girig match 0 eller fler förekomster av tidigare karaktärsklass

• + girig match 1 eller flera förekomster av tidigare karaktärsklass

• - lat match 0 eller fler förekomster av tidigare karaktärsklass

• ? matcha exakt 0 eller 1 förekomst av föregående teckenklass

Anmärkningar

Lua mönster matchning

Istället för att använda regex har Lua-strängbiblioteket en speciell uppsättning tecken som används i syntaxmatchningar. Båda kan vara väldigt lika, men Lua-mönstermatchning är mer begränsad och har en annan syntax. Till exempel matchar teckensekvensen %a vilken bokstav som helst, medan dess versaler representerar alla tecken som inte är bokstäver, listas alla teckenklasser (en teckenföljd som som ett mönster kan matcha en uppsättning objekt) nedan.

Som nämnts ovan representerar alla versaler av dessa klasser komplementet till klassen. Exempelvis kommer %D att matcha alla icke-siffriga teckensekvenser:

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

Förutom teckenklasser har vissa tecken specialfunktioner som mönster:

( ) % . + - * [ ? ^ $

Tecknet % representerar en teckenflukt, vilket gör %? matcha en förhör och %% matcha procenttalssymbolen. Du kan använda % -tecknet med alla andra icke-alfanumeriska tecken, därför måste du använda \\ före det, om du behöver fly, till exempel ett offert, som slipper alla tecken från en lua-sträng.

En teckenuppsättning, representerad i fyrkantiga parenteser ( [] ), låter dig skapa en speciell teckenklass, som kombinerar olika klasser och enstaka tecken:

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

Du kan få komplementet till teckenuppsättningen genom att starta det med ^ :

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

I det här exemplet string.match den första händelsen som inte är b , a eller r .

Mönster kan vara mer användbara med hjälp av repetition / valfria modifierare, mönster i lua erbjuder dessa fyra tecken:

Tecknet + representerar ett eller flera matchade tecken i sekvensen och det kommer alltid att returnera den längsta matchade sekvensen:

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

Som du kan se, * liknar + , men det accepterar noll förekomster av tecken och används ofta för att matcha valfria mellanrum mellan olika mönster.

Karaktären - liknar också * , men istället för att returnera den längsta matchade sekvensen matchar den den kortaste.

Modifieraren ? matchar ett valfritt tecken, så att du till exempel kan matcha en negativ siffra:

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

Lua mönster matchande motor ger några ytterligare mönster matchande objekt:

string.find (Introduktion)

find

Låt oss först titta på funktionen string.find i allmänhet:

Funktionssträngen.find string.find (s, substr [, init [, plain]]) returnerar start- och slutindex för en substring om den hittas, och noll annars, börjar vid indexet init om det tillhandahålls (som standard till 1).

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

Introduktion av mönster

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

Alla utom följande tecken representerar sig själva ^$()%.[]*+-?) . Vilken som helst av dessa tecken kan representeras av en % följer själva tecknet.

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

Funktionen "gmatch"

Hur det fungerar

Funktionen string.gmatch tar en inmatningssträng och ett mönster. Detta mönster beskriver vad man faktiskt ska få tillbaka. Denna funktion returnerar en funktion som faktiskt är en iterator. Resultatet av denna iterator matchar mönstret.

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

Introduktion av fångar:

Detta är mycket likadant med den vanliga funktionen, men det kommer bara att returnera fångarna istället för hela matchen.

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

Gsub-funktionen

blanda inte med funktionen string.sub, som returnerar en substring!

Hur det fungerar

strängargument

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

funktionsargument

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

tabellargument

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