Lua
패턴 매칭

통사론

• string.find (str, pattern [, init [, plain]]) - str에서 일치하는 시작과 끝 인덱스를 반환합니다.

• string.match (str, pattern [, index]) - 패턴을 한 번 일치시킵니다 (인덱스에서 시작).

• string.gmatch (str, pattern) - str의 모든 일치를 반복하는 함수를 반환합니다.

• string.gsub (str, pattern, repl [, n]) - 부분 문자열을 대체합니다 (최대 n 번까지).

• . 모든 문자를 나타냅니다.

• %a 는 모든 문자를 나타냅니다.

• %l 은 모두 소문자를 나타냅니다.

• %u 는 모두 대문자를 나타냅니다.

• %d 은 모든 숫자를 나타냅니다.

• %x 는 모든 16 진수를 나타냅니다.

• %s 는 모든 공백 문자를 나타냅니다.

• %p 는 모든 구두점 문자를 나타냅니다.

• %g 은 공백을 제외한 모든 인쇄 가능한 문자를 나타냅니다.

• %c 는 모든 제어 문자를 나타냅니다.

• [set] 은 [set] 에있는 모든 문자의 합집합 인 클래스를 나타냅니다.

• [^set] 은 [^set] 의 보수를 나타냅니다.

• * 욕심 많은 일치 이전 문자 클래스의 0 번 이상 발생

• + 욕심 많은 일치 이전 문자 클래스의 1 회 이상 발생

• - 게으른 일치 이전 문자 클래스가 0 회 이상 발생합니다.

• ? 이전의 문자 클래스가 정확히 0 번 또는 1 번 일치한다.

비고

루아 패턴 매칭

regex를 사용하는 대신, Lua 문자열 라이브러리에는 구문 일치에 사용되는 특수 문자 집합이 있습니다. 둘 다 매우 유사 할 수 있지만 루아 패턴 일치는 더 제한적이며 다른 구문을 사용합니다. 예를 들어, %a 문자 시퀀스는 모든 문자와 일치하지만 대문자 버전은 모든 비 문자 문자를 나타내며 모든 문자 클래스 (패턴으로 항목 세트와 일치 할 수있는 문자 시퀀스)는 아래에 나열됩니다.

위에서 언급했듯이, 이러한 클래스의 대문자 버전은 클래스의 보수를 나타냅니다. 예를 들어 %D 는 임의의 비 숫자 문자 시퀀스와 일치합니다.

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

문자 클래스 외에도 일부 문자는 패턴과 같은 특수한 기능을 가지고 있습니다.

( ) % . + - * [ ? ^ $

문자 % 는 문자 이스케이프를 나타내며 %? 심문과 일치하고 %% 는 백분율 기호와 일치합니다. % 문자를 다른 영숫자가 아닌 문자와 함께 사용할 수 있으므로 따옴표와 같이 이스케이프해야하는 경우 앞에 \\ 를 사용해야합니다. 그러면 루아 문자열의 문자를 이스케이프 처리합니다.

대괄호 ( [] ) 안에 표시된 문자 세트를 사용하면 여러 클래스와 단일 문자를 결합하여 특수 문자 클래스를 만들 수 있습니다.

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

^ :로 시작하여 캐릭터 세트의 보완을 얻을 수 있습니다.

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

이 예에서 string.match 는 b , a 또는 r 이 아닌 첫 번째 항목을 찾습니다.

패턴은 반복 / 선택적 수식어의 도움으로 더욱 유용 할 수 있습니다. lua의 패턴은 다음 네 가지 문자를 제공합니다.

문자 + 는 시퀀스에서 하나 이상의 일치하는 문자를 나타내며 항상 가장 긴 일치 시퀀스를 반환합니다.

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

보시다시피 * 는 + 와 유사하지만 문자가 전혀 나타나지 않으며 여러 패턴 사이의 선택적 공백을 비교하는 데 주로 사용됩니다.

캐릭터는 - 또한 유사하다 * , 대신 가장 긴 일치 시퀀스를 반환하는, 그것은 짧은 하나와 일치합니다.

수식어 ? 선택 문자와 일치하여 음수와 같이 일치시킬 수 있습니다.

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

루아 패턴 매칭 엔진은 몇 가지 추가적인 패턴 일치 아이템을 제공합니다 :

string.find (소개)

find 기능

먼저 일반적인 string.find 함수를 살펴 보겠습니다.

함수 string.find (s, substr [, init [, plain]]) 을 찾을 경우 문자열의 시작 및 종료 인덱스를 리턴하고, 그렇지 않으면 전무 인덱스에서 시작 init 가 (1 디폴트)를 제공하는 경우.

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

패턴 소개

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

다음 문자를 제외한 모든 문자는 ^$()%.[]*+-?) 냅니다. 이 문자들 중 어떤 것도 문자 자체 뒤에 % 로 표시 될 수 있습니다.

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

`gmatch` 함수

작동 원리

string.gmatch 함수는 입력 문자열과 패턴을 취합니다. 이 패턴은 실제로 되돌아 가야 할 것에 대해 설명합니다. 이 함수는 실제로 반복자 인 함수를 반환합니다. 이 반복자의 결과는 패턴과 일치합니다.

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

캡처 소개 :

이것은 일반 함수와 매우 유사하지만 전체 일치 대신 캡처 만 반환합니다.

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 함수

substring을 반환하는 string.sub 함수와 혼동하지 마십시오!

작동 원리

문자열 인수

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

함수 인수

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

테이블 인수

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