lua перенос строки в коде
Свежие записи
Архивы
string.byte
string.char
string.dump
string.find
string.format
string.match
string.gmatch
string.gsub
string.len
string.upper
string.lower
string.rep
string.reverse
string.sub
Поддерживаемые опции регулярных выражений:
Добавить комментарий Отменить ответ
Для отправки комментария вам необходимо авторизоваться.
Функции работы со строками в QLua(Lua): 91 комментарий
Добрый день! Подскажите, как можно применить:
А то всё время «attempt to call field ‘unpack’ (a nil value)»
А вот для такой ситуации:
для вас это вредно, потому, что unpack не будет возвращать значения nil, и все ваши линии будут съезжать, а вы будете исправлять это поведение разными шаманскими методами.
еще раз. если у вас t[6] = nil, то СЕЙЧАС вы вернете квику 1, 2, 3, 4, 5, nil, 7, 8, 9, 10, 11, 12, 13, 14, 15 а с использованием unpack вы вернете квику 1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15 (, nil).
Огромное спасибо! А то я увидел новую функцию и хотел попробовать. Действительно, nil необходимы!
для начала неплохо бы вам освоить глобальные и локальные переменные.
Правильно. Метатаблицы это прям самое то, что сейчас нужно Роману. Все остальное же Роман уже изучил на отлично, теперь метатаблицами его нагрузить остается и будет отличный программист.
Кстати, Роман, используя метатаблицы, можно применять что то очень близкое к ООП, возьмитесь и за эту тему, тоже новое для Вас будет.
А если говорить серьезно, зачем Вам все это надо? Вы куда то поступаете, где нужно экзамены сдавать? Поэтому и изучаете все подряд.
Самые основы изучите на отлично и 99% алгоритмов сможете писать. Согласен, метатаблицы в некоторых моментах хороши, но сколько я не пробовал их применять, в итоге все равно отказывался в пользу обычных.
Хотя, изучайте.
Ну что же. Что есть в QUIK с тем и работаем.
Нету никакого противопоставления «метатаблиц» и «обычных». Все равно что сказать «сколько не пробовал, мне все равно больше нравится кушать, чем ложкой».
Вот у вас есть торговый алгоритм и некие данные, с которыми вам приходится работать. Вы можете реализовывать алгоритм непосредственно на родном квиковом api, но это усложняет и запутывает код самого алгоритма, делает его плохо читаемым и поддерживаемым. Если объекты квика завернуть в удобные абстракции, то тогда непосредственно код алгоритма будет становиться проще, он как бы очищается от всего этого шлака и проявляется. Это означает, что вы сможете его модифицировать и усложнять, не боясь запутаться. Конечно, полноценного ООП в lua нет, но мы можем делать инкапсуляцию и виртуализировать доступ, что довольно сильно упрощает жизнь.
В квике, например, совершенно уродское api для datasource. В нем плохо вообще ВСЁ. Совершенно уродские функции, колбэк не имеет в параметрах ds, колбэки вызываются вхолостую множество раз для одной и той же сделки и так далее, и тому подобное. Если ваш алгоритм использует пять разных datasource, то код становится просто не читаемым. А если это обернуть lua’шными псевдообъектами, то получается вполне прилично.
Всем Привет! Помогите разобраться!?
ваш индикатор возвращает что-то только для тех свечей, у которых H(indx) == O(indx), во всех остальных случаях он возвращает 10 nil’ов. в случае, когда это условие выполняется, ваш индикатор возвращает для этой свечи для первой линии значение H(indx), и 9 nil’ов.
так как событие H(indx) == O(indx) довольно редкое, то в результате вы видите «только разовые метки на свечах по условию».
Спасибо! Это просто пример. На самом деле там всё сложнее. Но я тоже уже понял. Таблица создаётся внутри OnCalculate каждый раз заново при появлении свечки или тика. Так новое значение перезаписывается на первую линию. Поэтому вынес создание таблицы значений в условие (indx == Size()). Теперь, вроде, всё заработало как надо.
Извиняюсь! Ошибся! indx == 1, а не Size(). Таблица создаётся только при загрузке. Или действительно можно вариант выноса
many_lines = <> на место перед function Init().
Добрый вечер, Господа!
Подскажите, как можно варианты меток?
У меня вот такая метка выводит прямую линию через
label.TEXT=» «..string.rep(«\151»,1000).
А где можно найти коды других возможных символов?
Привет, Дмитрий. Вот появилась такая задача. Есть строка
Lua перенос строки в коде
200?’200px’:»+(this.scrollHeight+5)+’px’);»>
— В одинарных кавычках
str = ‘Mickey Mouse’
— В двойных кавычках
str = «stack pile heap»
— Между так называемыми [i]длинными скобками[/i].
— Количество знаков равно ‘=’ между двумя открывающими ‘[‘
— и двумя закрывающими ‘]’ знаками, вообще говоря, произвольно.
str1 = [=[Stop spitting on the ground]=]
str2 = [[Prime number]]
str3 = [=====[Windsor McKee]=====]
200?’200px’:»+(this.scrollHeight+5)+’px’);»>
print «Mah good ol’ pal»
—> Mah good ol’ pal
print ‘»This is ridiculous!» he said.’
—> «This is ridiculous!» he said.
print [====[
O come, O come, Emmanuel,
and ransom captive Israel
that mourns in lonely exile here
until the Son of God appear.
]====]
— Выведет именно то, что видно
Если очень нужно использовать в строке и ‘, и «, но не хочется писать длинные скобки (вас можно понять: длинные скобки действительно некрасиво выглядят), то желаемый символ экранируется знаком \ (обратная косая черта):
200?’200px’:»+(this.scrollHeight+5)+’px’);»>
print «Can use both \’s and \»s.»
—> Can use both ‘s and «s
— Также можно экранировать перенос строки.
— Если убрать \ в строке ниже, программа не будет работать.
— Если требуется записать в строке непосредственно символ \,
— он пишется два раза подряд. Это не очень удобно, но по-другому
— нельзя: либо так, либо используйте длинные скобки.
print «C:\\Lua\\lua.exe»
—> C:\Lua\lua.exe
print [[D:\Photos\smile.jpg]]
—> D:\Photos\smile.jpg
Записи типа \», \’ и \\ называются экранирующими последовательностями или escape-последовательностями. Lua поддерживает и другие экранирующие последовательности, которые вы можете использовать в ваших строках:
print «Great\nNews!»
—> Great
—> News!
print ‘You are dumb\b\b\b\b\b nice’
—> You are nice
print «Nobody hid the facts\rBush »
—> Bush hid the facts
print «Hewey\tDewey\tLouie»
print «100$\t200$\t150$»
—> Hewey Dewey Louie
—> 100$ 200$ 150$
print ‘\x48\x65\x6C\x6C\x6F\x20\x77\x6F\x72\x6C\x64’
— Тайная запись на языке хакеров!
print «\d52\d50»
— Знаменитая программа, записаная строкой выше, на одном суперкомпьютере
— исполнялась миллион лет.
200?’200px’:»+(this.scrollHeight+5)+’px’);»>
print [[\n\t\v\b\a]]
Что же, теперь-то мы умеем записать в строке всё, что угодно, но не слишком ли это скучно? В строках самое интересное не то, что мы можем в них записать, а то, что мы можем с ними сделать.
200?’200px’:»+(this.scrollHeight+5)+’px’);»>
— Берём строку.
— [s]Варим три минуты[/s] Смотрим, что получилось:
С помощью оператора «..» к строке можно присоединять не только другие строки, но и числа, что даёт нам удобное средство форматирования вывода:
200?’200px’:»+(this.scrollHeight+5)+’px’);»>
kittens = 3
print(«I have «..kittens..» kittens.»)
—> I have 3 kittens
print [==[
No more bottles of beer on the wall.
No more bottles of beer.
Go to the store, buy some more!]==]
Как видно, получить с помощью конкатенации красивый текст с числами гораздо проще, чем если бы вы передали print несколько аргументов через запятую: так бы получилось, что между числом и остальными знаками слишком большой пробел.
print («banana» > «banona»)
—> false
print («Argonaut» > «argonaut»)
—> false
— ASCII-коды прописных букв меньше ASCII-кодов строчных букв
print («bit» true
— Если символы в неравнодлинных строках совпадают, меньшей считается
— более короткая.
print («Satan» == «Satan»)
—> true
Большинство оставшихся вохможных манипуляций со строками в Lua возложено на модуль string: он, как и модуль math, содержит некоторые функции, обращаться к которым необходимо с предшествующим именем модуля, отделённым точкой. Существование модуля string помимо всего прочего обязывает вас не называть ни одну переменную именем string, иначе доступ к модулю для программы будет потерян ценой создания одной маленькой переменной. А ведь, казалось бы, так хочется!
Многие из функций для работы со строками весьма сложны для понимания и использования и не так часто необходимы (например, string.gsub и string.match, а также string.format), поэтому нашего краткого обзора на них ни в коем случае не хватит, но я их всё равно упоминаю здесь, чтобы разжечь ваше любопытство и подтолкнуть вас к самостоятельному изучению их работы с помощью официального руководства, так как в практике программирования на Lua такие знания вполне могут пригодиться. А сейчас мы вкратце рассмотрим простейшие функции модуля string:
200?’200px’:»+(this.scrollHeight+5)+’px’);»>
string.len(«»)
— Пустая строка, вернёт 0.
string.len(«Yes we can»)
— Вернёт 10.
Длина строки в Lua измеряется в байтах, а не в символах, что на самом деле прискорбно. Между байтом и символом гарантированно нет никакой разницы, если вы используете только символы ASCII, и, в частности, не употребляете русских букв.
200?’200px’:»+(this.scrollHeight+5)+’px’);»>
string.upper(«A quick brown fox jumps over the lazy dog.»)
— Возвращает: «A QUICK BROWN FOX JUMPS OVER THE LAZY DOG.»
string.lower(«The NASDA System Was Developed To Protect US»)
— «the nasda system was developed to protect us»
Учтите, что эти функции обычно работают только с латинскими буквами, так что не стоит полагаться на них при работе с русскоязычными символами.
string.toupper и string.tolower удобно применять, если вы хотите сравнить две строки без учёта регистра: просто приведите их к одному регистру и затем производите сравнение.
function compare(str1, str2)
return (string.toupper(str1) == string.toupper(str2))
end
print( copmpare(«StrANgER», «sTRanGer»))
—> true
Опять же, так как многобайтовые символы Lua обрабатывает некорректно, использование русских букв в переворачиваемой строке может привести к непредсказуемым результатам. Также в Windows под вопросом корректное переворачивание строк, содержащих символ \n. Следовательно, string.reverse стоит применять с аккуратностью: не думайте, что («булка» == string.reverse(«аклуб»)) обязательно возвратит true.
200?’200px’:»+(this.scrollHeight+5)+’px’);»>
str = «WOBBLE»
sep = «, «
— Вызов с разделителем:
print( string.rep(str, 4, sep) )
—> WOBBLE, WOBBLE, WOBBLE, WOBBLE
—Вызов без разделителя:
print( string.rep(str, 4) )
—> WOBBLEWOBBLEWOBBLEWOBBLE
Полезность функции string.rep неочевидна, но мне за всю жизнь удалось пару раз успешно применить её. Правда, лучше бы я этого не делал.
200?’200px’:»+(this.scrollHeight+5)+’px’);»>
str = «John Emmanuel Doe»
— Указав только один индекс, мы велим функции обрезать строку слева до
— символа с этим индексом:
string.sub(str, 6)
— Возвратит «Emmanuel Doe»
string.sub(str, 6, 13)
— Возвратит «Emmanuel»
200?’200px’:»+(this.scrollHeight+5)+’px’);»>
str = «John Emmanuel Doe»
string.byte(str)
— Возвратит 74, код символа ‘J’
— Получаем полное представление строки в кодах ASCII.
string.byte(str, 1, string.len(str))
— Получаем 74, 111, 104, 110, 32, 69, 109, 97, 117,
— 101, 108, 32, 68, 111, 101
200?’200px’:»+(this.scrollHeight+5)+’px’);»>
string.char(0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x77, 0x6F, 0x72, 0x6C, 0x64)
— Возвращает строку «Hello world»
string.char()
— Возвращает пустую строку «».
string.char(74, 111, 104, 110)
— Возвратит «John»
—! string(1024, 768, 111)
—! Вызовет ошибку, работать не будет.
Вместо этого я расскажу вам о преобразованиях между строками и другими значениями и как иногда полезно применять эти преобразования.
Допустим, перед вами стоит задача: найти число, которое получается при перестановке цифр заданного числа в обратном порядке. Традиционное решение предполагает множество последовательных целочисленных делений, но Lua предлагает более элегантный подход, буквально в три действия:
print( rn(123), rn(150000), rn(1.33), rn(0.1))
—> 123 51 33.1 1
Ключевыми функциями в работе reversenumber являются tonumber и tostring.
200?’200px’:»+(this.scrollHeight+5)+’px’);»>
tonumber(«700»)
— Возвратит 700
tonumber(«ff», 16)
— 255
tonumber(«steiner», 36)
— 62727809283
tonumber(«one hundred»)
tonumber(«300 Spartans»)
— Вернут nil
2. tostring работает в обратном направлении: она возвращает строковое представление переданного в качестве параметра значения. Причём значением может быть:
200?’200px’:»+(this.scrollHeight+5)+’px’);»>
— Число
tostring(128)
— Вернёт «128»
— Логическое значение
tostring(1 > 0)
— «true»
— nil
tostring(nil)
— «nil» (строка «nil», а не значение nil)
— Функция
tostring(tostring)
— «function: 0x418a20»
Поздравляю! Теперь вы стали настоящим волшебником строк, и можете творить с ними почти всё, что вам вздумается. Веселитесь, потому что, как говорится:
Резюме:
1. Мы узнали, как записываются строки в тексте программы.
2. Узнали про экранирующие последовательности, как и для чего их применять.
3. Узнали про лексикографическое сравнение.
4. Выяснили, почему Lua плохо работает с русскими символами, и в каких ситуациях их следует избегать.
5. Узнали о целом ряде полезных функций модуля string.
6. Научились превращать числа и строки друг в друга с помощью функций tonumber и tostring.
Ответ на 3-й вопрос:
function a_count(str)
local count=0
for i=1, string.len(str) do
if string.byte(str,i)==string.byte(‘a’) then
count=count+1
end
end
print(«‘a’ repeats here «..count..» times»)
end
print(‘How many times does letter \’a\’ repeat in this sentence?’)
a_count(‘How many times does letter \’a\’ repeat in this sentence?’)
Ответ на вопрос 2:
Своя версия string.sub через функции
function string_sub(str,i,j)
return print(string.char(string.byte(str, i, j)))
end
string_sub(‘It\’s my life’,2,6) 
Скорее всего, сделаю, потому что вещь действительно порой полезная.
Однако, строго говоря, в Lua нет поддержки настоящих регулярных выражений: есть их урезанная версия под названием patterns (шаблоны). Разработчики языка прокомментировали это тем, что реализация полноценных регулярных выражений потребовала бы вдвое больше строк кода, чем в Lua уже есть.
Очень подробно разжёвано для чайников по LUA часть1!
Скрипты на языке Lua
Написанный на Lua скрипт не имеет какой-либо специальной функции, с которой начиналось бы его выполнение. Скрипт можно рассматривать просто как набор команд (инструкций), который выполняется, начиная с первой инструкции.
Скрипт может быть как очень простым, состоящим всего из одной команды, так и весьма сложным, содержащим десятки, сотни и даже тысячи инструкций. Следующие друг за другом инструкции могут разделяться точкой с запятой (;). Однако это требование не является обязательным, поэтому весь приведённый ниже код является корректным с точки зрения синтаксиса:
Работа с переменными в Lua
Переменные используются для хранения значений в процессе выполнения скрипта.
Имена переменных в Lua
Именами (идентификаторами) переменных в Lua могут быть любые последовательности из букв, цифр и символа подчеркивания, начинающиеся не с цифры.
Язык Lua различает регистр символов, поэтому abc, Abc, ABC являются различными именами.
В таблице ниже приведены слова, которые зарезервированы языком Lua и не могут использоваться в именах переменных:
and break do else elseif
end false for function if
in local nil not or
repeat return then true until
Кроме того, все имена, начинающиеся с символа подчеркивания, за которым идут заглавные буквы (например, _VERSION) также являются зарезервированными.
Какие переменные бывают в Lua?
Переменные в Lua могут быть глобальными и локальными. Если переменная не объявлена явно как локальная, она считается глобальной.
Глобальные переменные Lua
Глобальная переменная появляется в момент присваивания ей первого значения. До присваивания первого значения обращение к глобальной переменной даёт nil.
Глобальная переменная существует до тех пор, пока существует среда исполнения скрипта и доступна любому Lua-коду, выполняемому в этой среде.
При необходимости удалить глобальную переменную можно явным образом, просто присвоив ей значение nil.
g = 1 — создаем глобальную переменную g со значением 1
g = nil — удаляем глобальную переменную g
Все глобальные переменные являются полями обычной таблицы, называемой глобальным окружением. Эта таблица доступна через глобальную переменную _G. Поскольку полями глобального окружения являются все глобальные переменные (включая саму _G), то _G._G == _G.
Локальные переменные Lua
Любые локальные переменные должны быть объявлены явно с использованием ключевого слова local. Объявить локальную переменную можно в любом месте скрипта. Объявление может включать в себя присваивание переменной начального значения. Если значение не присвоено, переменная содержит nil.
local a — объявляем локальную переменную a
local b = 1 — объявляем локальную переменную b, присваиваем ей значение 1
local c, d = 2, 3 — объявляем локальные переменные c и d, присваиваем им значения 2 и 3
Область видимости локальной переменной начинается после объявления и продолжается до конца блока.
Областью видимости переменной называется участок кода программы, в пределах которого можно получить доступ к значению, хранящемуся в данной переменной.
Под блоком понимается:
тело управляющей конструкции (if-then, else, for, while, repeat);
фрагмент кода, заключённый в ключевые слова do. end.
Если локальная переменная определена вне какого-либо блока, её область видимости распространяется до конца скрипта.
a = 5 — глобальная переменная a
local i = 1 — переменная i локальна в пределах скрипта
while i 1, 4, 9, 16, 25
local a — переменная а локальна внутри then
local a = 20 — переменная а локальна внутри do-end
Когда возможно, рекомендуется использовать локальные переменные вместо глобальных. Это позволит избежать «засорения» глобального пространства имён и обеспечит лучшую производительность (поскольку доступ к локальным переменным в Lua выполняется несколько быстрее, чем к глобальным).
Типы данных Lua
Какие типы данных поддерживает язык Lua?
Lua поддерживает следующие типы данных:
1. Nil (ничего). Соответствует отсутствию у переменной значения. Этот тип представлен единственным значением — nil.
2. Boolean (логический). К данному типу относятся значения false (ложь) и true (истина).
При выполнении логических операций значение nil рассматривается как false. Все остальные значения, включая число 0 и пустую строку, рассматриваются как true.
3. Number (числовой). Служит для представления числовых значений.
В числовых константах можно указывать необязательную дробную часть и необязательный десятичный порядок, задаваемый символами «e» или «E». Целочисленные числовые константы можно задавать в шестнадцатеричной системе, используя префикс 0x.
Примеры допустимых числовых констант: 3, 3.0, 3.1415926, 314.16e-2, 0xff.
4. String (строковый). Служит для представления строк.
Строковые значения задаются в виде последовательности символов, заключённой в одинарные или двойные кавычки:
b = ‘это вторая строка’
Строки, заключённые в двойные кавычки, могут интерпретировать C-подобные управляющие последовательности (escape-последовательности), начинающиеся с символа «\» (обратный слэш):
\t (горизонтальная табуляция),
Символ в строке также может быть представлен своим кодом с помощью escape-последовательности:
где ddd — последовательность из не более чем трёх цифр.
Кроме кавычек для определения строки могут также использоваться двойные квадратные скобки:
local a = [[Компания «Кронос»]]
Определение строки с помощью двойных квадратных скобок позволяет игнорировать все escape-последовательности, т. е. строка создаётся полностью так, как описана:
При определении строки с помощью двойных квадратных скобок учитываются символы табуляции и переноса.
Двойные скобки могут быть вложенными. Для того чтобы их не перепутать, между скобками вставляется символ«равно» (=):
local a = [=[определение строки [[string]] в Lua]=]
— будет срока: «определение строки [[string]] в Lua»
5. Function (функция). Функции в Lua могут быть записаны в переменные, переданы как параметры в другие функции ивозвращены как результат выполнения функций.
6. Table (таблица). Таблица представляет собой набор пар «ключ» — «значение», которые называют полями илиэлементами таблицы. Как ключи, так и значения полей таблицы могут иметь любой тип, за исключением nil. Таблицы не имеют фиксированного размера: в любой момент времени в них можно добавить произвольное число элементов.
Подробнее — в статье «Создание таблиц в Lua»
7. Userdata (пользовательские данные). Является особым типом данных. Значения этого типа не могут быть созданы или изменены непосредственно в Lua-скрипте.
Userdata используется для представления новых типов, созданных в вызывающей скрипт программе или в библиотеках, написанных на языке С. Например, библиотеки расширений Lua для «CronosPRO» используют этот тип для представления таких объектов, как:
банки данных (класс Bank);
базы данных (класс Base);
записи (класс Record) и т. п.
8. Thread (поток). Соответствует потоку выполнения. Эти потоки никаким образом не связаны с операционной системой и поддерживаются исключительно средствами самого Lua.
Как в Lua задать тип переменной?
Lua не предусматривает явного задания типа переменной. Тип переменной устанавливается в момент присвоения переменной значения. Любой переменной может быть присвоено значение любого типа (вне зависимости от того, значение какого типа она содержала ранее).
a = 123 — переменная a имеет тип number
a = «123» — теперь переменная a имеет тип string
a = true — теперь переменная a имеет тип boolean
a = <> — теперь переменная a имеет тип table
Переменные типа table, function, thread и userdata не содержат самих данных, а хранят ссылки на соответствующие объекты. При присваивании, передачи в функцию в качестве аргумента и возвращении из функции в качестве результата копирования объектов не происходит, копируются только ссылки на них.
a = <> — создаем таблицу. В переменную a помещается ссылка на таблицу
b = a — переменная b ссылается на ту же таблицу, что и a
a[1] = 10 — элементу таблицы с индексом 1 присвоено значение 10
Остальные данные являются непосредственными значениями.
Как в Lua получить тип переменной?
Тип значения, сохранённого в переменной, можно выяснить при помощи стандартной функции type. Эта функция возвращает строку, содержащую название типа («nil», «number», «string», «boolean», «table», «function», «thread», «userdata»).
t = type («это строка») — t равно «string»
t = type (123) — t равно «number»
t = type (type) — t равно «function»
t = type (true) — t равно «boolean»
t = type (nil) — t равно «nil»
t = type (CroApp.GetBank()) — t равно «userdata»
Как в Lua преобразовать тип переменной?
Lua при необходимости автоматически преобразует числа в строки и наоборот. Например, если строковое значение является операндом в арифметической операции, оно преобразуется в число. Аналогично числовое значение, встретившееся в том месте, где ожидается строковое, будет преобразовано в строку.
a = «10» + 2 — a равно 12
a = «10» + 2 — a равно «10 + 2»
a = «строка» + 2 — Ошибка! Невозможно преобразовать «строка» в число
Значение любого типа можно явным образом преобразовать в строку с помощью стандартной функции tostring.
a = tostring (10) — a равно «10»
a = tostring (true) — a равно «true»
a = tostring (nil) — a равно «nil»
a = tostring (<[1] = «это поле 1»>) — a равно «table: 06DB1058»
Из предыдущего примера видно, что содержимое таблиц функцией tostring не преобразуется. Выполнить такое преобразование можно с помощью функции render.
a = render (10) — a равно «10»
a = render (true) — a равно «true»
a = render (nil) — a равно «nil»
Для явного преобразования значения в число можно использовать стандартную функцию tonumber. Если значение является строкой, которую можно преобразовать в число (или уже является числом), функция возвращает результат преобразования, в противном случае возвращает nil.
a = tonumber («10») — a равно «10»
a = tonumber («10»..».5″) — a равно 10.5
a = tonumber (true) — a равно «nil»
a = tonumber (nil) — a равно «nil»
Расстановка комментариев в Lua
Комментарий в Lua начинается двумя знаками «минус» (—) и продолжается до конца строки.
local a = 1 — однострочный комментарий
Если непосредственно после символов «—» идут две открывающие квадратные скобки ([[), комментарий являетсямногострочным и продолжается до двух закрывающих квадратных скобок (]]).
local a = 1 — [[ многострочный
Двойные скобки в комментариях могут быть вложенными. Для того чтобы их не перепутать, между скобками вставляется знак равенства (=):
local a = [[Компания «Кронос»]] — [=[
local a = [[Компания «Кронос»]]
Количество символов «=» определяет вложенность:
local a = [=[определение некоторой строки [[string]] в языке Lua]=]
Операции, применяемые в Lua
В выражениях, написанных на Lua, могут применяться следующие виды операций:
1. Арифметические операции.
Lua поддерживает следующие арифметические операции:
^ (возведение в степень);
% (остаток от деления).
Арифметические операции применимы как к числам, так и к строкам, которые в этом случае преобразуются в числа.
2. Операции сравнения.
В Lua допустимы следующие операции сравнения величин:
Операции сравнения всегда возвращают логическое значение true или false.
Правила преобразования чисел в строки (и наоборот) при сравнениях не работают, т. е. выражение «0» == 0 даёт в результате false.
3. Логические операции.
К логическим операциям относятся:
Операция and возвращает свой первый операнд, если он имеет значение false или nil. В противном случае, операция возвращает второй операнд (причём этот операнд может быть произвольного типа).
a = (nil and 5) — a равно nil
a == (false and 5) — a равно false
a == (4 and 5) — a равно 5
Операция or возвращает первый операнд, если он не false и не nil, иначе он возвращает второй операнд.
a == (4 or 5) — a равно 4
a == (false or 5) — a равно 5
Логические операции and и or могут возвращать значения любых типов.
Логические операции and и or вычисляют значение второго операнда только в том случае, если его нужно вернуть. Если этого не требуется, второй операнд не вычисляется. Например:
a == (4 or f()) — вызова функции f() не произойдет
Операция not всегда возвращает true или false.
4. Операция конкатенации.
Для конкатенации (объединения) строк служит операция… (две точки).
a = «Кронос»..»-«..«Информ» — переменная a получит значение «Кронос-Информ»
Если один или оба операнда являются числами, выполняется их преобразование в строки.
a = 0..1 — переменная a получит значение «01»
5. Операция получения длины.
В Lua определена операция длины #, которую можно использовать для получения длины строки.
len = #a — len равно 6
len = #«ещё строка» — len равно 10
Приоритет операций в Lua
В языке Lua выполнение операций осуществляется в соответствии со следующим приоритетом (в порядке убывания):
Вызов скриптов из форм
С каждой формой (включая вложенные формы) связан отдельный скрипт, который обычно содержит функции, выполняющие обработку событий формы и её элементов.
Когда форма запускается, её скрипт загружается в глобальное окружение. При возникновении события формы или её элемента система вызывает сопоставленную этому событию функцию-обработчик.
Необходимо отметить, что скрипт формы, хотя и не содержит вызова функции module, фактически является модулем. Это означает, что переменные, объявленные в скрипте формы без ключевого слова local, не выносятся в глобальное окружение и доступны только внутри этого скрипта. Если необходимо сделать какое-либо значение доступным для скриптов других форм, его следует явным образом определить в глобальной таблице _G:
Другой скрипт форм сможет прочитать это значение следующим образом:
Блоки операторов (инструкций)
К основным операторам Lua относятся:
операторы для организации циклов.
Группа операторов может быть объединена в блок (составной оператор) при помощи конструкции do… end.
Блок открывает новую область видимости, в которой можно определять локальные переменные.
a = 5 — глобальная переменная a
local a = 20 — внутри do-end определяется локальная переменная а
Оператор присваивания в Lua
Присваивание изменяет значение переменной или поля таблицы. В простейшем виде присваивание может выглядеть так:
a = 1 — переменной a присвоено значение 1
a = b + c — переменной a присвоена сумма значений переменных b и с
a = f(x) — переменной a присвоено значение, возвращённое функцией f(x)
В Lua допускается так называемое множественное присваивание, когда несколько переменных, находящихся слева от оператора присваивания, получают значения нескольких выражений, записанных справа от оператора присваивания:
a, b = 1, 5*c — a равно 1; b равно 5*c
Если переменных больше чем значений, «лишним» переменным присваивается nil.
a, b, c = 1, 2 — a равно 1; b равно 2; c равно nil
Если значений больше чем переменных, «лишние» значения игнорируются.
a, b = 1, 2, 3 — a равно 1; b равно 2; значение 3 не использовано
Множественное присваивание можно использовать для обмена значениями между переменными:
a = 10; b = 20 — a равно 10, b равно 20
a, b = b, a — теперь a равно 20, b равно 10
Условный оператор (if) в Lua
Оператор if проверяет истинность заданного условия. Если условие является истинным, выполняется часть кода, следующая за ключевым словом then (секция then). В противном случае, выполняется код, следующий за ключевым словом else (секция else).
return a — если a больше b, вернуть a
return b — в противном случае — вернуть b
Секция else является необязательной.
Перед каждой итерацией цикла проверяется условие :
если условие ложно, цикл завершается и управление передаётся первому оператору, следующему за оператором while;
если условие истинно, выполняется тело цикла, после чего все действия повторяются.
while i > 0 do — цикл от 10 до 1
Для выхода из цикла до его завершения можно использовать оператор break.
while i > 0 do — ищем в массиве отрицательное значение
MsgBox («Индекс отрицательного значения: »..i)
MsgBox («Массив не содержит отрицательных значений»)
Подробнее об особенностях использования оператора break — в статье «Операторы break и return»
Цикл с постусловием (repeat) в Lua
Оператор repeat предназначен для организации циклов с постусловием и имеет следующий вид:
Тело цикла выполняется до тех пор, пока условие не станет истинным. Проверка условия осуществляется после выполнения тела цикла, поэтому в любом случае тело цикла выполнится хотя бы один раз.
— суммируем значения массива a, пока сумма не превысит 10
MsgBox («Сложено »..i..» элементов. Сумма равна «..sum)
Для выхода из цикла до его завершения можно использовать оператор break.
Подробнее об особенностях использования оператора break — в статье «Операторы break и return»
Циклы с оператором for в Lua
Оператор for предназначен для организации циклов и допускает две формы записи:
простую (числовой for);
расширенную (универсальный for).
Простая форма оператора for
Простая форма оператора for имеет следующий вид:
for var = exp1, exp2, exp3 do
Тело цикла выполняется для каждого значения переменной цикла (счётчика) var в интервале от exp1 до exp2, с шагом exp3.
Шаг может не задаваться. В этом случае он принимается равным 1.
for i = 1, 10 do — цикл от 1 до 10 с шагом 1
Выражения exp1, exp2 и exp3 вычисляются всего один раз, перед началом цикла. Так, в примере ниже, функция f(x) будет вызвана для вычисления верхнего предела цикла только один раз:
for i = 1, f(x) do — цикл от 1 до значения, возвращенного функцией f()
Переменная цикла является локальной для оператора цикла и по его окончании не определена.
for i = 1, 10 do — цикл от 1 до значения, возвращенного функцией f()
MsgBox («После выхода из цикла i равно »..i) — Неверно! i равно nil
Значение переменной цикла нельзя изменять внутри цикла: последствия такого изменения непредсказуемы.
Для выхода из цикла до его завершения используется оператор break.
for i = 1,#a do — ищем в массиве отрицательное значение