Lua
Musterabgleich

Syntax

• string.find (str, pattern [, init [, plain]]) - Gibt den Start- und Endindex der Übereinstimmung in str zurück

• string.match (str, pattern [, index]) - Gleicht ein Muster einmal ab (beginnend mit dem Index)

• string.gmatch (str, pattern) - Gibt eine Funktion zurück, die alle Übereinstimmungen in str durchläuft

• string.gsub (str, pattern, repl [, n]) - Ersetzt Teilzeichenfolgen (maximal n-mal)

• . steht für alle Zeichen

• %a für alle Buchstaben

• %l für alle Kleinbuchstaben

• %u für alle Großbuchstaben

• %d für alle Ziffern

• %x für alle Hexadezimalstellen

• %s für alle Leerzeichen

• %p für alle Satzzeichen

• %g für alle druckbaren Zeichen außer Leerzeichen

• %c für alle Steuerzeichen

• [set] für die Klasse, die die Vereinigung aller Zeichen in Set darstellt.

• [^set] repräsentiert das Komplement von set

• * gierige Übereinstimmung 0 oder mehr Vorkommen der vorherigen Zeichenklasse

• + greedy match 1 oder mehr Vorkommen der vorherigen Zeichenklasse

• - Lazy Match 0 oder mehr Vorkommen der vorherigen Zeichenklasse

• ? stimmt genau mit 0 oder 1 der vorherigen Zeichenklasse überein

Bemerkungen

Lua Musterabgleich

Anstatt Regex zu verwenden, enthält die Lua-String-Bibliothek einen speziellen Satz von Zeichen, der in Syntaxübereinstimmungen verwendet wird. Beide können sich sehr ähnlich sein, aber der Lua-Musterabgleich ist eingeschränkter und hat eine andere Syntax. Beispielsweise entspricht die Zeichenfolge %a beliebigen Buchstaben, während die Großbuchstabenversion alle Zeichen ohne Buchstaben darstellt . Alle Zeichenklassen (eine Zeichenfolge, die als Muster mit einer Gruppe von Elementen übereinstimmen kann) sind unten aufgeführt.

Wie oben erwähnt, stellt jede Version dieser Klassen in Großbuchstaben das Komplement der Klasse dar. Zum Beispiel stimmt %D mit einer beliebigen Nicht-Ziffernfolge überein:

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

Zusätzlich zu den Zeichenklassen haben einige Zeichen spezielle Funktionen als Muster:

( ) % . + - * [ ? ^ $

Das Zeichen % für eine Zeichenflucht und macht %? Übereinstimmung mit einer Abfrage und %% mit dem Prozentzeichen. Sie können das % -Zeichen auch für andere nicht-alphanumerische Zeichen verwenden. Wenn Sie beispielsweise ein Zitat mit einem Escape-Zeichen versehen müssen, müssen Sie \\ vor diesem Zeichen verwenden, wodurch jedes Zeichen aus einem Lua-String entzogen wird.

Mit einem in eckigen Klammern ( [] ) dargestellten Zeichensatz können Sie eine spezielle Zeichenklasse erstellen, die verschiedene Klassen und Einzelzeichen kombiniert:

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

Sie können das Komplement des Zeichensatzes erhalten, indem Sie es mit ^ :

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

In diesem Beispiel findet string.match das erste Vorkommen, das nicht b , a oder r ist .

Muster können mithilfe von Wiederholungs- / optionalen Modifizierern nützlicher sein. Muster in Lua bieten die folgenden vier Zeichen:

Das Zeichen + stellt ein oder mehrere übereinstimmende Zeichen in der Sequenz dar und gibt immer die längste übereinstimmende Sequenz zurück:

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

Wie Sie sehen, * ist ähnlich wie + , akzeptiert jedoch keine Vorkommen von Zeichen und wird normalerweise verwendet, um optionale Leerzeichen zwischen verschiedenen Mustern abzugleichen.

Das Zeichen - ist ebenfalls * ähnlich, aber anstatt die längste übereinstimmende Sequenz zurückzugeben, stimmt es mit der kürzesten überein.

Der Modifikator ? passt auf ein optionales Zeichen, sodass Sie beispielsweise eine negative Ziffer finden können:

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

Die Lua-Pattern-Matching-Engine bietet einige zusätzliche Pattern-Matching-Elemente:

string.find (Einleitung)

Die find

Zuerst werfen wir einen Blick auf die Funktion string.find :

Die Funktion string.find (s, substr [, init [, plain]]) gibt den Start- und string.find (s, substr [, init [, plain]]) eines gefundenen Teilstrings zurück, andernfalls null, beginnend mit dem Index init falls vorhanden (Standardeinstellung 1).

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

Muster einführen

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

Mit Ausnahme der folgenden Zeichen repräsentieren alle sich selbst ^$()%.[]*+-?) . Jedes dieser Zeichen kann durch ein % nach dem Zeichen selbst dargestellt werden.

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

Die "gmatch" -Funktion

Wie es funktioniert

Die Funktion string.gmatch nimmt eine Eingabezeichenfolge und ein Muster an. Dieses Muster beschreibt, worauf man eigentlich zurückkommt. Diese Funktion gibt eine Funktion zurück, die eigentlich ein Iterator ist. Das Ergebnis dieses Iterators wird mit dem Muster übereinstimmen.

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

Captures vorstellen:

Dies ist der regulären Funktion sehr ähnlich, es werden jedoch nur die Erfassungen statt der vollständigen Übereinstimmung zurückgegeben.

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

Die gsub Funktion

Verwechseln Sie nicht mit der Funktion string.sub, die einen Teilstring zurückgibt!

Wie es funktioniert

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

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

Tabellenargument

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