Конкатенация (по-кухонному — склейка) строк нужна для присоединения к тексту скриптового значения. Делается с помощью оператора «..» (две точки). Склейка всегда выносится за кавычки.
Пример:
Код
a = 9; print("Самое большое однозначное число — "..a);
Напечатается: «Самое большое однозначное число — 9».
Склеек может быть сколько угодно много:
Код
a = 1; b = 9; c = 0;
print("Самое маленькое однозначное число — "..a..", а самое большое — "..b..". А ещё есть "..c.." — это вообще ничего.")
Напечатается: «Самое маленькое однозначное число — 1, а самое большое — 9. А ещё есть 0 — это вообще ничего».
Не стоит также забывать про постановку пробелов при склейке.
Если склеивать два числа, необходимо разделить их пробелами, иначе Lua воспримет первую точку как десятичную дробь.
Правильно:
Код
print(10 .. 10);
Не правильно:
Код
print(10..10);
Ах да, склеивание двух чисел даст в результате число:
Код
print(10 .. 10);
Или:
Код
print("10".."10");
Напечатается: «1010» (тысяча десять).
--------------------------------
§12.2. Функции для работы со строками.
Все они начинаются со «string.» (от англ. «string» — ‘строка’), далее следует название вызываемой функции.
string.len():
Возвращает длину строки.
string.rep():
Возвращает строку, содержащую указанное число копий исходной строки.
string.lower():
Заменяет все прописные буквы в строке на строчные.
string.upper():
Заменяет в строке все строчные буквы на прописные.
string.reverse():
Возвращает строку, в которой символы исходной строки расположены в обратном порядке.
string.format():
Генерирует строку по форматной строке и аргументам по правилам, принятым в языке C.
string.byte():
Возвращает числовые коды символов строки.
string.char():
Преобразует набор числовых кодов символов в строку.
string.find():
Выполняет поиск в строке первого вхождения подстроки, соответствующей заданному шаблону. Возвращает индексы начального и конечного символов найденной подстроки.
string.match():
Выполняет поиск в строке первого вхождения подстроки, соответствующей заданному шаблону. Возвращает найденную подстроку.
string.gmatch():
Возвращает итератор, который на каждой итерации возвращает подстроку, соответствующую заданному шаблону.
string.sub():
Возвращает подстроку исходной строки.
string.gsub():
Возвращает копию исходной строки, в которой все вхождения шаблона заменены на строку, заданную третьим аргументом. Этот аргумент может быть строкой, таблицей или функцией.
string.dump():
Возвращает строку, содержащую двоичное представление функции Lua с заданным именем.
Также к функциями можно обращаться немного иначе: сначала идёт название строки, затем двоеточие, затем название функции (без «string.») и скобки.
Пример:
Код
s = "Hello!";
print(string.len(s)); -- то же, что и print(s:len()); -- это
Тут уже кому как удобнее.
--------------------------------
§12.3. Подробный разбор некоторых функций.
string.len():
Функция возвращает количество символов, которая содержит строка (самые крайние кавычки не считаются, пробелы и прочие знаки — считаются).
Пример:
Код
s = "The String";
print(string.len(s)); -- 10. Если посчитать символы самостоятельно, будет тот же результат.
string.rep():
Код
s = "String";
print(string.rep(s,2)); -- StringString
То же, что и:
Код
print(s..s);
string.lower():
Функция возвращает копию строки, в которой все большие буквы заменены на маленькие.
Пример:
Код
s = "STRING";
print(string.lower(s)); -- string
string.upper():
Функция противоположна предыдущей:
Код
s = "string";
print(string.upper(s)); -- STRING
string.reverse():
Код
s = "String";
print(string.reverse(s)); -- gnirtS
string.byte():
Функция возвращает числовой код буквы указанного индекса.
Пример:
Код
s = "String";
print(string.byte(s,3)); -- 114, то есть буква r
При вызове без второго параметра по умолчанию ему присвоится 1:
Код
print(string.byte(s)); -- 83, то есть буква S
Не стоит забывать, что каждая буква каждого регистра имеет свой определённый код.
string.char():
Функция возвращает числовые коды символов, преобразованные в строку. Параметров может быть сколько угодно много.
Функция ищет вхождение подстроки в строку и возвращает индекс начала вхождения, или nil, если совпадение не найдено.
Пример:
Код
s = "String"; string.find(s,"tri"); -- вернёт 2
Я думаю, достаточно будет проверять функцию на неравенство nil, ведь если совпадения не будет найдено, функция вернёт nil, в остальных случаях — считай true.
Код
if string.find(s,"tri") then print("Was found! :)"); else print("Wasn't found :("); end
--------------------------------
§12.4. Управляющие последовательности.
Все они служат для форматирования строк. Вот они все:
Присоединяются к строке напрямую, без склеек и пробелов — Lua сам опознает их.
Пример:
Код
s = "String";
print(s.." with\ttabulation and\nnew line");
Напечатается: «String with tabulation and new line».
Также эти последовательности служат для форматирования строки через функцию string.format().
--------------------------------
§12.5. Функция tostring.
Данная функция принимает казанную переменную в строку. Если конвертируемая переменная уже является строкой, возвращается та же самая строка. Если не функция не может конвертировать перемнную в строку, она возвращает nil.
Пример:
Код
a = 12; a = tostring(a) -- теперь этой переменной можно распоряжаться как строкой, используя всё пройденное выше по строкам
--========================= §13. Функции.
Функции — один из типов данных. В неё можно записать любое количество необходимых операций, а затем вызвать по желанию. В неё вообще можно всё что угодно записывать.
--------------------------------
§13.1. Простые функции.
Выглядят так:
Синтаксис:
Код
function ...:...() ... end
function — зарезервированный оператор, с которого начинается каждая функция. То, что перед двоеточием, — это имя файла, в котором эта функция создаётся. Между двоеточием и скобками пишется имя функции. Оно может быть любым (только главное, чтобы в одном файле не было двух или более функций с одним и тем же именем файла и названием функции). В скобках записываются её аргументы.
Пример функции:
script.lua:
Код
function script:newfunc() print("First function was created!"); end
Данная функция не заработает, пока её не вызвать. Сделать это можно так:
Код
script:newfunc(); -- First function was created!
Если вызов функции происходит из того же файла, в котором она было создана, можно воспользоваться оператором self:
Код
self:newfunc(); -- First function was created!
При вызове из другого файла применяется способ выше. Но и для этого вызова никто не запрещает использование способа выше.
Вообще, название файла можно в принципе отсечь:
Код
function func() print("Second function"); end
Тогда вызов всегда будет выглядеть так:
Код
func();
Но всё же для того, чтобы облегчить другим поиск той или иной функции, лучше писать название файла.
Также к функциям других файлов можно обращаться из иных файлов, чтобы внести в неё свои изменения, не трогая при этом оригинальные файлы:
anotherscript.lua:
Код
function script:newfunc() print("Function was edited first time!"); end
Теперь при последующих вызовах функции она будет выдавать другое содержимое, — то, которое написано чуть выше.
--------------------------------
§13.2. Аргументы.
Аргументы являются локальными переменными функции. Записываются в скобки. Их может быть несколько или всего один.
Пример:
script.lua
Код
function script:stick(a,b,c); a = 1; b = 2; c = 3; print(a + b + c); end
self:stick(a,b,c); -- 5
Аргументы можно заменять на другие значения:
script.lua
Код
function script:stick2(a,b,c); print(a + b + c); end
self:stick2(2,2,2); -- 6
Это может повлиять на содержимое функции.
Если не вызывать какие-либо аргументы, то им присвоится значение nil. А если вызвать больше аргументов, чем есть, тогда все лишние аргументы удалятся:
Код
self:stick2(); -- все аргументы равны nil — вылезет ошибка self:stick2(1); -- аргументы b и c равны nil — вылезет ошибка self:stick2(1,2); -- аргумент c равен nil — вылезет ошибка self:stick2(1,2,3,4); -- 4 — лишнее — он просто удалится, и всё будет нормально
--------------------------------
§13.2.1. Переменное число аргументов.
Примечание автора: для того чтобы лучше понимать этот параграф, необходимо знать таблицы — §14. Лучше всего будет пропустить сейчас этот параграф и вернуться к нему после изучения таблиц. Но выбор, конечно, остаётся за читающим.
Это значит, что функция может иметь сколько угодно много аргументов, и при вызовах их количество можно будет изменять. Для определения переменного числа аргументов в скобках надо записать оператор «...» (многоточие):
Код
function func(...) ... end
Все аргументы, скрытые за многоточием, собираются в локальную таблицу arg. У этой таблицы есть явное поле n, которое возвращает количество аргументов, скрытых за многоточием:
Код
funcion func(...) print(arg.n); end
func(1,2,3); -- 3 func(1,4,562,6,26,); -- 5
Например, нужно написать в консоль все аргументы скрытые за многоточием. Сделать это можно так:
Код
function func(...) for i=1,arg.n do print(arg[i]); end end
func(1,2,3,4,5); --[[ 1 2 3 4 5 ]]
Или так:
Код
function func(...) print(...); end
func(1,2,3,4,5); -- 1 2 3 4 5
Но лучше всё же первый вариант.
Также возможно совмещать явные аргументы со скрытыми за многоточием:
Код
function func(a,b,...) print(a+b);
for i=1,arg.n do print(arg[i]); end end
func(2,2,87,0,9); --[[4 87 0 9 ]]
Напоследок скажу о том, что таблицу arg всё же лучше предопределить самостоятельно (так как в некоторых версиях Lua это приходится делать принудительно, иначе будет ошибка) таким образом:
Код
local arg = {...};
--------------------------------
§13.3. Оператор return в функциях.
Этот оператор уже не раз встречался ранее. Настало время рассказать о его применении в функциях.
Во-первых, его можно применять как блокиратор выполнения функции. То есть, предположим, что функция не должна выполнится при том условии, если переменная не будет существовать. Можно, конечно, это сделать через условия:
Код
a = nil;
function func() if a then print(a); end end
Но гораздо удобнее и быстрее воспользоваться оператором return:
Код
a = nil;
function func() if not a then return end
print(a); end
func(); -- не тут-то было. Функция не выполнилась, потому что a — nil
a = "Hello!";
func(); -- другое дело. Напечатается: «Hello!»
return можно использовать в любом месте функции. Главное, чтобы он был внутри условия или блока do ... end:
Код
function func(param) local state = nil;
if param then state = true; else state = false; end
Также если вы считаете, что данный материал мог быть интересен и полезен кому-то из ваших друзей, то вы бы могли посоветовать его, отправив сообщение на e-mail друга:
Игровые объявления и предложения:
Если вас заинтересовал материал «Lua. Туториал для начинающих. Часть 3», и вы бы хотели прочесть что-то на эту же тему, то вы можете воспользоваться списком схожих материалов ниже. Данный список сформирован автоматически по тематическим меткам раздела.
Предлагаются такие схожие материалы:
Если вы ведёте свой блог, микроблог, либо участвуете в какой-то популярной социальной сети, то вы можете быстро поделиться данной заметкой со своими друзьями и посетителями.
1. их можно проигнорировать оператором «_» -- _ это не оператор не хрена, это обычная переменная и она не фига не игнорирует значения.
2. local state = nil --так никто не объявляет переменные. local state этого достаточно. a = nil -- вообще можно не объявлять.
3. return можно использовать в любом месте функции. Главное, чтобы он был внутри условия или блока do ... end: --Не правда. Его можно использовать только в конце блока do end.
4.
После чего эту функцию можно использовать как обычную переменную: local sum = func(2,2); print(sum); -- 4
--?!?!?!?!?! Ты получаешь только значение которое вернула функция, а не саму функцию
local sum = func print(sum(2,2)) --4
Вот это уже ссылка на функцию.
5.
Синтаксис:
function ...:...() ... end --Ложь и провокация. a ={function() return 1 end} --Чо, синтаксис не правильный? print(a[1]()) --Почему тогда синтаксической ошибки не выбивает?
6. Почему в "простой функции" мы уже смотрим в модули?
7. funcion func(...) print(arg.n); end --WTF?! арг не работает, уже лет как 10. Что такое n и зачем он нужен? Понимаю что это ключ, но а если в ... выпадет число/строка?
«_ это не оператор не хрена, это обычная переменная и она не фига не игнорирует значения».
Да, абсолютно согласен. Просто для меня эта переменная стала способом проигнорировать ненужные значения, а после забыть о них.
«local state = nil --так никто не объявляет переменные. local state этого достаточно. a = nil -- вообще можно не объявлять».
Ну, коли это не ошибка, и мало что это меняет, есть ли смысл бранить за это того, кому такой способ лучше? Если предоставляется выбор, человек в полном праве выбрать то, что он хочет.
«return можно использовать в любом месте функции. Главное, чтобы он был внутри условия или блока do ... end: --Не правда. Его можно использовать только в конце блока do end».
function somefunc() ... return -- на версии Lua 5.0.2 такая запись провоцировала ошибку ... end
function somefunc() ... do return end -- всё хорошо ... a = 2; if a = 2 then return end -- тоже ... end
Если же имелось в виду, что return для корректной работы — если он в условии — должен располагаться либо в его конце, либо в do ... end, то да, здесь признаю свою недосказанность.
«?!?!?!?!?! Ты получаешь только значение которое вернула функция, а не саму функцию».
Разве не это ли подразумевалось а написанном тексте?
5. Данный синтаксис:
function ...:...() ... end
Это синтаксис для простейших функций, создаваемым в Lua-файле с упоминанием его названия. То, что показано чуть ниже, — это пример функции непосредственно внутри таблицы. Так как эти две записи связаны между собой?
«Почему в "простой функции" мы уже смотрим в модули?»
Я не специалист по Lua, а лишь любитель, потому не знаю всего в этом языке. Я изучил только то, что мне нужно, — самое основное. Модули я не изучал по простой причине: не нашёл им применения. Я даже и не знал, что там откуда-то взялись эти модули. Можно указать, где они там расположены?
«WTF?! арг не работает, уже лет как 10».
Локальная таблица arg замечательно работает на версиях 5.0.2 и 5.1.4. На более новых версиях не работаю, потому не знаю, что там с этой таблицей. Что же с ней произошло? что теперь используется вместо неё?
«Что такое n и зачем он нужен? Понимаю что это ключ, но а если в ... выпадет число/строка?»
О поле n написано в самом туториале:
«У этой таблицы есть явное поле n, которое возвращает количество аргументов, скрытых за многоточием».
Да, этот момент я упустил. Прежде чем выводить каждый аргумент, скрытый за многоточием, для начала следовало бы запустить конвертирование получаемого значения в строку, то бишь так:
function func(...) for i=1,arg.n do print(tostring(arg[i])); end end
Локальная таблица arg замечательно работает на версиях 5.0.2 и 5.1.4. На более новых версиях не работаю, потому не знаю, что там с этой таблицей. Что же с ней произошло? что теперь используется вместо неё?
Все просто, она не существует и вместо нее ничего не существует. сам вбивай эти ... в таблицу и перебирай. тем самым .n не работает
Цитата
«?!?!?!?!?! Ты получаешь только значение которое вернула функция, а не саму функцию».
Разве не это ли подразумевалось а написанном тексте?
нет, написано что вы можете использовать функцию как обычную переменную. Мне вообще непонятна часть та.
Цитата
function ...:...() ... end Это синтаксис для простейших функций, создаваемым в Lua-файле с упоминанием его названия. Я даже и не знал, что там откуда-то взялись эти модули.
Ну твой твой подключаемый файл и есть модуль.
function f() end
вот эта простая функция, согласен
a = {} function a.f() end
Эта функция уже хранится внутри хеша, можно считать как простая функция, так как объявляется так же как и обычная функция
a = {} function a:f() print(a == self) end
Это уже не простая функция. Так как у нее появляется аргумент self который равен родительскому объекту, то есть a == self --true.
Добавлять комментарии могут только зарегистрированные пользователи. [ Регистрация | Вход ]
1
2173718 ошибок. 
