Что такое массив, наверное всем понятно. Это набор данных одного и того же типа, занумерованный последовательностью целых чисел (индексами) с "шагом" 1. Обычно индексация делается либо от 0 до N-1, где N - количество элементов массива, либо от 1 до N. И тот и другой подход имеет свои плюсы и минусы; в более низкоуровневых языках вроде С/C++ применяется (и оказывается реально удобнее!) индексация с нуля, а вот в Lua "прижилась" индексация массивов с 1. Как мы потом узнаем, это всё не очень принципиально, и при правильном построении программ об этом вообще не приходится думать.

Как объявляются массивы и как с ними работать? Очень просто:

Как видите, всё очень наглядно. Размер массива можно узнать следующим образом:

Более подробно о массивах, их размерах и других тонкостях мы поговорим в отдельной главе, а пока познакомимся с таблицами. Если читатель знаком, например, с С++ и библиотекой STL, то для него таблица "в первом приближении" - это стандартный контейнер std::map. Для "остальных смертных" придётся сказать, что таблица - это ассоциативный массив, представляющий собой множество пар { (key, value) }, для которого определена операция [] (получение элемента value по ключу key). Немного забегая вперед, скажем что массивы в Lua - это на самом деле тоже таблицы с числовыми значениями ключа key от 1 до размера массива.

Вышесказанное показалось вам слишком сложным и непонятным? Ничего страшного, это просто формальное определение интуитивно простых понятий. Сейчас мы рассмотрим пример и всё станет понятно. Например, у нас есть телефонная записная книжка, в которой контактам сопоставлено (для простоты) по одному телефонному номеру. В Lua эту книжку можно было бы задать так:

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

Для таблиц со строковыми ключами, которые записаны латинскими буквами и не содержат в себе пробелов (то есть по сути являются идентификаторами языка), можно использовать упрощенный синтаксис при обращении к элементам таблицы, делая ее похожей на структуру (или класс). А именно:

Здорово, не правда ли? Запись через точку в присвоении выглядит горзадо понятнее, чем в распечатке значений со скобками. Самое главное, у нас появляется возможность двоякой работы с таблицами - как со структурами и как с массивами (ну, разве что с соблюдением более строгих правил для имен полей).

На этом мы временно оставим таблицы в стороне - этого нам будет достаточно для понимания некоторых дальнейших примеров.

Операции в Lua

Настало время поговорить о самых простых средствах языка - операциях. Как и во всех остальных языках, в Lua имеется более чем джентльменский набор операций - арифметических, логических и строковых. Начнем разумеется с простого -- с арифметики.

Арифметические операции

Сколько их, арифметических операций? четыре? Неправильно, шесть: сложение, вычитание, умножение, деление, взятие остатка от деления и возведение в степень. Обозначения их стандартны и используются во многих других языках:

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

будет равно 6.25, а не 6, как в языке С/C++. Lua по сути не делает различий между вещественными и целыми числами. Приятно отметить, что он позволяет работать с достаточно большими целыми числами (в текущих реализациях - до 2^46), не переходя к экспоненциальной форме хранения.

Кроме арифметических операций, имеется ещё некоторое количество функций математической библиотеки, добавляющие нам разного рода округления, стандартные математические функции типа синусов и косинусов, но их мы обсудим позже.

Логические операции

Основные операции "И", "ИЛИ", "НЕ" в Lua записываются как and, or, not и полностью аналогичны другим языкам. Пример:

Операции сравнения похожи на операции в С/C++. Сравнение здесь пишется двумя знаками равенства ==, а "не равно" -- комбинацией ~= (тильда и знак равенства).

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

Первый раз будет напечатано 0, а второй раз -- 10. Таким образом, если один из операндов or равен nil, выражение "x or y" будет равно противоположному операнду. Это удобно для инициализации переменных заведомо корректными значениями (отличными от nil), если заранее значение не известно. Конструкция выглядит гораздо красивее, чем аналогичное сооружение с if.

Строковые операции

Со строками можно делать много всего, но операция для работы с ними всего одна - конкатенация (или, по-кухонному, склейка) двух строк. Надо отметить, что для её обозначения пока что не выработалось общемирового стандарта, поэтому в Lua она обозначается двумя точками (к слову, в PHP для этой цели используется точка, в JavaScript - знак плюс). Пример тривиален, но мы его всё-таки напишем:

Lua допускает склейку строк с числами - в этом случае последние преобразуются в десятичную запись. Пример:

Но ни в коем случае не пытайтесь склеивать строку с неинициализированной переменной (или, что то же самое, со значением nil):

Если переменная nothing не инициализировалась ранее, программа "вылетит" с ошибкой примерно такого содержания: "attempt to concatenate global 'nothing' (a nil value)". Разумеется, вылетит только во время выполнения, так как заранее никто не знает, будет где-нибудь задано этой переменной значение или нет.

Смешение типов

Любопытный читатель наверняка захочет применить какие-нибудь операции к переменным тех типов, к которым "официально" их применять нельзя. И тут его ждет некоторое разочарование - они будут восприняты языком вполне адекватно и естественно. Например:

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

Операторы языка

Сейчас мы перейдем к обсуждению того, без чего не напишешь ни одной серьезной программы. А именно, об операторах языка для управления логикой работы программы. Как и в любом уважающем себя языке, в Lua есть ветвление (if..then..else) и циклы (for, while, repeat). Их мы сейчас и обсудим.

Отметим, что в Lua нету так называемых "операторных скобок", вроде { ... } в С/С++ и begin .. end в Pascal. Поэтому большинство операторов имеют форму ключевое слово ... end (кстати, забегая вперед, скажем что то же самое относится к объявлению функций). Сейчас мы подробно обсудим каждый из операторов, а начнем с самого часто используемого -- условного оператора if.

if..elseif..elseif..else..end

Синтаксис его таков (поскольку в Lua переносы строк не имеют значения, будем для красоты использовать многострочную запись):

Первый, самый простой вариант без else:

Вместо многоточий пишите то, что должно быть выполнено, если логическое_выражение может быть (неявно) приведено к логическому true. В Lua значения nil и false воспринимаются как ложь, всё остальное - как истина (даже значение 0). Это немного непривычно для программистов на С и приучает писать сравнения более аккуратно.

Второй вариант, с else:

Если условие верно, выполняется первый блок, если нет -- второй. Альтернативных условных блоков может быть много, в этом случае добавляется elseif:

Цикл for

Цикл имеет два варианта синтаксиса: арифметический и for-each. Разберем сначала первый, для этого хватит пары примеров:

Тут переменная пробегает значения от 1 до 10 и программа выводит 10 строчек с её значениями. Третье число означает шаг увеличения переменной (если оно равно 1, его можно не писать вообще). Важная особенность: выражения, определяющие начальное, конечное значение и шаг переменной цикла вычисляются один раз при входе в него. Если потребуется выйти "досрочно" - используйте оператор break, о котором будет рассказано далее.

Арифметическая форма цикла for используется редко ввиду особенностей языка, а точнее ввиду его области наболее частого применения. Гораздо чаще в Lua применяется второй вариант (если он сейчас будет совсем не понятен, ничего страшного - дальше мы ещё будем очень подробно говорить о таблицах, ключах и индексах). Он обычно называется for-each, так как некоторое действие (в данном случае тело цикла) делается для каждого элемента из некоторого множества (в примере - для каждой записи таблицы).

Программа выведет три строки с упоминанием в них элементов таблицы. Переменная k пробегает индексы таблицы (т.е. массива), а val -- значения элементов по этим индексам. Здесь мы попутно бегло познакомились с очень полезной конструкцией pairs, которая выдаёт ключ (индекс) таблицы и ее элемент. К этому примеру мы ещё вернемся позже.

В качестве более интересного примера для циклов напишем программу, которая выведет все простые числа от 2 до 1000 (делящиеся только на 1 и само себя). Алгоритм самый примитивный, который только может быть (перебор всех делителей).

Здесь скобки вокруг x % d стоят исключительно для наглядности. Приоритет операции % (остаток от деления, так же как и в С) выше, чем приоритет сравнения.

Цикл while

Удобство цикла for проявляется тогда, когда мы знаем, сколько раз нам этот цикл крутить. А если нам нужно какое-то действие выполнять, пока верно некоторое условие, удобнее использовать цикл while. Синтаксис его очень простой:

При входе в цикл значение выражения проверяется на истинность. Если оно ложно, цикл не выполняется ни разу. Если истинно, выполняется первая итерация, и снова проверяется условие. Если оно снова истинно - выполняется вторая итерация, и так далее. Если наше выражение так и останется истинным - цикл будет бесконечным. Наш более содержательный пример - нахождение положительного корня уравнения x^2=2 методом половинного деления на отрезке от 1 до 2. Его значение мы и так знаем: sqrt(2), но мы вычислим его двумя способами и сравним результаты.

Тут, как Вы наверное уже заметили, есть сюрприз в виде неизвестных нам пока функций math.abs и math.sqrt. Знакомые с другими языками разумеется догадались, что это модуль (абсолютное значение) числа и квадратный корень соответственно. Я намеренно включаю в свои примеры некоторые функции из стандартной библиотеки, чтобы читатель постепенно их тоже осваивал по ходу пьесы.

Если выполнить программу, мы увидим, что результаты отличаются только в 11-м знаке. Неплохая точность, не правда ли?

Цикл repeat..until

Цикл repeat..until отличается от цикла с пред-условием (while) тем, что всегда выполняется хотя бы один раз. Синтаксис его аналогичен while c точностью до зеркального отражения:

Цикл выполняется до тех пор, пока выражение не станет истинным. Следующий пример печатает первое число, которое больше 2000 и делится на 13:

Блок do..end

Эта конструкция сама по себе ничего не делает, это просто блок команд, аналогичный {...} в С/C++. Как мы потом узнаем, она влияет на видимость переменных, их глобальность и время жизни. С его помощью удобно выделять логически разные куски кода, если по каким-то причинам их неудобно выносить в отдельные функции. Переменные, обявленные локальными внутри блока, погибают при выходе из его, поэтому целесообразно применять его например в тех случаях, когда мы имеем дело с "большими" (по объему памяти) переменными, и т.д.

Управляющие конструкции в циклах

Прервать выполнение цикла досрочно можно с помощью оператора break. Его можно использовать только внутри циклов. Синтаксис его использования таков:

Переменные: более пристальный взгляд

Как правильно объявлять переменные?

В Lua можно определять переменные практически где угодно. Вернее, поскольку специальное объявление как таковое не требуется, можно вводить переменную именно тогда, когда уже известно ее значение. Это позволяет избежать ошибок с использованием неинициализированных значений. Стиль, навязываемый скажем, языком Pascal, в котором переменные объявляются в специальной секции, совершенно порочен и кроме ошибок ничего не даёт. Кто-то скажет, что так лучше видно, какие в процедуре есть переменные и какие у них типы, однако же никто не знает, используются они вообще в программе или нет, а уж чему равны - тем более не ясно. Поэтому, объявляйте переменную там и только там, где она вам пригодилась.

Тут ничего хитрого нет. Объявляется глобальная переменная text, ей задаётся некоторое значение, а потом переменной more_text присваивается склейка строковой константы и значения первой переменной. Вообще, любая переменная в Lua является по умолчанию глобальной. А вот следующий пример уже кому-то может показаться необычным. Во всяком случае, в других языках такие конструкции не работают:

Здесь будет напечатано сначала 1, а потом text. На первый взгляд не очень понятно, в чем смысл такой конструкции - казалось бы лучше объявить сначала одну переменную, а потом другую. Но этот прием очень часто применяется в более сложных примерах, где используются функции, возвращающие не одно значение, а сразу много. Тогда это становится удобным. А если вам нужно поменять две переменные a и b местами, это можно сделать очень элегантно:

Не правда ли, красиво? То же самое можно сделать с тремя, четырьмя переменными (например, переставить их по кругу). Разумеется, в таких конструкциях мы должны внимательно следить за порядком переменных, но это уже, как говорится, дело техники. При всём при этом Lua не понимает, например, вот таких вот "извращений в стиле С":

Область видимости переменных

Хороший тон программирования предполагает использовать локальные переменные всюду, где это возможно, и и стараться не использовать глобальных переменных вообще. Поэтому теперь мы будем везде стараться объявлять локальные переменные. Делается это с помощью ключевого слова local.

Как это всё работает? продемонстрируем на примере:

Как Вы думаете, что напечатает наш пример? Правильно, Вы угадали - он напечатает строку ext variable, потому что переменная внутри оператора if является локальной по отншению к внешней переменной, и значение будет задано у нее, а не переопределено значение внешней переменной. Разумеется, наш пример корректен, поскольку условие верно, и мы попадаем внутрь if-а.

Разумеется, если написать вот так:

... то переменная у нас тут всего одна и будет изменено именно ее значение, и программа выведет int variable.

В общем случае область видимости переменной - это блок некоторого оператора (if, for, while) блок операторов do..end, тело функции или же вся программа (точнее файл). Обладая этим понятием, можно сформулировать общее правило: среди всех переменных с данным названием, встречающихся в коде, в выражении используется ближайшая в данной области видимости (если расстоянием считать глубину вложенности областей).

Пожалуй, для полноты картины стоит привести ещё один (не очень хороший, но допустимый) пример кода. К сожалению, он потребует объявления функции, но я надеюсь, интуитивно понятен:

Поначалу можно подумать, что будет выведено значение nil два раза, так как "глобальную" переменную global_var никто не инициализирует, а то что делается внутри функции, так и останется в ее пределах. Ан нет: сначала будет напечатано nil, а второй строкой -- слово "value", потому что внутри функции идёт обращение именно к глобальной сущности. Разумеется, стоит нам написать внутри функции заветное слово local в этом присвоении, как ситуация преобразится радикальным образом, и будет выведено два раза слово nil. Вообще, таких неявных конструкций следует избегать, поскольку они часто порождают ошибки.

Осталось заметить, что модификатор local применим так же и к функциям в Lua и влияет на их область видимости (доступности). Это удобно, когда функция заведомо будет использоваться только в рамках данного файла, в котором она описана и не приведет к "засорению" глобального пространства имён.

Типы данных. Динамическая типизация

А какие вообще в Lua бывают типы?

Наверное многие уже поняли, что в Lua имеют право на жизнь как минимум числа (целые и вещественные, между ними нету разницы), строки и таблицы. На самом деле и это тоже не всё. Фокус в том, что функция в Lua - это тоже тип данных, и с функциями можно обращаться почти так же, как с обычными переменными - присваивать одной функции другую функцию, и многое другое. Но про функции у нас ещё будет отдельный длинный разговор, вернемся на землю к "обычным" переменным и типам. Если читатель ещё не забыл введение, там упоминался ещё один специальный тип nil, озанчающий отсутствие какого-либо объекта. Но и на этом список типов не завершается, поскольку в Lua бывают ещё thread-ы (потоки). Но о них мы поговорим позже.

Объявление переменной (точнее, инициализация), как уже говорилось выше, и определяет ее тип в данный момент времени. Почему "в данный момент", а не вообще? Потому что есть динамическая типизация, о которой речь чуть ниже. Вот несколько примеров определений переменных разных типов:

Вот по сути и всё, что в Lua допустимо с точки зрения типов. Последняя запись примера с на самом деле не имеет смысла: любая неинициализированная переменная и так имеет значение . Другое дело что в более сложной программе такое присваивание может вполне себе иметь нетривиальный смысл. Чуть забегая вперед, можно сказать что такая запись ведёт к разрушению данной переменной, если до этого она ссылалась на некоторый объект.

Динамическое определение типа переменной

Теперь мы поясним смысл выражения "в данный момент" из предыдущего параграфа. Сейчас мы повторим наш пример, смело заменив в нем имена переменных на какое-нибудь одно (назовем ее просто var):

Проницательный читатель уже давно догадался, что два минуса "--" озанчают строчные комментарии в Lua, а оператор type возвращает тип переменной.

Функции

Маленькое лирическое отступление о функциях... Основа читаемости любого кода - это его структурированность. Если написать текст программы "одним куском", его никто не поймет, а его длина в большинстве случаев увеличится во много раз по сравнению с другими реализациями, а скорость работы возрастёт незначительно. Самый простой способ структурировать программу -- разбить её на подпрограммы, снабдив каждую из них именем. Эти подпрограммы в народе называются процедурами и функциями. Точнее говоря, в разных языках - по-разному, но термин "функция" есть в большинстве языков. Из популярных, пожалуй, только в ассемблере устоялся термин "процедура", поскольку там функции синтаксически не отличаются от процедур. Обычно под "процедурой" подразумевают подпрограмму, которая делает некоторое действие, но не возвращает никаких значений (например, именно так дела обстоят в Pascal/Delphi), а функция - это подпрограмма, имеющая "результат" в виде некоторого объекта, называемого "возвращаемым значением" (return value) функции. А например в языках С и С++ эта грань, напротив, стерта и там все подпрограммы с точки зрения синтаксиса являются функциями. Так... к чему я это всё? А, ну да. Мне просто хотелось сказать что Lua в этом плане похож на С/С++ и там любая подпрограмма - это функция. А теперь обо всём по порядку.

Простые (классические) примеры функций

Синтаксис объявления (описания) функции таков:

Описание функции начинается с ключевого слова function, далее в скобках перечисляются аргументы функции (только их имена, никаких типов) которые являются локальными переменными внутри функции. Перед ключевым словом function можно, как и в случае переменных, написать слово local, что повлияет на область видимости самой функции. Аргументами функции обычно является последовательность переменных, разделенных запятой. Почему "обычно"? Потому что есть ещё один интересный и полезный случай, который мы разберем чуть ниже.

В отличие, скажем, от С, в Lua нету понятия "протопипа" (заголовка) функции. Она видна везде в своей области видимости, в том числе и выше своего описания.

Выход из функции происходит либо по достижению последней инструкци в функции, либо с помощью оператора return. Если return-а нет, наша функция будет возвращать значение nil (то есть на самом деле ничего возвращать не будет).

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

Этой функцией можно склеивать числа, строки, nil-ы -- всё что угодно, ошибки не произойдет. Потом мы узнаем, как такое можно делать более красиво, но это будет потом.

Функции с переменным числом аргументов

Как и в С/C++, в Lua можно задавать функции с переменным числом аргументов. В этом случае они передаются туда как массив с зарезервированным именем arg c индексами от 1 до n, где n=arg.n (буква 'n' -- это тоже на самом деле индекс массива, имеющий строковый тип и значение 'n'. Если это сейчас не очень понятно - ничего страшного, всё встанет на свои места, когда мы разберемся с таблицами, и иожете пока просто это выражение (arg.n) воспринимать как заклинание). Вместо имен параметров функции нужно написать троеточие. Вот пример, который склеивает все свои аргументы (разумеется, кроме nil-ов) в одну строку:

Когда пойдет разговор о таблицах, мы ещё вспомним этот пример и реализуем эту же функцию иначе. Но вернемся к нашему многоточию. В нашем примере мы заменили им все аргументы функции. Разумеется, это не всегда удобно, поэтому есть возможность использовать и такие конструкции:

Подобные описания функций можно применять, когда некоторые параметры имеют для нас особое значение, а некоторые в известном смысле одинаковые и нам не очень важно, кто из них первый кто последний. Наш последний пример выведет вот что:

Обратите внимание, что нумерация аргументов функции в этом случае остаётся прежней: arg[1] - это первый "динамический" параметр, а не параметр prefix. Поставить многоточие перед именованными аргументами синтаксис Lua, разумеется, запрещает - в этом случае невозможно было бы определить количество динамических и обычных параметров.

Параметры (аргументы) командной строки

Раз уж мы затронули вопрос аргументов функций, уместно тут же заметить, что при старте скрипта массив arg заполняется параметрами командной строки, переданными нашему скрипту. Тут наблюдается полная аналогия с C/C++ и необязательными аргументами функции main(int argc, char**argv). Вот примерчик, демонстрирующий их использование:

Если Вы запустите этот скрипт консольным интерпретатором Lua, Вы увидите примерно следующее (само собой, вид приглашения командной строки будет у вас другим):

Возвращаемые значения функции и оператор return

В отличие от многих других языков, в Lua возвращаемых значений у функции может быть много, и при этом не надо их оформлять в виде какой-нибудь специальной структуры. Просто пишите их через запятую, и в том же порядке присваивайте. Например, напишем функцию, которая возвращает сразу и частное, и остаток от деления двух чисел. Она будет очень простая и будет состоять из единственной интересующей нас строчки с return-ом.

Я думаю, что тут происходит - и так понятно. Для полной ясности остаётся лишь сказать, что math.floor возвращает целую часть числа, округленную вниз.

Разумеется, если нам нужен только один параметр (скажем, частное), можно написать так:

А если нужен только остаток, первый параметр нужно будет тоже куда-то присвоить. Для этого очень часто используют переменную с именем "_":

Выглядит может быть слегка коряво, но этот приём (и именно такое имя переменной) очень часто применяется в реально существующих проектах на Lua, поэтому изобретать что-то оригинальное в данном случае не хочется. Если Вам нужно добраться до третьего занчения, никто не мешает использовать "мусорную" переменную дважды:

Проницательный читатель скорее всего уже догадался, что если функция возвращает меньше параметров, чем мы написали в присвоении, последние (недостающие) будут заполнены значением nil. Никаких ошибок вам интерпретатор при этом не выдаст, а молчаливо сделает то, что Вы ему сказали. В нижеследующем примере сначала напечатается "1 2 3", а потом "5 nil nil":

Разумеется, количество возвращаемых значений и их типы могут быть непостоянными. Следующий пример может показаться слегка бредовым, но тем не менее любопытным. В нем будет функция, которая возвращает переданный параметр "как есть", если он строковый, а если передали число - возвращает его же, преобразованное в строковый формат с выравниванием на 10 символов, и второе значение "true" как флаг осущественной конвертации:

Кстати, обратите внимание на последнюю строчку. Там вызывается наша функция Convert без параметров, хотя по идее должна принимать один параметр. Неужели интерпретатор на это ругнется? Конечно же нет! Функция будет вызвана, вот только параметр будет равен nil. В соответствии с тем, что написано в нашей функции, последней строкой будет напечатано "Bug in your code!".

Прочие особенности вызова функций

В Lua допустимы конструкции следующего вида: пусть у вас есть функция, которая принимает (например) два параметра, и вторая функция, которая возвращает два параметра. Можно использовать такую запись:

Программа напечатает false, поскольку наши переменные будут сначала поменяны местами.

Вышеописанный приём можно применять, если "внутренняя" функция (exchange в нашем примере) стоит на последнем месте в списке параметров. Если это не так - из нее будет взят только один параметр. В следующем примере одна из строчек программы выполнится правильно, а вторая сломается на арифметической операции:

Передача параметров по ссылке и по значению

Обычные типы (строки, числа, логические переменные) в Lua передаются в функции по значению (то есть как обычно). Параметр такого типа является локальной переменной внутри функции, его можно менять и при этом значение той переменной, которую мы передавали в функцию, не изменится. Следующий пример это подтверждает:

Здесь будут напечатаны именно те значения, которые были изначально присвоены этим переменным. Но есть и другие типы, для которых всё вышесказанное неверно. Среди тех, про которые мы уже что-то знаем, - это таблицы и функции. Есть ещё два типа, про которые пока мне говорить не хочется, чтобы не пугать читателя - с ними мы познакомимся позже.