Lua
Dopasowywanie wzorów
Szukaj…
Składnia
string.find (str, pattern [, init [, zwykły]]) - Zwraca indeks początku i końca dopasowania w str
string.match (str, pattern [, index]) - Raz dopasowuje wzór (zaczynając od indeksu)
string.gmatch (str, pattern) - Zwraca funkcję, która iteruje przez wszystkie dopasowania w str
string.gsub (str, pattern, repl [, n]) - Zamienia podciągi (maksymalnie n razy)
.
reprezentuje wszystkie postacie%a
reprezentuje wszystkie litery%l
reprezentuje wszystkie małe litery%u
reprezentuje wszystkie wielkie litery%d
reprezentuje wszystkie cyfry%x
reprezentuje wszystkie cyfry szesnastkowe%s
reprezentuje wszystkie znaki białych znaków%p
reprezentuje wszystkie znaki interpunkcyjne%g
reprezentuje wszystkie znaki do wydruku oprócz spacji%c
reprezentuje wszystkie znaki kontrolne[set]
reprezentuje klasę, która jest unią wszystkich znaków w zestawie.[^set]
reprezentuje uzupełnienie zestawu*
chciwy mecz 0 lub więcej wystąpień poprzedniej klasy postaci+
chciwy mecz 1 lub więcej wystąpień poprzedniej klasy postaci-
leniwe dopasowanie 0 lub więcej wystąpień poprzedniej klasy postaci?
pasuje dokładnie 0 lub 1 wystąpieniu poprzedniej klasy znaków
Uwagi
W niektórych przykładach stosowany jest zapis (<string literal>):function <string literal>
, który jest równoważny string.function(<string literal>, <string literal>)
ponieważ wszystkie ciągi mają __index
ustawionym polem __index
do tabeli string
.
Dopasowywanie wzoru Lua
Zamiast używania wyrażenia regularnego biblioteka ciągów Lua ma specjalny zestaw znaków używanych w dopasowaniach składniowych. Oba mogą być bardzo podobne, ale dopasowanie wzorca Lua jest bardziej ograniczone i ma inną składnię. Na przykład sekwencja znaków %a
pasuje do dowolnej litery, podczas gdy jej wielka wersja reprezentuje wszystkie znaki niebędące literami , wszystkie klasy znaków (sekwencja znaków, która jako wzór może pasować do zestawu elementów) wymieniono poniżej.
Klasa postaci | Dopasowana sekcja |
---|---|
%za | litery (AZ, az) |
%do | znaki kontrolne (\ n, \ t, \ r, ...) |
%re | cyfry (0–9) |
% l | mała litera (az) |
% p | znaki interpunkcyjne (!,?, &, ...) |
% s | znaki spacji |
% u | wielkie litery |
% w | znaki alfanumeryczne (AZ, az, 0-9) |
% x | cyfry szesnastkowe (\ 3, \ 4, ...) |
% z | znak z reprezentacją 0 |
. | Pasuje do dowolnej postaci |
Jak wspomniano powyżej, każda wielka wersja tych klas stanowi uzupełnienie klasy. Na przykład %D
będzie pasował do dowolnej nie cyfrowej sekwencji znaków:
string.match("f123", "%D") --> f
Oprócz klas postaci niektóre znaki mają specjalne funkcje jako wzorce:
( ) % . + - * [ ? ^ $
Znak %
reprezentuje ucieczkę postaci, dzięki czemu %?
dopasuj zapytanie i %%
dopasuje symbol procentu. Możesz użyć znaku %
z dowolnym innym niealfanumerycznym znakiem, dlatego jeśli chcesz uciec, na przykład cytat, musisz użyć \\
przed nim, który unika dowolnego znaku z ciągu lua.
Zestaw znaków, reprezentowany w nawiasach kwadratowych ( []
), pozwala utworzyć specjalną klasę znaków, łącząc różne klasy i pojedyncze znaki:
local foo = "bar123bar2341"
print(foo:match "[arb]") --> b
Możesz uzyskać uzupełnienie zestawu znaków, zaczynając od ^
:
local foo = "bar123bar2341"
print(string.match(foo, "[^bar]")) --> 1
W tym przykładzie string.match
znajdzie pierwsze wystąpienie, które nie jest b , a lub r .
Wzory mogą być bardziej przydatne za pomocą powtórzeń / opcjonalnych modyfikatorów, wzory w lua oferują następujące cztery znaki:
Postać | Modyfikator |
---|---|
+ | Jedno lub więcej powtórzeń |
* | Zero lub więcej powtórzeń |
- | Również zero lub więcej powtórzeń |
? | Opcjonalne (zero lub jedno wystąpienie) |
Znak +
reprezentuje jeden lub więcej dopasowanych znaków w sekwencji i zawsze zwróci najdłuższą dopasowaną sekwencję:
local foo = "12345678bar123"
print(foo:match "%d+") --> 12345678
Jak widać, *
jest podobny do +
, ale akceptuje zerowe występowanie znaków i jest powszechnie używany do dopasowania opcjonalnych spacji między różnymi wzorami.
Znak -
jest również podobny do *
, ale zamiast zwracać najdłuższą dopasowaną sekwencję, pasuje do najkrótszej.
Modyfikator ?
dopasowuje znak opcjonalny, umożliwiając dopasowanie na przykład cyfry ujemnej:
local foo = "-20"
print(foo:match "[+-]?%d+")
Silnik dopasowania wzoru Lua zapewnia kilka dodatkowych elementów dopasowania wzoru:
Przedmiot postaci | Opis |
---|---|
%n | dla n od 1 do 9 dopasowuje podciąg równy n-temu przechwyconemu ciągowi |
%bxy | dopasowania SUBSTRING dwóch różnych znaków (symetryczne parę x i y ) |
%f[set] | wzór granicy: dopasowuje pusty ciąg w dowolnej pozycji, taki jak następny znak należy do zestawu, a poprzedni znak nie należy do zestawu |
string.find (Wprowadzenie)
Funkcja find
Najpierw spójrzmy string.find
funkcję string.find
:
Funkcja string.find (s, substr [, init [, plain]])
zwraca indeks początkowy i końcowy podłańcucha, jeśli zostanie znaleziony, lub zero, zaczynając od indeksu init
jeśli jest podany (domyślnie 1).
("Hello, I am a string"):find "am" --> returns 10 11
-- equivalent to string.find("Hello, I am a string", "am") -- see remarks
Przedstawiamy wzorce
("hello world"):find ".- " -- will match characters until it finds a space
--> so it will return 1, 6
Wszystkie oprócz następujących znaków przedstawiają się ^$()%.[]*+-?)
. Każdy z tych znaków może być reprezentowany przez %
następujący po samym znaku.
("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
Funkcja „gmatch”
Jak to działa
Funkcja string.gmatch
pobierze ciąg wejściowy i wzór. Ten wzór opisuje, co faktycznie odzyskać. Ta funkcja zwróci funkcję, która jest w rzeczywistości iteratorem. Wynik tego iteratora będzie pasował do wzorca.
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
Przedstawiamy przechwyty:
Jest to bardzo podobne do zwykłej funkcji, jednak zwróci tylko przechwyty zamiast pełnego dopasowania.
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
Funkcja gsub
nie mylić z funkcją string.sub, która zwraca podłańcuch!
Jak to działa
argument ciąg
("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 funkcji
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 tabeli
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