Поиск…


Синтаксис

  • 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 представляет все шестнадцатеричные цифры

  • %s представляет все пробельные символы

  • %p обозначает все знаки пунктуации

  • %g представляет все печатные символы, кроме пробела

  • %c все управляющие символы

  • [set] представляет класс, который является объединением всех символов в наборе.

  • [^set] представляет собой дополнение к множеству

  • * жадный матч 0 или более вхождений предыдущего класса символов

  • + жадный матч 1 или более вхождений предыдущего класса символов

  • - ленивое совпадение 0 или более случаев предыдущего символьного класса

  • ? соответствие точно 0 или 1 вхождения предыдущего символьного класса

замечания

В некоторых примерах используется нотация (<string literal>):function <string literal> , которая эквивалентна string.function(<string literal>, <string literal>) потому что все строки имеют метатебель с __index полем __index к таблице string .

Соответствие Lua

Вместо использования регулярного выражения в строковой библиотеке Lua имеется специальный набор символов, используемых в синтаксических совпадениях. Оба варианта могут быть очень похожими, но соответствие шаблону Lua более ограничено и имеет другой синтаксис. Например, последовательность символов %a соответствует любой букве, в то время как ее версия в верхнем регистре представляет все символы без букв , все классы символов (последовательность символов, которая, как шаблон, может соответствовать набору элементов), перечислены ниже.

Класс символов Раздел соответствия
% в буквы (AZ, az)
% с управляющие символы (\ n, \ t, \ r, ...)
% d цифры (0-9)
% л строчная буква (az)
%п знаки пунктуации (!,?, &, ...)
% s символы пробела
% U заглавные буквы
% мас буквенно-цифровые символы (AZ, az, 0-9)
%Икс шестнадцатеричные цифры (\ 3, \ 4, ...)
% г символ с представлением 0
, Соответствует любому персонажу

Как упоминалось выше, любая версия этого класса в верхнем регистре представляет дополнение к классу. Например, %D будет соответствовать любой несимметричной символьной последовательности:

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

В дополнение к классам символов некоторые символы имеют специальные функции как шаблоны:

( ) % . + - * [ ? ^ $

Символ % представляет escape-символ, делая %? соответствие опросу и %% соответствуют символу процента. Вы можете использовать символ % с любым другим алфавитно-цифровым символом, поэтому, если вам нужно убежать, например, цитату, вы должны использовать \\ перед ней, которая избегает любого символа из строки lua.

Набор символов, представленный внутри квадратных скобок ( [] ), позволяет создать специальный класс символов, сочетающий разные классы и отдельные символы:

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+")

Механизм соответствия шаблону Lua предоставляет несколько дополнительных элементов, соответствующих шаблону:

Персонаж Описание
%n для n от 1 до 9 соответствует подстроке, равной n-ой захваченной строке
%bxy соответствует подстроке между двумя разными символами (сбалансированная пара x и y )
%f[set] frontier pattern: соответствует пустой строке в любой позиции, так что следующий символ
принадлежит множеству, а предыдущий символ не принадлежит множеству

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

не путайте с функцией 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


Modified text is an extract of the original Stack Overflow Documentation
Лицензировано согласно CC BY-SA 3.0
Не связан с Stack Overflow