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


Modified text is an extract of the original Stack Overflow Documentation
Licencjonowany na podstawie CC BY-SA 3.0
Nie związany z Stack Overflow