Функции работы со строками на Lua

Lua

Давайте перейдем к строковым операциям в Lua. Lua предлагает широкий спектр функций для работы с текстом. Как мы уже упоминали ранее, Lua является агностиком Unicode. Unicode agnostic достаточно хорош для большинства вещей, но есть ситуации, когда это просто не работает, поэтому мы также представим библиотеку для работы с utf8 в Lua. Давайте сначала рассмотрим основные строковые операции.

Основные строковые функции

Как и все остальное в Lua, все наши индексы начинаются с 1, а не с 0! Помните это для всего, что связано с индексом. Давайте начнем с таблицы и представим каждую функцию по ходу.

Функция Описание
string.len( s ) Получает длину s в байтах
string.upper( s ) Возвращает преобразование “s” в
string.lower( s ) Возвращает преобразование “s” в нижний регистр
string.reverse( s ) Возвращает обратный “с”
string.sub( s [, i [, j ] ] ) Возвращает подстроку от “S”, начиная с “i” и заканчивается на “j”
string.rep( s, n ) Возвращает “s” , повторённое n раз
string.match( s, pattern [, i] ) Возвращает подстроку из “s”, которая соответствует “pattern” (см. ниже для паттернов), начинается с индекса optioni
string.gmatch( s, pattern ) Возвращает подстроки в виде итератора из “s”, которые соответствуют “шаблону” (см.)
string.gsub( s, pattern, replacement [, n] ) Возвращает строку “s”, которая каждый экземпляр “pattern” заменяется на “replacement”, принимает необязательный n, который ограничивает количество раз, чтобы сделать замену
string.find( s, pattern [, index [, boolplain ] ] ) Возвращает начальный и конечный индекс (или ноль) для поиска “паттерна” в “s”, начинается с необязательного “индекса” и может принимать необязательный bool“boolplain”, чтобы игнорировать поиск паттерна и поиск буквально
string.format( s, o1, …, on ) Возвращает форматирование “s” с помощью опций в o1 и за ее пределами, аналогично опциям printf в C

Мы рассмотрим каждый из них и то, как их использовать. Такие вещи, как match и gmatch, будут подробно описаны, поскольку каждый из них имеет разные варианты использования. Давайте также рассмотрим некоторые из менее часто используемых строковых функций, на которые мы не будем тратить много времени.

Давайте сначала погрузимся в самые простые для изучения строковые функции.

  • string.len( s ),
  • string.upper( s ),
  • string.lower( s ),
  • string.reverse( s )

Каждый из них прост, так как они просто принимают один параметр. Вот пример их действия:

#!/usr/bin/lua5.1

test= «123456789»
test2 = «aBcDeFgHiJkLmNoPqRsTuVwXyZ»

print( «Длина теста:» .. string.len( test ) )
print( «Длина теста 2:» .. test2:len() )
print( «тест записанный в верхнем регистре:» .. test:upper() )
print( «тест 2 записанный в верхнем регистре:» .. string.upper( test2 ) )
print( «тест записанный в нижнем регистре:» .. test2:lower() )
print( «обратный тест:» .. test:reverse() )
print( «обратный тест 2 в нижнем регистре:» .. string.reverse( test2:lower() ) )

На выходе мы получаем:

./luastring.lua
длина теста: 9
длина теста 2: 26
тест записанный в верхнем регистре: 123456789
тест 2 записанный в верхнем регистре: ABCDEFGHIJKLMNOPQRSTUVWXYZ
тест 2 записанный в нижнем регистре: abcdefghijklmnopqrstuvwxyz
: 987654321
обратный тест 2 в нижнем регистре: zyxwvutsrqponmlkjihgfedcba

string.sub( s [, i [, j ] ] )

string.sub(…) чрезвычайно полезен для извлечения известных частей строки. Как Perl и некоторые другие языки, вы также можете использовать отрицательные индексы. Отрицательный индекс означает начало с обратной стороны, поэтому -1 будет последним символом. Давайте посмотрим все это на практике:

#!/usr/bin/lua5.1

test= «123456789»

print( «тестовая подстрока, начинающаяся с 5:» .. test:sub( 5 ) )
print( «тестовая подстрока от 5 до 8:» .. string.sub( test, 5, 8 ) )
print( «тестовая подстрока от -3 до -1:» .. string.sub( test, -3, -1 ) )

На выходе мы получаем:

./luastring2.lua
тестовая подстрока, начинающаяся в 5: 56789
тестовая подстрока от 5 до 8: 5678
тестовая подстрока от -3 до -1: 789

Если вы хотите получить один символ в определенной позиции, установите “i” и“j” на одно и то же число.

string.rep( s, n )

Это еще одна тривиальная строковая функция. Повторите “s” n раз. Давайте рассмотрим краткий пример:

#!/usr/bin/lua5.1

print( «повторите ‘abcdefg’ 3 раза: «.. string.rep( «abcdefg», 3 ) )

На выходе мы получаем:

./luastring3.lua
повторите «abcdefg» 3 раза: abcdefgabcdefgabcdefg

Узоры и специальные символы

Для начала нам нужно понять основы шаблонов и то, как обрабатывать специальные символы в Lua. Специальные символы — это такие вещи, как новые строки и вкладки. Давайте сначала рассмотрим специальные символы, поскольку они самые простые.

Экранизированный символ Описание
\n Новая строка
\r Возврат
\t Tab
\\ \
\”
\’
\[ [
\] ]

Все они чрезвычайно распространены и работают практически во всех строковых операциях, и их следует запомнить. “Новая строка” распространена во всех операционных системах, но “Возврат каретки” используется в Windows в сочетании с “Новыми строками”. Я склонен просто выполнять регулярное выражение (подробнее см. шаблоны ниже). Вам также нужно будет принять во внимание магические символы (см. Ниже).

Необычные специальные символы

Они редко используются, но вот вам для общего развития.

Символ Описание
\a Bell
\b Backspace
\f Подача формы
\v Вертикальная вкладка

Жадное совпадение

Жадное сопоставление означает, что мы сопоставляем все, что соответствует шаблону, в то время как не-жадное соответствие означает, что мы сопоставляем до тех пор, пока условие не будет впервые сопоставлено. В нашей предыдущей строке у нас есть “123”, затем куча дополнительных вещей и заканчивается “123” для тестовой строки. У нас есть еще один “123” в середине строки.

Мы сопоставляем цифру или больше, затем что угодно, затем цифру или больше. Из-за этого жадное сопоставление будет соответствовать всему этому последнему “123”, поскольку наши цифры технически являются “любым символом”, но не жадное сопоставление закончится, как только он увидит следующую партию цифр.

Жадное сопоставление полезно, когда вы хотите, чтобы все было между чем-то, даже если оно будет совпадать и конечным случаем. Не-жадное сопоставление полезно, когда вы хотите что-то между известным набором вещей и никогда не хотите, чтобы это выплеснулось. Это полезно, когда у вас есть последовательности аналогичного форматирования (например, теги в строке или аналогичные). Жадное и не жадное сопоставление становится более важным с некоторыми другими строковыми форматами.

string.gmatch( s, pattern )

string.gmatch( s, pattern ) аналогичен string.match, за исключением того, что он предоставляет все совпадения. Вы можете перебирать их с помощью цикла for или аналогичного. Давайте рассмотрим пример:

#!/usr/bin/lua5.1

test= «abc 123 ABC 456 !!! catd0g -+[] 789»

for s in ( string.gmatch( test, «%d+» ) ) do
print( «найдено:» .. s )
end

На выходе мы получаем:

./luamatch.lua
найдено: 123
найдено: 456
найдено: 0
найдено: 789

string.gsub( s, pattern, replacement [, n] )

string.gsub( s, pattern, replacement [, n]) — одна из самых полезных функций во всем Lua для работы со строками. Это позволяет вам взять строку и заменить в ней что-то из шаблона. Вы получаете обратно строку и количество сделанных замен. Вот простой пример:

#!/usr/bin/lua5.1

test= «abc 123 ABC 456 !!! catd0g -+[] 789»

localnewstring, replacements = string.gsub( test, «%d+», «[Numbers]» )
print( «Заменено:» .. replacements )
print( «Новая строка:» .. newstring )

На выходе мы получаем:

./luamatch.lua
Заменено: 4
Новая строка: abc [Numbers] ABC [Numbers] !!!cat d[Numbers]g -+[] [Numbers]

Вы можете ограничить количество замен, добавив целое число n, чтобы ограничить количество вхождений, на которые вы влияете. Это полезно для некоторых сценариев, когда вы примерно знаете, где должны произойти замены. Вы будете использовать такие вещи в обработке данных.

Оцените статью
Образовательный портал WELCOME4U.RU
Добавить комментарий

Adblock
detector