Lua язык программирования компилятор. Чем открыть файл.LUA? Установка Луа. Доступ
Скрипты на языке 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.
MsgBox(tostring (g)) --> nil
MsgBox(tostring (g)) --> 1
Глобальная переменная существует до тех пор, пока существует среда исполнения скрипта и доступна любому Lua-коду, выполняемому в этой среде.
При необходимости удалить глобальную переменную можно явным образом, просто присвоив ей значение nil.
g = 1 - создаем глобальную переменную g со значением 1
g = nil - удаляем глобальную переменную g
MsgBox(tostring (g)) --> nil
Все глобальные переменные являются полями обычной таблицы, называемой глобальным окружением. Эта таблица доступна через глобальную переменную _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.
Если локальная переменная определена вне какого-либо блока, её область видимости распространяется до конца скрипта.
local i = 1 - переменная i локальна в пределах скрипта
while i <= a do - цикл от 1 до 5
local a = i^2 - переменная а локальна внутри цикла while
MsgBox(a) --> 1, 4, 9, 16, 25
MsgBox(a) -->
if i > 5 then
local a - переменная а локальна внутри then
MsgBox(a) --> 10
MsgBox(a) --> 5 (здесь обращение к глобальной a)
local a = 20 - переменная а локальна внутри do-end
MsgBox(a) --> 20
MsgBox(a) --> 5 (здесь обращение к глобальной a)
Обратите внимание
Когда возможно, рекомендуется использовать локальные переменные вместо глобальных. Это позволит избежать «засорения» глобального пространства имён и обеспечит лучшую производительность (поскольку доступ к локальным переменным в 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 (строковый). Служит для представления строк.
Строковые значения задаются в виде последовательности символов, заключённой в одинарные или двойные кавычки:
a = «это строка»
b = "это вторая строка"
Строки, заключённые в двойные кавычки, могут интерпретировать C-подобные управляющие последовательности (escape-последовательности), начинающиеся с символа «\» (обратный слэш):
\b (пробел),
\n (перевод строки),
\r (возврат каретки);
\t (горизонтальная табуляция),
\\ (обратный слеш);
\"" (двойная кавычка);
\" (одинарная кавычка).
Обратите внимание
Символ в строке также может быть представлен своим кодом с помощью escape-последовательности:
где ddd - последовательность из не более чем трёх цифр.
Кроме кавычек для определения строки могут также использоваться двойные квадратные скобки:
Определение строки с помощью двойных квадратных скобок позволяет игнорировать все escape-последовательности, т. е. строка создаётся полностью так, как описана:
local a = [] в Lua]=]
Будет срока: «определение строки [] в 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 = 10 - элементу таблицы с индексом 1 присвоено значение 10
MsgBox(b) --> "10"
MsgBox(a) --> "20"
Остальные данные являются непосредственными значениями.
MsgBox(a) --> "20"
MsgBox(b) --> "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 = "-5.3e-10"*«2» - a равно -1.06e-09
a = «строка» + 2 - Ошибка! Невозможно преобразовать «строка» в число
Значение любого типа можно явным образом преобразовать в строку с помощью стандартной функции tostring.
a = tostring (10) - a равно «10»
a = tostring (true) - a равно «true»
a = tostring (nil) - a равно «nil»
a = tostring ({ = «это поле 1»}) - a равно «table: 06DB1058»
Из предыдущего примера видно, что содержимое таблиц функцией tostring не преобразуется. Выполнить такое преобразование можно с помощью функции render.
a = render (10) - a равно «10»
a = render (true) - a равно «true»
a = render (nil) - a равно «nil»
a = render ({ = «это поле 1»}) - a равно "{ = «это поле 1»}"
Для явного преобразования значения в число можно использовать стандартную функцию 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 = [=[определение некоторой строки [] в языке Lua]=] --[==[
local a = [=[определение некоторой строки [] в языке Lua]=]
Операции, применяемые в Lua
В выражениях, написанных на Lua, могут применяться следующие виды операций:
1. Арифметические операции.
Lua поддерживает следующие арифметические операции:
+ (сложение);
- (вычитание);
* (умножение);
/ (деление);
^ (возведение в степень);
% (остаток от деления).
Обратите внимание
Арифметические операции применимы как к числам, так и к строкам, которые в этом случае преобразуются в числа.
2. Операции сравнения.
В Lua допустимы следующие операции сравнения величин:
== (равно);
~= (не равно);
< (меньше);
> (больше);
<= (меньше или равно);
>= (больше или равно).
Обратите внимание
Операции сравнения всегда возвращают логическое значение true или false.
Правила преобразования чисел в строки (и наоборот) при сравнениях не работают, т. е. выражение «0» == 0 даёт в результате false.
3. Логические операции.
К логическим операциям относятся:
and (логическое И).
Операция and возвращает свой первый операнд, если он имеет значение false или nil. В противном случае, операция возвращает второй операнд (причём этот операнд может быть произвольного типа).
a = (nil and 5) - a равно nil
a == (false and 5) - a равно false
a == (4 and 5) - a равно 5
or (логическое ИЛИ).
Операция 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 (логическое НЕ).
Операция not всегда возвращает true или false.
4. Операция конкатенации.
Для конкатенации (объединения) строк служит операция… (две точки).
a = «Кронос».."-"..«Информ» - переменная a получит значение «Кронос-Информ»
Обратите внимание
Если один или оба операнда являются числами, выполняется их преобразование в строки.
a = 0..1 - переменная a получит значение «01»
5. Операция получения длины.
В Lua определена операция длины #, которую можно использовать для получения длины строки.
a = «строка»
len = #a - len равно 6
len = #«ещё строка» - len равно 10
Обратите внимание
С помощью операции # можно также узнать максимальный индекс (или размер) массива. Подробнее - в статье «Работа с массивами в Lua» .
Приоритет операций в Lua
В языке Lua выполнение операций осуществляется в соответствии со следующим приоритетом (в порядке убывания):
2. not # - (унарный)
6. < > <= >= ~= ==
Вызов скриптов из форм
С каждой формой (включая вложенные формы) связан отдельный скрипт, который обычно содержит функции, выполняющие обработку событий формы и её элементов.
Когда форма запускается, её скрипт загружается в глобальное окружение. При возникновении события формы или её элемента система вызывает сопоставленную этому событию функцию-обработчик.
Необходимо отметить, что скрипт формы, хотя и не содержит вызова функции module, фактически является модулем. Это означает, что переменные, объявленные в скрипте формы без ключевого слова local, не выносятся в глобальное окружение и доступны только внутри этого скрипта. Если необходимо сделать какое-либо значение доступным для скриптов других форм, его следует явным образом определить в глобальной таблице _G:
local a = _G.var
Блоки операторов (инструкций)
К основным операторам Lua относятся:
присваивание;
условный оператор;
операторы для организации циклов.
Группа операторов может быть объединена в блок (составной оператор) при помощи конструкции do… end.
do - начало блока
<оператор1> - тело блока
<оператор2>
<операторN>
end - конец блока
Блок открывает новую область видимости, в которой можно определять локальные переменные.
a = 5 - глобальная переменная a
local a = 20 - внутри do-end определяется локальная переменная а
MsgBox(a) --> 20
MsgBox(a) --> 5 (здесь обращение уже к глобальной a)
Оператор присваивания в 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).
if a > b then
return a - если a больше b, вернуть a
return b - в противном случае - вернуть b
Секция else является необязательной.
if a < 0 then
a = 0 - если a меньше 0, присвоить a значение 0
Вместо вложенных операторов if можно использовать конструкцию elseif. Например, приведенный код:
будет проще для восприятия, если заменить его следующим:
return «Иван» - если a равно 1
elseif a == 2 then
return «Петр» - если a равно 2
elseif a == 3 then
return «Сергей» - если a равно 3
return «Нет такого игрока» - если a - ни одно из перечисленных
Цикл с предусловием (while) в Lua
Оператор while предназначен для организации циклов с предусловием и имеет следующий вид:
while
… - тело цикла
Перед каждой итерацией цикла проверяется условие
если условие ложно, цикл завершается и управление передаётся первому оператору, следующему за оператором while;
если условие истинно, выполняется тело цикла, после чего все действия повторяются.
while i > 0 do - цикл от 10 до 1
t[i] = «поле »..i
a = {3, 5, 8, -6, 5}
while i > 0 do - ищем в массиве отрицательное значение
if a[i] < 0 then break end - если найдено, прерываем цикл
i = i - 1 - иначе переходим к следующему элементу
if i > 0 then
MsgBox («Индекс отрицательного значения: »..i)
MsgBox («Массив не содержит отрицательных значений»)
Примечание
Цикл с постусловием (repeat) в Lua
Оператор repeat предназначен для организации циклов с постусловием и имеет следующий вид:
… - тело цикла
until
Тело цикла выполняется до тех пор, пока условие
Суммируем значения массива a, пока сумма не превысит 10
a = {3, 2, 5, 7, 9}
sum = sum + a[i]
until sum > 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
MsgBox («i равно »..i)
for i = 10, 1, -1 do - цикл от 10 до 1 с шагом -1
MsgBox («i равно »..i)
Обратите внимание
Выражения exp1, exp2 и exp3 вычисляются всего один раз, перед началом цикла. Так, в примере ниже, функция f(x) будет вызвана для вычисления верхнего предела цикла только один раз:
for i = 1, f(x) do - цикл от 1 до значения, возвращенного функцией f()
MsgBox («i равно »..i)
Переменная цикла является локальной для оператора цикла и по его окончании не определена.
for i = 1, 10 do - цикл от 1 до значения, возвращенного функцией f()
MsgBox («i равно »..i)
MsgBox («После выхода из цикла i равно »..i) - Неверно! i равно nil
Обратите внимание
Значение переменной цикла нельзя изменять внутри цикла: последствия такого изменения непредсказуемы.
Для выхода из цикла до его завершения используется оператор break.
a = {3, 5, 8, -6, 5}
for i = 1,#a do - ищем в массиве отрицательное значение
if a[i] < 0 then - если найдено...
index = i - сохраняем индекс найденного значения...
break - и прерываем цикл
MsgBox («Индекс отрицательного значения: »..index)
Примечание
Подробнее об особенностях использования оператора break - в статье «Операторы break и return»)
Lua for Windows (LfW) – интерпретируемый язык программирования, разработанный подразделением Tecgraf Католического университета Рио-де-Жанейро (Computer Graphics Technology Group of Pontifical Catholic University of Rio de Janeiro in Brazil). Разработанный интерпретатор является свободно распространяемым, с открытыми исходными текстами на языке Си.
По возможностям, идеологии и реализации язык ближе всего к JavaScript, однако Lua отличается более мощными и гораздо более гибкими конструкциями. Хотя Lua не содержит понятия класса и объекта в явном виде, механизмы объектно-ориентированного программирования, включая множественное наследование, легко реализуются с использованием метатаблиц, которые также отвечают за перегрузку операций и т. п.. Реализуемая модель объектно-ориентированного программирования – прототипная (как и в JavaScript).
Язык широко используется для создания тиражируемого программного обеспечения – в частности, на нём написан графический интерфейс пакета Adobe Photoshop Lightroom. Также получил известность как язык программирования уровней и расширений во многих играх (например, World of Warcraft) из-за удобства встраивания, скорости исполнения кода и лёгкости обучения.
Lua обычно называют мультипарадигменным языком. Он обеспечивает небольшой набор базовых механизмов, которые могут быть расширены для решения различных задач, а не набор сложных жёстких спецификаций, обеспечивающих программирование в единой парадигме.
Так, в Lua отсутствует явная поддержка наследования, однако оно легко реализуется с помощью метатаблиц.
В этой серии уроков, которую я задумал, будет обсуждаться язык программирования Lua. Я постараюсь сделать изложение как можно более доступным для начинающих, и именно на них буду ориентироваться. То есть, опытные Lua-кодеры, скорее всего, не почерпнут отсюда ничего нового (уверен, тут они найдут только простор для придирок и замечаний, которые, собственно, с их стороны даже приветствуется), но если у вас за плечами нет богатого опыта программирования, то, думаю, кое-что вы вынесете.Вся серия не будет подчиняться какой-то системе. Уроки будут последовательно вводить ряд конструкций языка, чтобы уже к третьему или четвёртому уроку вы уже могли писать свои программы. Моя цель - подтолкнуть вас к самостоятельному изучению языка, помочь ощутить его, а не разъяснить от А до Я - если хотите освоить язык полностью, читайте справочное руководство (которое, хоть и скверно, переведено на русский язык: http://www.lua.ru/doc/). Чем раньше вы перейдёте от уроков "для чайников" в Сети к изучению справочника, тем лучше.
Если что-то непонятно - обязательно задайте вопрос в комментариях, и я и другие участники постараемся вам помочь.
Lua - популярный, несложный для освоения встраиваемый интерпретируемый динамически типизированный язык программирования общего назначения. Нет, вам необязательно понимать и половины слов, сказанных в предыдущем предложении - главное знайте, что он популярный и несложный. Кстати, простотой, а также маленьким размером дистрибутива (около 150 килобайт), он и заслужил свою популярность. Скрипты на Lua поддерживаются большим количеством приложений, в том числе играми. World of Warcraft и S.T.A.L.K.E.R. используют язык Lua. Мой любимый игровой движок, позволит вам с помощью Lua с лёгкостью создавать разнообразные игры. Как видите, Lua открывает вам немалые горизонты!
Прежде чем мы начнём, вам следует обустроить среду для программирования: то есть, найти программу, которая принимала бы написанный вами код на Lua и исполняла его: интерпретатор. Тут есть три варианта:
1. Скачать официальный дистрибутив Lua с одного из сайтов, поставляющих их.
С официального сайта Lua можно скачать только исходные коды интерпретатора. Однако поизучав http://lua.org/download.html в разделе Binaries, вы можете обнаружить ссылки на сайты с исполняемыми файлами для Windows. Один из них: . Загрузите оттуда один из архивов (совпадающий с вашей платформой: Win32 или Win64) и распакуйте его куда-нибудь, желательно в каталог с коротким путём: вроде C:\lua. Отныне я буду полагать, что вы пользуетесь Windows, и ваш интерпретатор лежит именно там.
Пользователям операционных систем на базе Linux в этом смысле проще: им достаточно воспользоваться пакетным менеджером и установить Lua из репозиториев. В Debian и Ubuntu это делается командой apt-get install lua, а в Fedora, Red Hat и производных дистрибутивах - yum install lua. Однако не доверяйте мне слепо и обратитесь к справочнику вашей операционной системы, чтобы узнать, как именно это делается у вас.
2. Использовать онлайн-интерпретатор.
Находится по адресу http://www.lua.org/demo.html . На первых порах его может хватить, однако в дальнейшем, когда мы коснёмся модулей, вы будете вынуждены использовать оффлайн-версию. Пользоваться онлайн-интерпретатором очень просто: введите в окошко с текстом вашу программу и нажмите кнопку Run. Программа будет исполнена, в окошке Output покажется вывод вашей программы, а также отчёты об ошибках, если таковые были вами допущены.
3. Использовать IDE.
Например ZeroBrane Studio: http://studio.zerobrane.com/ . Есть и другие - поищите в Интернете.
В ходу сейчас две несколько различающиеся версии Lua: 5.1 и 5.2. Я буду ориентироваться на самую последнюю версию - версию 5.2, но обязательно укажу на важные различия между ей и 5.1, так как последняя тоже достаточно распространена. Кстати, Lua 5.1 исполняет код в полтора раза быстрее, чем Lua 5.2, чтобы вы знали.
=== Урок №1 ===
Итак, начнём. Создайте в изолированной от посторонних файлов папке файл main.lua и напишите в него:
200?"200px":""+(this.scrollHeight+5)+"px");">
-- main.lua --
print("Hello world!")
После чего запустите в командной строке (не забудьте переместиться в директорию с main.lua с помощью команды cd):
200?"200px":""+(this.scrollHeight+5)+"px");">
> C:\lua\lua.exe main.lua
В ответ интерпретатор Lua выдаст:
200?"200px":""+(this.scrollHeight+5)+"px");">
Hello world!
В принципе, этого следовало ожидать. В программе мы вызвали функцию print. Функция print принимает произвольное число параметров и последовательно выводит их на экран. В данном примере мы передали ей строку (цепочку символов) "Hello world!". С таким же успехом можно передать в качестве параметра:
200?"200px":""+(this.scrollHeight+5)+"px");">
print(8) -- какое-нибудь десятичное число
-- выведет: 8
Print(0xDEADBEEF) -- шестнадцатиричное число
-- выведет: 3735928559
Print("0xDEADBEEF") -- а это строка, не число! Видете кавычки?
-- выведет: 0xDEADBEEF
Print(1.35e-4) -- число с плавающей запятой (дробное число)
-- Выведет 0.000135. 1.35e-4 следует понимать как "1.35, умноженное
-- на десять в минус четвёртой степени", если кто не знает.
Print((198*99)-3*500 + 14/88) -- выражение
-- Выведет значение выражения: 18102.159090909. Неплохая альтернатива
-- настольному калькулятору!
Print(198/7, "fertilizer", 2^9) -- несколько параметров произвольного
-- типа. Будут выведены значения каждого из них, разделённые знаками
-- табуляции:
-- 28.285714285714 fertilizer 512
-- Обратите внимание, что кавычки вокруг fertilizer не выводятся!
Print(1,35) -- два числа, а не десятичная дробь 1,35!
-- Запятая используется для разделения параметров.
-- Выведет:
-- 1 35
Знак "--" - не просто имитация знака тире, которая вставлена для красоты. Знаком "--" в Lua отмечаются комментарии: подсказки для программиста, которые игнорируются интерпретатором, и предназначенные для того, чтобы в коде было легче разобраться. Можете попробовать написать в программе:
200?"200px":""+(this.scrollHeight+5)+"px");">
-- print("nothing")
Интерпретатор подумает, что это комментарий, и не станет выполнять инструкцию.
Хозяйке на заметку: если вы хотите напечатать только одну строку, можно написать вызов print так, без скобок:
200?"200px":""+(this.scrollHeight+5)+"px");">
print "Just one string"
Удобство, безусловно, сомнительное: просто имейте ввиду, что так можно. Вместе с тем, такие вызовы недопустимы:
200?"200px":""+(this.scrollHeight+5)+"px");">
print 2 -- не сработает, 2 - не строка.
print 2*2 + 6 -- тем более не сработает
Str = "string!!" -- присвоили переменной str значение "string!!"
-- о переменных читайте ниже
print str -- тоже не сработает.
В каждом из вышеперечисленных случаев программа просто откажется работать. Таким образом, в "бесскобочном" вызове за названием функции может стоять лишь строковый литерал (то есть, последовательность символов, заключённая в кавычки), и больше ничего. В будущем я расскажу об этой особенности чуть подробнее, но сейчас с вас хватит и этого.
В любом хорошем языке программирования возможно объявлять переменные: маленькие контейнеры, которые могут содержать какие-нибудь данные. В Lua это делается таким образом:
200?"200px":""+(this.scrollHeight+5)+"px");">
<имя_переменной> = <выражение>
Например:
200?"200px":""+(this.scrollHeight+5)+"px");">
star = 8 -- Теперь в переменной star хранится число 8
wars = "owl" -- В переменной wars - строка "owl"
jedi = 42/2 -- В переменной jedi - число 21
luke = star*jedi -- В переменной luke - число 168 (да, 21 умножить на 8)
Значения переменных и выражений с ними также можно вывести на экран:
200?"200px":""+(this.scrollHeight+5)+"px");">
print(star, wars, jedi, jedi-star+luke)
-- Выведет:
-- 8 owl 21 181
Только не пытайтесь сложить переменные star и wars - попытавшись прибавить 8 к "owl", вы ничего хорошего не добьётесь!
Как вы должны были заметить, имя у переменной может быть практически любым: главное, чтобы оно не начиналось с цифры. Серьёзно, вы даже можете объявить переменную с названием print, и тогда функция print перестанет работать, потому что имя print станет ссылаться на вновь объявленную переменную. Но есть группа слов, которые запрещено использовать в качестве названий переменных - это ключевые слова языка, с которыми мы пока не познакомились, но на которые точно стоит посмотреть:
200?"200px":""+(this.scrollHeight+5)+"px");">
and break do else elseif end
false for function goto if in
local nil not or repeat return
then true until while
Создав переменную с одним из этих названий, вы вызовете ошибку в программе, и работать она точно не будет. Обратите внимание: в Lua 5.1 ключевого слова goto нет, и переменную так назвать можно, но вы лучше так не делайте.
Также учтите, что имена переменных чувствительны к регистру. Это означает, что foo, fOo, fOO и FOO - четыре разные переменные, так что если вы написали имя какой-то переменной строчными буквами, а позднее написали его прописными, то, скорее всего, программа не будет работать корректно.
А теперь один важный момент: что будет если вы, случайно или преднамеренно, обратитесь к несуществующей переменной? В большинстве других языков это вызовет ошибку, но в Lua такая ситуация допустима. Она трактуется так, как будто несуществующая переменная на самом деле существует, но её значение равно nil . nil - запомните это слово! - особый тип значения в Lua, который означает "ничто". Не нуль и не пустую строку (строку вида "" - попробуйте её вывести на экран), а просто ничто. Сравните это с такой моделью: есть два человека, у одного из них есть банковский счёт, но на нём нет денег, а у другого банковского счёта нет вообще. В терминах Lua будет считаться, что на счету у первого - 0 долларов, а на счету у второго - nil . И даже не долларов, а просто nil . Надеюсь, я вас не запутал.
Попробуйте, например, запустить такую программу:
200?"200px":""+(this.scrollHeight+5)+"px");">
-- main.lua --
foo = "bar"
print(foo, baz)
-- Выведет:
-- bar nil
Таким образом, у переменной baz, которой нет, но считается, будто она есть, значение nil, и функция print понимает это и выводит его на экран в виде строки "nil". В Lua есть хороший метод проверки существования переменной: если значение переменной не равняется nil, то она по крайней мере объявлена. С другой стороны, можно явно объявить переменную, равную nil:
200?"200px":""+(this.scrollHeight+5)+"px");">
cool_var = nil
Так можно делать, и, хотя это на первый взгляд и кажется глупым, так иногда делают. В последующих уроках вы узнаете, кто и зачем, и наверняка начнёте делать так же. Иногда, конечно же.
Будьте осторожны с nil"ом: напечатать nil можно, но совершать с ним арифметические операции нельзя! То есть, если print(nil) сойдёт вам с рук, то конструкция вроде 99+nil вызовет ошибку, даже если вам бы хотелось, чтобы 99+nil равнялось 99. Поверьте, я тоже огорчился, когда узнал.
Резюме:
1. Мы узнали про функцию print, что она умеет и как правильно вызывать её без скобок.
2. Узнали, как объявлять переменные, как вычислять выражения (правда, совсем немножко), какие могут быть имена у переменных.
3. Узнали про nil, прониклись его мистической загадочностью и обрели уверенность в том, что в будущем многое будем связано с ним.
Для пытливых и желающих укрепить свои познания предлагаю простые упражнения,
которые можно не выполнять, если вы чувствуете себя и без того достаточно компетентным:
1. Напишите программу, которая выводит припев вашей любимой песни.
2. Попробуйте вывести значения следующий выражений. Попытайтесь понять, почему некоторые из них работают, а некоторые - нет. Посмотрите, какие ошибки вызывают несработавшие выражения.
200?"200px":""+(this.scrollHeight+5)+"px");">
2 + "string";
6 + "14";
"box" - "vox";
1 * "11b"
"148" * "1e6";
3. Напишите программу, которая обменивает две переменные значениями. То есть:
200?"200px":""+(this.scrollHeight+5)+"px");">
a = 6502
b = 8086
Сделайте так, чтобы a стала равна 8086, а b - 6502. Для этого создайте третью переменную и совершите нехитрые перестановки. Убедитесь, что задача решена правильно, вызвав print(a,b) до обмена и print(a,b) после.
Это вопрос, который возникает достаточно часто. Что, вообще-то, достаточно удивительно, потому как установка на самом деле, крайне проста и понятна. Можно даже сказать, что там вообще нечего делать. Но, раз уж такие вопросы возникают, давайте немного поговорим об установке .
Установка Луа. Скачиваем
Первое, что нам нужно будет сделать перед установкой, это скачать исходники с её официального сайта: . Для установки, естественно, нам понадобится самая последняя версия, на данный момент это lua 5.1.4. После скачивания, естественно, надо разархивировать исходники lua в отдельную папку.
Установка Луа. Компиляция.
Есть два варианта компиляции , которые, в принципе, ничем не отличаются))) Первый – это компиляция из Visual Studio Command Prompt:
- Запускаем Visual Studio
- Выполняем Tools->Visual Studio Command Prompt
- Переходим в папку с луа, в директорию etc. Вот так: cd D:/mylibs/lua-5.1.4
- запускаем скрипт компиляции луа: etc/luavs.bat
- Мы получили нужны нам файлы lua.exe и luac.exe
Второй способ без запуска Visual Studio:
- В любом файл-мендеже (я лично работаю в ) заходим в папку где_луа/etc/
- Редактируем файл, первой строкой ставим: call “путь_к_вижуалстудио/VC/bin/vcvars32.bat”
- Добавляем вторую строку: cd .. и сохраняем файл
- Запускаем, получаем искомые экзешники
Установка Луа. Доступ
Что бы вы могли запускать луа откуда угодно – вам надо добавить их (путь к ним) в переменную окружения %PATH%. Думаю, Вы сами прекрасно знаете как это сделать. В любом случае, нам не нужны эти файлы, т.к. мы планируем использовать луа внтри наших программ, а не как отдельное приложение. После этого считайте, что сама установка Lua завершена, вам лишь остаётся прописать в Visual Studio пути в получившейся.lib и хидерам луа.
Установка Луа. Статическая линковка.
Меня лично выводит из себя то, что с каждый проектом, использующим луа, приходится таскать и lua.dll , поскольку без неё программы работать не будут. А что бы они работали – надо что бы луа линковалась с нашей программой статически. Делается это тоже совсем не сложно:
- Делаем в Visual Studio новый проект, Win32Project, назовём его “LuaLib”
- Тип проекта указываем “Static Library”, отключаем использование Precompiled Header, нажимаем Finish
- Добавляем в проект все файлы.h и.c, кроме lua.c и luac.c
- Что бы компилятор не выдавал нам варнингов, в настройки проекта (Protec/Propreties/Preprocessor) добавляем;_CRT_SECURE_NO_WARNINGS (не забудьте сделать это и для релиз и для дебаг-версии!!!)
- В настройках линковки (Project/Properties/Librarian/General/OutputFile) указываем какие имена библиотек мы хотим. Я указал lua.lib для релиза и lua-debug.lib для дебага.
- Компилируем дебаг и релиз-версии. Получаем нужные нам либы
- Прописываем пути к ним в Visual Studio
Установка Луа. Проверка.
Проверим, всё ли работает. Создаём новый проект (я сделал консольный проект win32). Дописываем инклюды луа:
и доделываем сам main():
int _tmain(int argc, _TCHAR* argv ) { lua_State * L; L = lua_open() ; //Создаем стэк luaL_openlibs(L) ; //подключить стандартные библиотеки int status = luaL_loadfile(L, "test.lua" ) ; //загрузить файл /* Состояние стtка: [-1]main <--top of the stack */ if (status) { (void ) fprintf (stderr , "file not found\n " ) ; return 1 ; } int result = lua_pcall(L, 0 , LUA_MULTRET, 0 ) ; _getch() ; return 0 ; } |
В настройки линковщика (Project/Properties/Linker/Input/Addition Dependencies) не забываем добавить нашу библиотеку (lua.lib для релиза и lua-debug.lib для дебага). Компилируем. Создаём тестовый файлик с луа-скриптом.
- Расширение (формат) - это символы в конце файла после последней точки.- Компьютер определяет тип файла именно по расширению.
- По умолчанию Windows не показывает расширения имен файлов.
- В имени файла и расширении нельзя использовать некоторые символы.
- Не все форматы имеют отношение к одной и той же программе.
- Ниже находятся все программы с помощью которых можно открыть файл LUA.
Многие пользователи MS Windows давно успели заметить, что стандартный блокнот - это довольно неудобная в своем использовании программа. Заменой ей может стать данный бесплатный редактор текстовых файлов, обеспечивающий поддержку синтаксиса большого количества языков программирования. Программа содержит в себе довольно широкий набор опций и отличается минимальным потреблением ресурсов процессора. Программа делает возможным одновременный просмотр нескольких документов сразу и редактирование их, без закрытия лишних окон. Доступной стала и такая опция, как редактирование одного и того же документа в разных местах, что очень удобно...
Notepad2 – простое приложение, позволяющее печатать и редактировать текст. Она поможет в создании HTML-страниц, программировании на различных языках (CSS, Java, JavaScript, Python, SQL, Perl, PHP) так как способна подсвечивать код. Программа построена по принципу простого блокнота, она маловесна и компактна. Этот текстовый редактор проверяет все скобки на наличие пары, поддерживает авто отступы. Программа Notepad2 не только поддерживает кодировки ASCII и UTF-8, но и умеет их конвертировать. Позволяет откатывать нежелательные операции на много уровней назад. Поддерживает блочное выделение элементов текста и имеет нумерованные ст...
Komodo Edit - удобный редактор кода, поддерживающий широкий спектр различных языков программирования. Программа дает пользователям возможность работать сразу с несколькими файлами, писать код станет более эффективно с использованием функции автозаполнения, подсказок. Приложение позволяет автоматически выделять переменные при их выборе. С помощью редактора можно просматривать файлы на других программных языках. Программа поддерживает окраску синтаксиса, отступы. Может проверять параметры синтаксиса, сниппеты, используемые для хранения кода исходного столбца. Имеет режим простого редактирования и поддерживает перетаскивание элеме...
В интернете очень много программ, позволяющих редактировать исходный код другой программы, файла и др. Однако большинство из подобных программ являются всего лишь текстовым редактором наподобие блокнота. Отличаются они от вышеуказанного редактора лишь тем, что имеют подсветку синтаксиса. Однако в некоторых случаях, такого функционала программы оказывается недостаточно. Программисту бывает необходимо быстро находить различные части документа. И вот, наконец-то, в появилась программа, позволяющая решить эту проблему. Программа называется SynWrite. Её отличительная особенность – наличие навигационной панели с деревом, котор...