Lua - Краткое руководство
Lua - это расширяемый, легкий язык программирования, написанный на C. Он начался как собственный проект в 1993 году Роберто Ирусалимши, Луис Энрике де Фигейредо и Вальдемар Селес.
С самого начала он был разработан как программное обеспечение, которое можно интегрировать с кодом, написанным на C и других традиционных языках. Эта интеграция дает много преимуществ. Он не пытается делать то, что уже может сделать C, но стремится предложить то, в чем C не хорош: хорошее расстояние от оборудования, динамические структуры, отсутствие избыточности, простота тестирования и отладки. Для этого в Lua есть безопасная среда, автоматическое управление памятью и хорошие средства для обработки строк и других типов данных с динамическим размером.
Особенности
Lua предоставляет набор уникальных функций, которые отличают его от других языков. К ним относятся -
- Extensible
- Simple
- Efficient
- Portable
- Бесплатно и открыто
Пример кода
print("Hello World!")
Как реализован Lua?
Lua состоит из двух частей - интерпретатора Lua и действующей программной системы. Функционирующая программная система - это реальное компьютерное приложение, которое может интерпретировать программы, написанные на языке программирования Lua. Интерпретатор Lua написан на ANSI C, поэтому он очень портативен и может работать на широком спектре устройств, от высокопроизводительных сетевых серверов до небольших устройств.
И язык Lua, и его интерпретатор зрелые, маленькие и быстрые. Он произошел от других языков программирования и высших стандартов программного обеспечения. Небольшой размер позволяет ему работать на небольших устройствах с небольшим объемом памяти.
Изучение Lua
Самый важный момент при изучении Lua - сосредоточиться на концепциях, не теряясь в технических деталях.
Цель изучения языка программирования - стать лучшим программистом; то есть стать более эффективными в разработке и внедрении новых систем и в обслуживании старых.
Некоторые варианты использования Lua
Программирование игр
Создание сценариев в автономных приложениях
Сценарии в сети
Расширения и надстройки для таких баз данных, как MySQL Proxy и MySQL WorkBench
Системы безопасности, такие как система обнаружения вторжений.
Настройка локальной среды
Если вы все еще хотите настроить свою среду для языка программирования Lua, вам понадобится следующее программное обеспечение, доступное на вашем компьютере - (а) текстовый редактор, (б) интерпретатор Lua и (в) компилятор Lua.
Текстовый редактор
Вам понадобится текстовый редактор, чтобы напечатать вашу программу. Примеры нескольких редакторов включают Блокнот Windows, команду редактирования ОС, Brief, Epsilon, EMACS и vim или vi.
Название и версия текстового редактора могут различаться в разных операционных системах. Например, Блокнот будет использоваться в Windows, а vim или vi можно использовать в Windows, а также в Linux или UNIX.
Файлы, которые вы создаете с помощью своего редактора, называются исходными файлами, и эти файлы содержат исходный код программы. Исходные файлы для программ Lua обычно называются с расширением".lua".
Интерпретатор Lua
Это всего лишь небольшая программа, которая позволяет вам набирать команды Lua и сразу же запускать их. Он останавливает выполнение файла Lua в случае возникновения ошибки, в отличие от компилятора, который выполняется полностью.
Компилятор Lua
Когда мы расширяем Lua на другие языки / приложения, нам понадобится комплект разработки программного обеспечения с компилятором, совместимым с интерфейсом прикладных программ Lua.
Установка в Windows
Для среды Windows разработана отдельная IDE под названием «SciTE», которую можно загрузить с https://code.google.com/p/luaforwindows/ раздел загрузки.
Запустите загруженный исполняемый файл, чтобы установить Lua IDE.
Поскольку это IDE, вы можете создавать и собирать код Lua, используя то же самое.
В случае, если вы заинтересованы в установке Lua в режиме командной строки, вам необходимо установить MinGW или Cygwin, а затем скомпилировать и установить Lua в Windows.
Установка в Linux
Чтобы загрузить и собрать Lua, используйте следующую команду -
$ wget http://www.lua.org/ftp/lua-5.2.3.tar.gz $ tar zxf lua-5.2.3.tar.gz
$ cd lua-5.2.3 $ make linux test
Чтобы установить на другие платформы, такие как aix, ansi, bsd, generic linux, mingw, posix, solaris, заменив Linux в make Linux, проверьте с соответствующим именем платформы.
У нас есть helloWorld.lua в Lua следующим образом:
print("Hello World!")
Теперь мы можем создать и запустить файл Lua, скажем helloWorld.lua, переключившись на папку, содержащую файл, с помощью cd, а затем используя следующую команду -
$ lua helloWorld
Мы видим следующий результат.
Hello World!
Установка в Mac OS X
Чтобы собрать / протестировать Lua в Mac OS X, используйте следующую команду -
$ curl -R -O http://www.lua.org/ftp/lua-5.2.3.tar.gz
$ tar zxf lua-5.2.3.tar.gz $ cd lua-5.2.3
$ make macosx test
В некоторых случаях вы могли не установить инструменты Xcode и командной строки. В таких случаях вы не сможете использовать команду make. Установите Xcode из магазина приложений Mac. Затем перейдите в «Настройки Xcode», затем переключитесь в «Загрузки» и установите компонент с именем «Инструменты командной строки». После завершения процесса вам будет доступна команда make.
Вы не обязаны выполнять оператор make macosx test. Даже не выполнив эту команду, вы все равно можете использовать Lua в Mac OS X.
У нас есть helloWorld.lua в Lua, а именно:
print("Hello World!")
Теперь мы можем создать и запустить файл Lua, скажем helloWorld.lua, переключившись в папку, содержащую файл, с помощью cd, а затем используя следующую команду -
$ lua helloWorld
Мы видим следующий результат -
Hello World!
Lua IDE
Как упоминалось ранее, для Windows SciTE Lua IDE - это IDE по умолчанию, предоставляемая командой разработчиков Lua. Доступна альтернативная IDE от ZeroBrane Studio, которая доступна на нескольких платформах, таких как Windows, Mac и Linux.
Также существуют плагины для eclipse, которые позволяют разрабатывать Lua. Использование IDE упрощает разработку с такими функциями, как автозавершение кода, и настоятельно рекомендуется. IDE также обеспечивает программирование в интерактивном режиме, аналогичное версии Lua для командной строки.
Приступим к созданию нашей первой программы на Lua!
Первая программа на Lua
Программирование в интерактивном режиме
Lua предоставляет режим, называемый интерактивным режимом. В этом режиме вы можете вводить инструкции одну за другой и мгновенно получать результаты. Это можно вызвать в оболочке с помощью lua -i или просто команды lua. Как только вы введете это, нажмите Enter, и интерактивный режим запустится, как показано ниже.
$ lua -i $ Lua 5.1.4 Copyright (C) 1994-2008 Lua.org, PUC-Rio
quit to end; cd, dir and edit also available
Вы можете распечатать что-нибудь, используя следующий оператор -
print("test")
После того, как вы нажмете Enter, вы получите следующий результат -
test
Программирование режима по умолчанию
Вызов интерпретатора с параметром имени файла Lua начинает выполнение файла и продолжается до завершения сценария. Когда сценарий завершен, интерпретатор больше не активен.
Напишем простую программу на Lua. Все файлы Lua будут иметь расширение .lua. Поэтому поместите следующий исходный код в файл test.lua.
print("test")
Предполагая, что среда lua настроена правильно, давайте запустим программу, используя следующий код -
$ lua test.lua
Мы получим следующий результат -
test
Давайте попробуем другой способ выполнить программу Lua. Ниже приведен модифицированный файл test.lua -
#!/usr/local/bin/lua
print("test")
Здесь мы предположили, что у вас есть интерпретатор Lua, доступный в вашем каталоге / usr / local / bin. Первая строка игнорируется интерпретатором, если она начинается со знака #. Теперь попробуйте запустить эту программу следующим образом -
$ chmod a+rx test.lua
$./test.lua
Мы получим следующий результат.
test
Давайте теперь посмотрим на основную структуру программы Lua, чтобы вам было легко понять основные строительные блоки языка программирования Lua.
Токены в Lua
Программа Lua состоит из различных токенов, и токен представляет собой ключевое слово, идентификатор, константу, строковый литерал или символ. Например, следующий оператор Lua состоит из трех токенов -
io.write("Hello world, from ",_VERSION,"!\n")
Отдельные токены -
io.write
(
"Hello world, from ",_VERSION,"!\n"
)
Комментарии
Комментарии похожи на вспомогательный текст в вашей программе Lua, и интерпретатор игнорирует их. Они начинаются с - [[и заканчиваются символами -]], как показано ниже -
--[[ my first program in Lua --]]
Идентификаторы
Идентификатор Lua - это имя, используемое для идентификации переменной, функции или любого другого определяемого пользователем элемента. Идентификатор начинается с буквы «от A до Z» или от «от a до z» или символа подчеркивания «_», за которым следует ноль или более букв, подчеркиваний и цифр (от 0 до 9).
Lua не допускает символов пунктуации, таких как @, $ и%, в идентификаторах. Lua - этоcase sensitiveязык программирования. Таким образом, рабочая сила и рабочая сила - это два разных идентификатора в Lua. Вот несколько примеров приемлемых идентификаторов -
mohd zara abc move_name a_123
myname50 _temp j a23b9 retVal
Ключевые слова
В следующем списке показаны несколько зарезервированных слов в Lua. Эти зарезервированные слова нельзя использовать в качестве констант, переменных или любых других имен идентификаторов.
и | сломать | делать | еще |
elseif | конец | ложный | за |
функция | если | в | местный |
ноль | не | или же | повторение |
возвращение | тогда | правда | до того как |
в то время как |
Пробелы в Lua
Строка, содержащая только пробелы, возможно, с комментарием, называется пустой строкой, и интерпретатор Lua полностью игнорирует ее.
Пробел - это термин, используемый в Lua для описания пробелов, табуляции, символов новой строки и комментариев. Пробел отделяет одну часть оператора от другой и позволяет интерпретатору определить, где заканчивается один элемент в операторе, например int, и начинается следующий элемент. Следовательно, в следующем заявлении -
local age
Между local и age должен быть хотя бы один пробел (обычно пробел), чтобы интерпретатор мог их различить. С другой стороны, в следующем заявлении -
fruit = apples + oranges --get the total fruit
Пробелы между фруктами и = или между = и яблоками не требуются, хотя вы можете включить некоторые из них, если хотите для удобства чтения.
Переменная - это не что иное, как имя, присвоенное области памяти, которой могут управлять наши программы. Он может содержать различные типы значений, включая функции и таблицы.
Имя переменной может состоять из букв, цифр и символа подчеркивания. Он должен начинаться с буквы или символа подчеркивания. Буквы верхнего и нижнего регистра различны, потому что Lua чувствителен к регистру. В Lua есть восемь основных типов значений:
В Lua, хотя у нас нет типов данных переменных, у нас есть три типа в зависимости от области видимости переменной.
Global variables - Все переменные считаются глобальными, если явно не объявлены как локальные.
Local variables - Когда тип указан как локальный для переменной, его область действия ограничивается функциями внутри их области действия.
Table fields - Это особый тип переменных, которые могут содержать все, кроме nil, включая функции.
Определение переменной в Lua
Определение переменной означает указание интерпретатору, где и сколько создать хранилище для переменной. Определение переменной имеет необязательный тип и содержит список из одной или нескольких переменных этого типа следующим образом:
type variable_list;
Вот, type необязательно является локальным или определенным типом, что делает его глобальным, и variable_listможет состоять из одного или нескольких имен идентификаторов, разделенных запятыми. Здесь показаны некоторые действительные декларации -
local i, j
local i
local a,c
Линия local i, jоба объявляют и определяют переменные i и j; который инструктирует интерпретатор создавать переменные с именами i, j и ограничивает область видимости локальной.
Переменные можно инициализировать (присвоить начальное значение) в их объявлении. Инициализатор состоит из знака равенства, за которым следует постоянное выражение:
type variable_list = value_list;
Вот несколько примеров -
local d , f = 5 ,10 --declaration of d and f as local variables.
d , f = 5, 10; --declaration of d and f as global variables.
d, f = 10 --[[declaration of d and f as global variables.
Here value of f is nil --]]
Для определения без инициализатора: переменные со статической продолжительностью хранения неявно инициализируются значением nil.
Объявление переменной в Lua
Как вы можете видеть в приведенных выше примерах, присвоения множественным переменным следуют формату variable_list и value_list. В приведенном выше примереlocal d, f = 5,10 у нас есть d и f в variable_list и 5 и 10 в списке значений.
Присвоение значений в Lua происходит как первая переменная в variable_list с первым значением в value_list и так далее. Следовательно, значение d равно 5, а значение f равно 10.
пример
Попробуйте следующий пример, где переменные были объявлены вверху, но они были определены и инициализированы внутри основной функции:
-- Variable definition:
local a, b
-- Initialization
a = 10
b = 30
print("value of a:", a)
print("value of b:", b)
-- Swapping of variables
b, a = a, b
print("value of a:", a)
print("value of b:", b)
f = 70.0/3.0
print("value of f", f)
Когда приведенный выше код построен и выполняется, он дает следующий результат:
value of a: 10
value of b: 30
value of a: 30
value of b: 10
value of f 23.333333333333
Lvalues и Rvalues в Lua
В Lua есть два вида выражений:
lvalue- Выражение, относящееся к области памяти, называется выражением «lvalue». Lvalue может отображаться как левая или правая часть присваивания.
rvalue- Термин rvalue относится к значению данных, которое хранится по некоторому адресу в памяти. Rvalue - это выражение, которому не может быть присвоено значение, что означает, что rvalue может отображаться справа, но не слева от присваивания.
Переменные - это lvalue, поэтому они могут появляться в левой части присваивания. Числовые литералы являются r-значениями, поэтому не могут быть присвоены и не могут отображаться в левой части. Ниже приводится действительное заявление -
g = 20
Но следующее не является допустимым заявлением и приведет к ошибке времени сборки:
10 = 20
В языке программирования Lua, помимо вышеперечисленных типов присваивания, можно иметь несколько lvalue и rvalue в одном и том же операторе. Это показано ниже.
g,l = 20,30
В приведенном выше утверждении 20 присваивается g, а 30 - l.
Lua - это язык с динамической типизацией, поэтому переменные не имеют типов, только значения имеют типы. Значения можно сохранять в переменных, передавать как параметры и возвращать как результаты.
В Lua, хотя у нас нет типов данных переменных, но у нас есть типы для значений. Список типов данных для значений приведен ниже.
Старший Нет | Тип значения и описание |
---|---|
1 | nil Используется, чтобы отличать значение от наличия некоторых данных или отсутствия (нулевых) данных. |
2 | boolean Включает в себя значения true и false. Обычно используется для проверки условий. |
3 | number Представляет действительные числа (с плавающей запятой двойной точности). |
4 | string Представляет массив символов. |
5 | function Представляет метод, написанный на C или Lua. |
6 | userdata Представляет произвольные данные C. |
7 | thread Представляет независимые потоки выполнения и используется для реализации сопрограмм. |
8 | table Представляет обычные массивы, таблицы символов, наборы, записи, графики, деревья и т. Д. И реализует ассоциативные массивы. Может содержать любое значение (кроме nil). |
Тип Функция
В Lua есть функция под названием 'type', которая позволяет нам узнать тип переменной. Некоторые примеры приведены в следующем коде.
print(type("What is my type")) --> string
t = 10
print(type(5.8*t)) --> number
print(type(true)) --> boolean
print(type(print)) --> function
print(type(nil)) --> nil
print(type(type(ABC))) --> string
Когда вы создаете и выполняете вышеуказанную программу, она дает следующий результат в Linux:
string
number
boolean
function
nil
string
По умолчанию все переменные будут указывать на ноль, пока им не будет присвоено значение или они не будут инициализированы. В Lua нулевые и пустые строки считаются истинными в случае проверки условий. Следовательно, вы должны быть осторожны при использовании логических операций. Мы узнаем больше об этих типах в следующих главах.
Оператор - это символ, который указывает интерпретатору выполнять определенные математические или логические операции. Язык Lua богат встроенными операторами и предоставляет следующие типы операторов:
- Арифметические операторы
- Операторы отношения
- Логические операторы
- Разные операторы
В этом руководстве по порядку будут объяснены арифметические, реляционные, логические и другие разные операторы.
Арифметические операторы
В следующей таблице показаны все арифметические операторы, поддерживаемые языком Lua. Предположим переменнуюA содержит 10 и переменную B держит 20, тогда -
Показать примеры
Оператор | Описание | пример |
---|---|---|
+ | Добавляет два операнда | A + B даст 30 |
- | Вычитает второй операнд из первого | A - B даст -10 |
* | Умножьте оба операнда | A * B даст 200 |
/ | Разделите числитель на де-числитель | Б / А даст 2 |
% | Оператор модуля и остаток после целочисленного деления | B% A даст 0 |
^ | Оператор экспоненты принимает экспоненты | ^ 2 даст 100 |
- | Унарный - оператор действует как отрицание | -A даст -10 |
Операторы отношения
В следующей таблице показаны все операторы отношения, поддерживаемые языком Lua. Предположим переменнуюA содержит 10 и переменную B держит 20, тогда -
Показать примеры
Оператор | Описание | пример |
---|---|---|
== | Проверяет, равны ли значения двух операндов или нет, если да, то условие становится истинным. | (A == B) неверно. |
~ = | Проверяет, равны ли значения двух операндов или нет, если значения не равны, условие становится истинным. | (A ~ = B) верно. |
> | Проверяет, больше ли значение левого операнда, чем значение правого операнда, если да, то условие становится истинным. | (A> B) неверно. |
< | Проверяет, меньше ли значение левого операнда, чем значение правого операнда, если да, то условие становится истинным. | (A <B) верно. |
> = | Проверяет, больше ли значение левого операнда или равно значению правого операнда, если да, то условие становится истинным. | (A> = B) неверно. |
<= | Проверяет, меньше ли значение левого операнда или равно значению правого операнда, если да, то условие становится истинным. | (A <= B) верно. |
Логические операторы
В следующей таблице показаны все логические операторы, поддерживаемые языком Lua. Предположим переменнуюA верно и изменчиво B тогда ложь -
Показать примеры
Оператор | Описание | пример |
---|---|---|
и | Вызывается логическим оператором И. Если оба операнда не равны нулю, условие становится истинным. | (A и B) ложно. |
или же | Вызывается логическим оператором ИЛИ. Если любой из двух операндов не равен нулю, условие становится истинным. | (A или B) верно. |
не | Вызывается оператором логического НЕ. Используется для изменения логического состояния операнда на обратное. Если условие истинно, то оператор логического НЕ сделает ложным. | ! (A и B) верно. |
Разные операторы
Разные операторы, поддерживаемые Lua Language, включают concatenation и length.
Показать примеры
Оператор | Описание | пример |
---|---|---|
.. | Объединяет две строки. | a..b, где a - это «Hello», а b - «World», вернет «Hello World». |
# | Унарный оператор, возвращающий длину строки или таблицы. | # "Привет" вернет 5 |
Приоритет операторов в Lua
Приоритет оператора определяет группировку терминов в выражении. Это влияет на то, как оценивается выражение. Некоторые операторы имеют более высокий приоритет, чем другие; например, оператор умножения имеет более высокий приоритет, чем оператор сложения -
Например, x = 7 + 3 * 2; Здесь x присваивается 13, а не 20, потому что оператор * имеет более высокий приоритет, чем +, поэтому он сначала умножается на 3 * 2, а затем складывается в 7.
Здесь операторы с наивысшим приоритетом отображаются вверху таблицы, а операторы с самым низким - внизу. Внутри выражения в первую очередь будут оцениваться операторы с более высоким приоритетом.
Показать примеры
Категория | Оператор | Ассоциативность |
---|---|---|
Унарный | не # - | Справа налево |
Конкатенация | .. | Справа налево |
Мультипликативный | * /% | Слева направо |
Добавка | + - | Слева направо |
Реляционный | <> <=> = == ~ = | Слева направо |
Равенство | == ~ = | Слева направо |
Логическое И | и | Слева направо |
Логическое ИЛИ | или же | Слева направо |
Может возникнуть ситуация, когда вам нужно выполнить блок кода несколько раз. Как правило, операторы выполняются последовательно: сначала выполняется первый оператор функции, затем второй и т. Д.
Языки программирования предоставляют различные структуры управления, которые позволяют использовать более сложные пути выполнения.
Оператор цикла позволяет нам выполнять оператор или группу операторов несколько раз. Ниже приведена общая форма оператора цикла на большинстве языков программирования.
Lua предоставляет следующие типы циклов для обработки требований цикла.
Sr.No. | Тип и описание петли |
---|---|
1 | пока цикл Повторяет утверждение или группу утверждений, пока выполняется заданное условие. Он проверяет условие перед выполнением тела цикла. |
2 | для цикла Выполняет последовательность операторов несколько раз и сокращает код, управляющий переменной цикла. |
3 | повторять ... до петли Повторяет операцию группы операторов до тех пор, пока не будет выполнено условие. |
4 | вложенные циклы Вы можете использовать один или несколько циклов внутри любого другого цикла while, for или do.. while. |
Заявление об управлении циклом
Оператор управления циклом изменяет выполнение обычной последовательности. Когда выполнение покидает область действия, все автоматические объекты, созданные в этой области, уничтожаются.
Lua поддерживает следующие управляющие операторы.
Sr.No. | Положение и описание управления |
---|---|
1 | заявление о прерывании Прекращает loop и передает выполнение оператору, следующему сразу за циклом или переключателем. |
Бесконечный цикл
Цикл становится бесконечным, если условие никогда не становится ложным. Вwhileпетля часто используется для этой цели. Поскольку мы прямо указываем истину для условия, оно продолжает выполняться вечно. Мы можем использовать оператор break, чтобы прервать этот цикл.
while( true )
do
print("This loop will run forever.")
end
Структуры принятия решений требуют, чтобы программист указал одно или несколько условий, которые должны быть оценены или протестированы программой, вместе с оператором или операторами, которые должны быть выполнены, если условие определено как истинное, и, необязательно, другие операторы, которые должны быть выполнены, если условие определено как ложное.
Ниже приводится общая форма типичной структуры принятия решений, встречающейся в большинстве языков программирования.
Язык программирования Lua предполагает любую комбинацию логических true и non-nil ценности как true, и если оно логическое false или же nil, то предполагается, что falseзначение. Следует отметить, что в Luazero will be considered as true.
Язык программирования Lua предоставляет следующие типы операторов принятия решений.
Sr.No. | Заявление и описание |
---|---|
1 | если заявление Если заявление состоит из логического выражения следует один или более операторов. |
2 | если ... еще заявление За оператором if может следовать необязательный оператор else , который выполняется, когда логическое выражение ложно. |
3 | вложенные операторы if Вы можете использовать один оператор if или else if внутри другого оператора if или else if . |
Функция - это группа операторов, которые вместе выполняют задачу. Вы можете разделить свой код на отдельные функции. Как разделить код между различными функциями - решать вам, но логически разделение обычно уникально, поэтому каждая функция выполняет определенную задачу.
Язык Lua предоставляет множество встроенных методов, которые может вызывать ваша программа. Например, методprint() чтобы напечатать аргумент, переданный как ввод в консоли.
Функция известна под разными именами, такими как метод, подпрограмма, процедура и т. Д.
Определение функции
Общая форма определения метода на языке программирования Lua следующая:
optional_function_scope function function_name( argument1, argument2, argument3........,
argumentn)
function_body
return result_params_comma_separated
end
Определение метода на языке программирования Lua состоит из заголовка метода и тела метода . Вот все части метода -
Optional Function Scope- Вы можете использовать ключевое слово local, чтобы ограничить область действия функции или игнорировать раздел области действия, что сделает ее глобальной функцией.
Function Name- Это настоящее имя функции. Имя функции и список параметров вместе составляют сигнатуру функции.
Arguments- Аргумент похож на заполнитель. Когда функция вызывается, вы передаете значение аргументу. Это значение называется фактическим параметром или аргументом. Список параметров относится к типу, порядку и количеству аргументов метода. Аргументы необязательны; то есть метод может не содержать аргументов.
Function Body - Тело метода содержит набор операторов, которые определяют, что делает метод.
Return - В Lua можно возвращать несколько значений, следуя ключевому слову return с возвращаемыми значениями, разделенными запятыми.
пример
Ниже приведен исходный код функции с именем max(). Эта функция принимает два параметра num1 и num2 и возвращает максимум между двумя -
--[[ function returning the max between two numbers --]]
function max(num1, num2)
if (num1 > num2) then
result = num1;
else
result = num2;
end
return result;
end
Аргументы функции
Если функция должна использовать аргументы, она должна объявить переменные, которые принимают значения аргументов. Эти переменные называютсяformal parameters функции.
Формальные параметры ведут себя как другие локальные переменные внутри функции и создаются при входе в функцию и уничтожаются при выходе.
Вызов функции
При создании функции Lua вы даете определение того, что функция должна делать. Чтобы использовать метод, вам нужно будет вызвать эту функцию для выполнения определенной задачи.
Когда программа вызывает функцию, управление программой передается вызываемой функции. Вызываемая функция выполняет определенную задачу, и когда выполняется ее оператор return или когда достигается конец ее функции, она возвращает управление программой обратно в основную программу.
Чтобы вызвать метод, вам просто нужно передать необходимые параметры вместе с именем метода, и если метод возвращает значение, вы можете сохранить возвращенное значение. Например -
function max(num1, num2)
if (num1 > num2) then
result = num1;
else
result = num2;
end
return result;
end
-- calling a function
print("The maximum of the two numbers is ",max(10,4))
print("The maximum of the two numbers is ",max(5,6))
Когда мы запустим приведенный выше код, мы получим следующий результат.
The maximum of the two numbers is 10
The maximum of the two numbers is 6
Назначение и передача функций
В Lua мы можем назначать функцию переменным, а также передавать их как параметры другой функции. Вот простой пример назначения и передачи функции в качестве параметра в Lua.
myprint = function(param)
print("This is my print function - ##",param,"##")
end
function add(num1,num2,functionPrint)
result = num1 + num2
functionPrint(result)
end
myprint(10)
add(2,5,myprint)
Когда мы запустим приведенный выше код, мы получим следующий результат.
This is my print function - ## 10 ##
This is my print function - ## 7 ##
Функция с переменным аргументом
В Lua можно создавать функции с переменными аргументами, используя в качестве параметра '...'. Мы можем понять это, посмотрев пример, в котором функция возвращает среднее значение и может принимать переменные аргументы.
function average(...)
result = 0
local arg = {...}
for i,v in ipairs(arg) do
result = result + v
end
return result/#arg
end
print("The average is",average(10,5,3,4,5,6))
Когда мы запустим приведенный выше код, мы получим следующий результат.
The average is 5.5
Строка - это последовательность символов, а также управляющих символов, таких как подача формы. Строка может быть инициализирована тремя формами, включая:
- Символы между одинарными кавычками
- Символы между двойными кавычками
- Символы между [[и]]
Пример для трех вышеуказанных форм показан ниже.
string1 = "Lua"
print("\"String 1 is\"",string1)
string2 = 'Tutorial'
print("String 2 is",string2)
string3 = [["Lua Tutorial"]]
print("String 3 is",string3)
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
"String 1 is" Lua
String 2 is Tutorial
String 3 is "Lua Tutorial"
Символы escape-последовательности используются в строке, чтобы изменить обычную интерпретацию символов. Например, чтобы напечатать двойные кавычки (""), мы использовали \ "в приведенном выше примере. Управляющая последовательность и ее использование перечислены ниже в таблице.
Последовательность побега | Использовать |
---|---|
\ а | Колокол |
\ b | Backspace |
\ f | Formfeed |
\ п | Новая линия |
\р | Возврат каретки |
\ т | Вкладка |
\ v | Вертикальная табуляция |
\\ | Обратная косая черта |
\ " | Двойные кавычки |
\ ' | Одинарные кавычки |
\ [ | Левая квадратная скобка |
\] | Правая квадратная скобка |
Манипуляции со строками
Lua поддерживает строку для управления строками -
Sr.No. | Метод и цель |
---|---|
1 | string.upper(argument) Возвращает аргумент в виде заглавной буквы. |
2 | string.lower(argument) Возвращает аргумент в нижнем регистре. |
3 | string.gsub(mainString,findString,replaceString) Возвращает строку, заменяя вхождения findString на replaceString. |
4 | string.find(mainString,findString, optionalStartIndex,optionalEndIndex) Возвращает начальный и конечный индексы findString в основной строке и nil, если не найден. |
5 | string.reverse(arg) Возвращает строку, меняя местами символы переданной строки. |
6 | string.format(...) Возвращает отформатированную строку. |
7 | string.char(arg) and string.byte(arg) Возвращает внутреннее числовое и символьное представление входного аргумента. |
8 | string.len(arg) Возвращает длину переданной строки. |
9 | string.rep(string, n)) Возвращает строку, повторяя одну и ту же строку n количество раз. |
10 | .. Таким образом оператор объединяет две строки. |
Теперь давайте рассмотрим несколько примеров, чтобы точно увидеть, как ведут себя эти функции обработки строк.
Обработка случаев
Ниже приводится пример кода для преобразования строк в верхний и нижний регистр.
string1 = "Lua";
print(string.upper(string1))
print(string.lower(string1))
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
LUA
lua
Замена подстроки
Ниже приведен пример кода для замены вхождений одной строки другой.
string = "Lua Tutorial"
-- replacing strings
newstring = string.gsub(string,"Tutorial","Language")
print("The new string is "..newstring)
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
The new string is Lua Language
Обнаружение и обращение
Ниже приведен пример кода для поиска индекса подстроки и реверсивной строки.
string = "Lua Tutorial"
-- replacing strings
print(string.find(string,"Tutorial"))
reversedString = string.reverse(string)
print("The new string is",reversedString)
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
5 12
The new string is lairotuT auL
Форматирование строк
Часто в нашем программировании нам может понадобиться напечатать строки в отформатированном виде. Вы можете использовать функцию string.format для форматирования вывода, как показано ниже.
string1 = "Lua"
string2 = "Tutorial"
number1 = 10
number2 = 20
-- Basic string formatting
print(string.format("Basic formatting %s %s",string1,string2))
-- Date formatting
date = 2; month = 1; year = 2014
print(string.format("Date formatting %02d/%02d/%03d", date, month, year))
-- Decimal formatting
print(string.format("%.4f",1/3))
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
Basic formatting Lua Tutorial
Date formatting 02/01/2014
0.3333
Представления символов и байтов
Пример кода для символьного и байтового представления, который используется для преобразования строки из строкового во внутреннее представление и наоборот.
-- Byte conversion
-- First character
print(string.byte("Lua"))
-- Third character
print(string.byte("Lua",3))
-- first character from last
print(string.byte("Lua",-1))
-- Second character
print(string.byte("Lua",2))
-- Second character from last
print(string.byte("Lua",-2))
-- Internal Numeric ASCII Conversion
print(string.char(97))
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
76
97
97
117
117
a
Другие общие функции
Обычные манипуляции со строками включают конкатенацию строк, определение длины строки и иногда повторение одной и той же строки несколько раз. Пример этих операций приведен ниже.
string1 = "Lua"
string2 = "Tutorial"
-- String Concatenations using ..
print("Concatenated string",string1..string2)
-- Length of string
print("Length of string1 is ",string.len(string1))
-- Repeating strings
repeatedString = string.rep(string1,3)
print(repeatedString)
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
Concatenated string LuaTutorial
Length of string1 is 3
LuaLuaLua
Массивы - это упорядоченное расположение объектов, которое может быть одномерным массивом, содержащим набор строк, или многомерным массивом, содержащим несколько строк и столбцов.
В Lua массивы реализованы с использованием таблиц индексации с целыми числами. Размер массива не является фиксированным и может увеличиваться в зависимости от наших требований с учетом ограничений памяти.
Одномерный массив
Одномерный массив может быть представлен с использованием простой структуры таблицы и может быть инициализирован и прочитан с помощью простого forпетля. Пример показан ниже.
array = {"Lua", "Tutorial"}
for i = 0, 2 do
print(array[i])
end
Когда мы запустим приведенный выше код, мы получим следующий результат.
nil
Lua
Tutorial
Как вы можете видеть в приведенном выше коде, когда мы пытаемся получить доступ к элементу в индексе, которого нет в массиве, он возвращает nil. В Lua индексация обычно начинается с индекса 1. Но также можно создавать объекты с индексом 0 и ниже 0. Массив с отрицательными индексами показан ниже, где мы инициализируем массив с помощью цикла for .
array = {}
for i= -2, 2 do
array[i] = i *2
end
for i = -2,2 do
print(array[i])
end
Когда мы запустим приведенный выше код, мы получим следующий результат.
-4
-2
0
2
4
Многомерный массив
Многомерные массивы можно реализовать двумя способами.
- Массив массивов
- Одномерный массив путем манипулирования индексами
Пример многомерного массива из 3,3 показан ниже с использованием массива массивов.
-- Initializing the array
array = {}
for i=1,3 do
array[i] = {}
for j=1,3 do
array[i][j] = i*j
end
end
-- Accessing the array
for i=1,3 do
for j=1,3 do
print(array[i][j])
end
end
Когда мы запустим приведенный выше код, мы получим следующий результат.
1
2
3
2
4
6
3
6
9
Ниже показан пример многомерного массива с использованием управляющих индексов.
-- Initializing the array
array = {}
maxRows = 3
maxColumns = 3
for row=1,maxRows do
for col=1,maxColumns do
array[row*maxColumns +col] = row*col
end
end
-- Accessing the array
for row=1,maxRows do
for col=1,maxColumns do
print(array[row*maxColumns +col])
end
end
Когда мы запустим приведенный выше код, мы получим следующий результат.
1
2
3
2
4
6
3
6
9
Как видно из приведенного выше примера, данные хранятся на основе индексов. Можно разместить элементы разреженным образом, и именно так работает реализация матрицы в Lua. Поскольку он не хранит нулевые значения в Lua, можно сэкономить много памяти без каких-либо специальных методов в Lua по сравнению со специальными методами, используемыми в других языках программирования.
Итератор - это конструкция, которая позволяет вам перемещаться по элементам так называемой коллекции или контейнера. В Lua эти коллекции часто относятся к таблицам, которые используются для создания различных структур данных, таких как массив.
Generic для итератора
Общий для итератора предоставляет пары ключ-значение для каждого элемента в коллекции. Ниже приводится простой пример.
array = {"Lua", "Tutorial"}
for key,value in ipairs(array)
do
print(key, value)
end
Когда мы запустим приведенный выше код, мы получим следующий вывод -
1 Lua
2 Tutorial
В приведенном выше примере используется функция итератора ipairs по умолчанию, предоставляемая Lua.
В Lua мы используем функции для представления итераторов. Основываясь на поддержании состояния в этих функциях итератора, у нас есть два основных типа:
- Итераторы без сохранения состояния
- Итераторы с отслеживанием состояния
Итераторы без сохранения состояния
По самому названию мы можем понять, что этот тип функции итератора не сохраняет никакого состояния.
Давайте теперь посмотрим на пример создания нашего собственного итератора с помощью простой функции, которая печатает квадраты n числа.
function square(iteratorMaxCount,currentNumber)
if currentNumber<iteratorMaxCount
then
currentNumber = currentNumber+1
return currentNumber, currentNumber*currentNumber
end
end
for i,n in square,3,0
do
print(i,n)
end
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
1 1
2 4
3 9
Приведенный выше код можно немного изменить, чтобы имитировать работу итераторов ipairs . Это показано ниже.
function square(iteratorMaxCount,currentNumber)
if currentNumber<iteratorMaxCount
then
currentNumber = currentNumber+1
return currentNumber, currentNumber*currentNumber
end
end
function squares(iteratorMaxCount)
return square,iteratorMaxCount,0
end
for i,n in squares(3)
do
print(i,n)
end
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
1 1
2 4
3 9
Итераторы с отслеживанием состояния
Предыдущий пример итерации с использованием функции не сохраняет состояние. Каждый раз, когда вызывается функция, она возвращает следующий элемент коллекции на основе второй переменной, отправленной в функцию. Для сохранения состояния текущего элемента используются замыкания. Замыкание сохраняет значения переменных между вызовами функций. Чтобы создать новое замыкание, мы создаем две функции, включая само замыкание и фабрику, функцию, которая создает замыкание.
Давайте теперь посмотрим на пример создания нашего собственного итератора, в котором мы будем использовать замыкания.
array = {"Lua", "Tutorial"}
function elementIterator (collection)
local index = 0
local count = #collection
-- The closure function is returned
return function ()
index = index + 1
if index <= count
then
-- return the current element of the iterator
return collection[index]
end
end
end
for element in elementIterator(array)
do
print(element)
end
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
Lua
Tutorial
В приведенном выше примере мы видим, что elementIterator имеет внутри другой метод, который использует локальные внешние переменные index и count для возврата каждого элемента в коллекции путем увеличения индекса каждый раз при вызове функции.
Мы можем создавать наши собственные итераторы функций, используя замыкание, как показано выше, и оно может возвращать несколько элементов каждый раз, когда мы перебираем коллекцию.
Введение
Таблицы - единственная структура данных, доступная в Lua, которая помогает нам создавать различные типы, такие как массивы и словари. Lua использует ассоциативные массивы, которые можно индексировать не только числами, но и строками, кроме nil. Таблицы не имеют фиксированного размера и могут увеличиваться по мере необходимости.
Lua использует таблицы во всех представлениях, включая представление пакетов. Когда мы обращаемся к методу string.format, это означает, что мы обращаемся к функции форматирования, доступной в строковом пакете.
Представление и использование
Таблицы называются объектами и не являются ни значениями, ни переменными. Lua использует выражение конструктора {} для создания пустой таблицы. Следует знать, что не существует фиксированной связи между переменной, содержащей ссылку на таблицу, и самой таблицей.
--sample table initialization
mytable = {}
--simple table value assignment
mytable[1]= "Lua"
--removing reference
mytable = nil
-- lua garbage collection will take care of releasing memory
Когда у нас есть стол a с набором элементов и если мы назначим его b, и то и другое a и bотносятся к той же памяти. Отдельная память для b не выделяется. Когда a установлено в nil, таблица будет по-прежнему доступна для b. Когда нет ссылки на таблицу, сборка мусора в Lua заботится о процессе очистки, чтобы снова использовать эту память без ссылок.
Ниже показан пример для объяснения вышеупомянутых функций таблиц.
-- Simple empty table
mytable = {}
print("Type of mytable is ",type(mytable))
mytable[1]= "Lua"
mytable["wow"] = "Tutorial"
print("mytable Element at index 1 is ", mytable[1])
print("mytable Element at index wow is ", mytable["wow"])
-- alternatetable and mytable refers to same table
alternatetable = mytable
print("alternatetable Element at index 1 is ", alternatetable[1])
print("alternatetable Element at index wow is ", alternatetable["wow"])
alternatetable["wow"] = "I changed it"
print("mytable Element at index wow is ", mytable["wow"])
-- only variable released and and not table
alternatetable = nil
print("alternatetable is ", alternatetable)
-- mytable is still accessible
print("mytable Element at index wow is ", mytable["wow"])
mytable = nil
print("mytable is ", mytable)
Когда мы запустим вышеуказанную программу, мы получим следующий вывод -
Type of mytable is table
mytable Element at index 1 is Lua
mytable Element at index wow is Tutorial
alternatetable Element at index 1 is Lua
alternatetable Element at index wow is Tutorial
mytable Element at index wow is I changed it
alternatetable is nil
mytable Element at index wow is I changed it
mytable is nil
Управление таблицей
Есть встроенные функции для работы с таблицами, и они перечислены в следующей таблице.
Sr.No. | Метод и цель |
---|---|
1 | table.concat (table [, sep [, i [, j]]]) Объединяет строки в таблицах на основе заданных параметров. См. Пример для подробностей. |
2 | table.insert (table, [pos,] value) Вставляет значение в таблицу в указанной позиции. |
3 | table.maxn (table) Возвращает наибольший числовой индекс. |
4 | table.remove (table [, pos]) Удаляет значение из таблицы. |
5 | table.sort (table [, comp]) Сортирует таблицу на основе необязательного аргумента компаратора. |
Давайте посмотрим некоторые примеры вышеуказанных функций.
Объединение таблиц
Мы можем использовать функцию concat для объединения двух таблиц, как показано ниже -
fruits = {"banana","orange","apple"}
-- returns concatenated string of table
print("Concatenated string ",table.concat(fruits))
--concatenate with a character
print("Concatenated string ",table.concat(fruits,", "))
--concatenate fruits based on index
print("Concatenated string ",table.concat(fruits,", ", 2,3))
Когда мы запустим вышеуказанную программу, мы получим следующий вывод -
Concatenated string bananaorangeapple
Concatenated string banana, orange, apple
Concatenated string orange, apple
Вставить и удалить
Вставка и удаление элементов в таблицах чаще всего используются при работе с таблицами. Это объясняется ниже.
fruits = {"banana","orange","apple"}
-- insert a fruit at the end
table.insert(fruits,"mango")
print("Fruit at index 4 is ",fruits[4])
--insert fruit at index 2
table.insert(fruits,2,"grapes")
print("Fruit at index 2 is ",fruits[2])
print("The maximum elements in table is",table.maxn(fruits))
print("The last element is",fruits[5])
table.remove(fruits)
print("The previous last element is",fruits[5])
Когда мы запустим вышеуказанную программу, мы получим следующий вывод -
Fruit at index 4 is mango
Fruit at index 2 is grapes
The maximum elements in table is 5
The last element is mango
The previous last element is nil
Сортировочные таблицы
Нам часто требуется отсортировать таблицу в определенном порядке. Функции сортировки сортируют элементы в таблице по алфавиту. Пример для этого показан ниже.
fruits = {"banana","orange","apple","grapes"}
for k,v in ipairs(fruits) do
print(k,v)
end
table.sort(fruits)
print("sorted table")
for k,v in ipairs(fruits) do
print(k,v)
end
Когда мы запустим вышеуказанную программу, мы получим следующий вывод -
1 banana
2 orange
3 apple
4 grapes
sorted table
1 apple
2 banana
3 grapes
4 orange
Что такое модуль?
Модуль похож на библиотеку, которая может быть загружена с помощью require и имеет одно глобальное имя, содержащее таблицу. Этот модуль может состоять из ряда функций и переменных. Все эти функции и переменные заключены в таблицу, которая действует как пространство имен. Кроме того, хорошо настроенный модуль имеет необходимые условия для возврата этой таблицы по требованию.
Специальность модулей Lua
Использование таблиц в модулях помогает нам во многих отношениях и позволяет нам управлять модулями так же, как мы манипулируем любой другой таблицей Lua. Благодаря возможности манипулировать модулями он предоставляет дополнительные функции, для которых другим языкам требуются специальные механизмы. Благодаря этому бесплатному механизму модулей в Lua, пользователь может вызывать функции в Lua разными способами. Некоторые из них показаны ниже.
-- Assuming we have a module printFormatter
-- Also printFormatter has a funtion simpleFormat(arg)
-- Method 1
require "printFormatter"
printFormatter.simpleFormat("test")
-- Method 2
local formatter = require "printFormatter"
formatter.simpleFormat("test")
-- Method 3
require "printFormatter"
local formatterFunction = printFormatter.simpleFormat
formatterFunction("test")
В приведенном выше примере кода вы можете увидеть, насколько гибким является программирование на Lua без какого-либо специального дополнительного кода.
Требуемая функция
Lua предоставил функцию высокого уровня под названием require для загрузки всех необходимых модулей. Он делается максимально простым, чтобы не было слишком много информации о модуле для его загрузки. Функция require просто принимает модули как фрагмент кода, который определяет некоторые значения, которые на самом деле являются функциями или таблицами, содержащими функции.
пример
Давайте рассмотрим простой пример, где одна функция имеет математические функции. Назовем этот модуль mymath, а имя файла - mymath.lua. Содержимое файла выглядит следующим образом -
local mymath = {}
function mymath.add(a,b)
print(a+b)
end
function mymath.sub(a,b)
print(a-b)
end
function mymath.mul(a,b)
print(a*b)
end
function mymath.div(a,b)
print(a/b)
end
return mymath
Теперь, чтобы получить доступ к этому модулю Lua в другом файле, скажем, moduletutorial.lua, вам необходимо использовать следующий сегмент кода.
mymathmodule = require("mymath")
mymathmodule.add(10,20)
mymathmodule.sub(30,20)
mymathmodule.mul(10,20)
mymathmodule.div(30,20)
Чтобы запустить этот код, нам нужно поместить два файла Lua в один и тот же каталог или, альтернативно, вы можете поместить файл модуля в путь к пакету, и это потребует дополнительной настройки. Когда мы запустим вышеуказанную программу, мы получим следующий результат.
30
10
200
1.5
То, что нужно запомнить
Поместите модули и запускаемый файл в один каталог.
Имя модуля и имя его файла должны совпадать.
Рекомендуется возвращать модули для функции require, и, следовательно, модуль должен быть предпочтительно реализован, как показано выше, хотя вы можете найти другие типы реализаций в другом месте.
Старый способ реализации модулей
Позвольте мне теперь переписать тот же пример более старым способом, который использует тип реализации package.seeall. Это использовалось в версиях Lua 5.1 и 5.0. Модуль mymath показан ниже.
module("mymath", package.seeall)
function mymath.add(a,b)
print(a+b)
end
function mymath.sub(a,b)
print(a-b)
end
function mymath.mul(a,b)
print(a*b)
end
function mymath.div(a,b)
print(a/b)
end
Использование модулей в moduletutorial.lua показано ниже.
require("mymath")
mymath.add(10,20)
mymath.sub(30,20)
mymath.mul(10,20)
mymath.div(30,20)
Когда мы запустим вышеуказанное, мы получим тот же результат. Но рекомендуется использовать старую версию кода, которая считается менее безопасной. Многие SDK, использующие Lua для программирования, такие как Corona SDK, не рекомендуют его использование.
Метатаблица - это таблица, которая помогает изменить поведение таблицы, к которой она прикреплена, с помощью набора ключей и связанных мета-методов. Эти мета-методы представляют собой мощную функциональность Lua, которая включает такие функции, как -
Изменение / добавление функций к операторам на таблицах.
Поиск метатаблиц, когда ключ недоступен в таблице, используя __index в метатаблице.
Есть два важных метода, которые используются при обработке метатаблиц, которые включают:
setmetatable(table,metatable) - Этот метод используется для установки метатаблицы для таблицы.
getmetatable(table) - Этот метод используется для получения метатаблицы таблицы.
Давайте сначала посмотрим, как сделать одну таблицу метатаблицей другой. Это показано ниже.
mytable = {}
mymetatable = {}
setmetatable(mytable,mymetatable)
Приведенный выше код можно представить в одной строке, как показано ниже.
mytable = setmetatable({},{})
_индекс
Ниже показан простой пример метатаблицы для поиска метатаблицы, когда она недоступна в таблице.
mytable = setmetatable({key1 = "value1"}, {
__index = function(mytable, key)
if key == "key2" then
return "metatablevalue"
else
return mytable[key]
end
end
})
print(mytable.key1,mytable.key2)
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
value1 metatablevalue
Давайте по шагам объясним, что произошло в приведенном выше примере.
Таблица mytable здесь {key1 = "value1"}.
Metatable устанавливается для mytable, которая содержит функцию для __index, которую мы называем метаметодом.
Метаметод выполняет простую работу по поиску индекса «key2», если он найден, он возвращает «metatablevalue», в противном случае возвращает значение mytable для соответствующего индекса.
У нас может быть упрощенная версия вышеуказанной программы, как показано ниже.
mytable = setmetatable({key1 = "value1"},
{ __index = { key2 = "metatablevalue" } })
print(mytable.key1,mytable.key2)
__newindex
Когда мы добавляем __newindex в метатаблицу, если ключи недоступны в таблице, поведение новых ключей будет определяться мета-методами. Ниже приведен простой пример, когда индекс метатаблицы устанавливается, когда индекс недоступен в основной таблице.
mymetatable = {}
mytable = setmetatable({key1 = "value1"}, { __newindex = mymetatable })
print(mytable.key1)
mytable.newkey = "new value 2"
print(mytable.newkey,mymetatable.newkey)
mytable.key1 = "new value 1"
print(mytable.key1,mymetatable.newkey1)
Когда вы запустите вышеуказанную программу, вы получите следующий результат.
value1
nil new value 2
new value 1 nil
Вы можете видеть в приведенной выше программе, если ключ существует в основной таблице, он просто обновляет его. Когда ключ недоступен в основной таблице, он добавляет этот ключ в метатаблицу.
Другой пример, который обновляет ту же таблицу с помощью функции rawset, показан ниже.
mytable = setmetatable({key1 = "value1"}, {
__newindex = function(mytable, key, value)
rawset(mytable, key, "\""..value.."\"")
end
})
mytable.key1 = "new value"
mytable.key2 = 4
print(mytable.key1,mytable.key2)
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
new value "4"
rawset устанавливает значение без использования __newindex метатаблицы. Точно так же есть rawget, который получает значение без использования __index.
Добавление поведения оператора в таблицы
Ниже показан простой пример объединения двух таблиц с использованием оператора +.
mytable = setmetatable({ 1, 2, 3 }, {
__add = function(mytable, newtable)
for i = 1, table.maxn(newtable) do
table.insert(mytable, table.maxn(mytable)+1,newtable[i])
end
return mytable
end
})
secondtable = {4,5,6}
mytable = mytable + secondtable
for k,v in ipairs(mytable) do
print(k,v)
end
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
1 1
2 2
3 3
4 4
5 5
6 6
Ключ __add включен в метатаблицу для добавления поведения оператора +. Таблица клавиш и соответствующий оператор показаны ниже.
Sr.No. | Режим и описание |
---|---|
1 | __add Изменяет поведение оператора '+'. |
2 | __sub Изменяет поведение оператора '-'. |
3 | __mul Изменяет поведение оператора '*'. |
4 | __div Изменяет поведение оператора '/'. |
5 | __mod Изменяет поведение оператора "%". |
6 | __unm Изменяет поведение оператора '-'. |
7 | __concat Изменяет поведение оператора '..'. |
8 | __eq Изменяет поведение оператора '=='. |
9 | __lt Изменяет поведение оператора '<'. |
10 | __le Изменяет поведение оператора '<='. |
__вызов
Добавление поведения вызова метода выполняется с помощью оператора __call. Простой пример, который возвращает сумму значений в основной таблице с переданной таблицей.
mytable = setmetatable({10}, {
__call = function(mytable, newtable)
sum = 0
for i = 1, table.maxn(mytable) do
sum = sum + mytable[i]
end
for i = 1, table.maxn(newtable) do
sum = sum + newtable[i]
end
return sum
end
})
newtable = {10,20,30}
print(mytable(newtable))
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
70
__нанизывать
Чтобы изменить поведение оператора печати, мы можем использовать метаметод __tostring. Ниже показан простой пример.
mytable = setmetatable({ 10, 20, 30 }, {
__tostring = function(mytable)
sum = 0
for k, v in pairs(mytable) do
sum = sum + v
end
return "The sum of values in the table is " .. sum
end
})
print(mytable)
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
The sum of values in the table is 60
Если вы полностью знаете возможности метатаблицы, вы действительно можете выполнять множество операций, которые были бы очень сложными, без ее использования. Итак, попробуйте больше поработать над использованием метатаблиц с различными параметрами, доступными в метатаблицах, как описано в примерах, а также создайте свои собственные образцы.
Введение
Сопрограммы по своей природе являются совместными, что позволяет выполнять два или более методов контролируемым образом. С сопрограммами в любой момент времени выполняется только одна сопрограмма, и эта работающая сопрограмма приостанавливает свое выполнение только тогда, когда она явно запрашивает приостановку.
Приведенное выше определение может показаться расплывчатым. Предположим, у нас есть два метода: метод основной программы и сопрограмма. Когда мы вызываем сопрограмму с помощью функции возобновления, она начинает выполнение, а когда мы вызываем функцию yield, она приостанавливает выполнение. Опять же, та же сопрограмма может продолжить выполнение с другим вызовом функции возобновления с того места, где она была приостановлена. Этот процесс может продолжаться до конца выполнения сопрограммы.
Функции, доступные в сопрограммах
В следующей таблице перечислены все доступные функции для сопрограмм в Lua и их соответствующее использование.
Sr.No. | Метод и цель |
---|---|
1 | coroutine.create (f) Создает новую сопрограмму с функцией f и возвращает объект типа «поток». |
2 | coroutine.resume (co [, val1, ...]) Возобновляет сопрограмму co и передает параметры, если они есть. Он возвращает статус операции и необязательные другие возвращаемые значения. |
3 | coroutine.running () Возвращает работающую сопрограмму или nil, если вызывается в основном потоке. |
4 | coroutine.status (co) Возвращает одно из значений из запущенного, нормального, приостановленного или мертвого состояния в зависимости от состояния сопрограммы. |
5 | coroutine.wrap (f) Как и coroutine.create, функция coroutine.wrap также создает сопрограмму, но вместо того, чтобы возвращать саму сопрограмму, она возвращает функцию, которая при вызове возобновляет сопрограмму. |
6 | coroutine.yield (...) Приостанавливает работающую сопрограмму. Параметр, переданный этому методу, действует как дополнительные возвращаемые значения функции возобновления. |
пример
Давайте посмотрим на пример, чтобы понять концепцию сопрограмм.
co = coroutine.create(function (value1,value2)
local tempvar3 = 10
print("coroutine section 1", value1, value2, tempvar3)
local tempvar1 = coroutine.yield(value1+1,value2+1)
tempvar3 = tempvar3 + value1
print("coroutine section 2",tempvar1 ,tempvar2, tempvar3)
local tempvar1, tempvar2= coroutine.yield(value1+value2, value1-value2)
tempvar3 = tempvar3 + value1
print("coroutine section 3",tempvar1,tempvar2, tempvar3)
return value2, "end"
end)
print("main", coroutine.resume(co, 3, 2))
print("main", coroutine.resume(co, 12,14))
print("main", coroutine.resume(co, 5, 6))
print("main", coroutine.resume(co, 10, 20))
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
coroutine section 1 3 2 10
main true 4 3
coroutine section 2 12 nil 13
main true 5 1
coroutine section 3 5 6 16
main true 2 end
main false cannot resume dead coroutine
Что делает приведенный выше пример?
Как упоминалось ранее, мы используем функцию возобновления, чтобы запустить операцию, и функцию yield, чтобы остановить операцию. Кроме того, вы можете видеть, что функция возобновления сопрограммы получает несколько возвращаемых значений.
Сначала мы создаем сопрограмму и назначаем ее переменной с именем co, а сопрограмма принимает две переменные в качестве параметров.
Когда мы вызываем первую функцию возобновления, значения 3 и 2 сохраняются во временных переменных value1 и value2 до конца сопрограммы.
Чтобы вы это поняли, мы использовали tempvar3, которая изначально равна 10, и она обновляется до 13 и 16 при последующих вызовах сопрограмм, поскольку значение1 сохраняется как 3 на протяжении всего выполнения сопрограммы.
Первый coroutine.yield возвращает два значения 4 и 3 функции возобновления, которые мы получаем, обновляя входные параметры 3 и 2 в операторе yield. Он также получает статус выполнения сопрограммы истина / ложь.
Еще одна вещь о сопрограммах - это то, как заботятся о следующих параметрах вызова возобновления в приведенном выше примере; вы можете видеть, что переменная coroutine.yield получает следующие параметры вызова, что обеспечивает мощный способ выполнения новой операции с сохранением существующих значений параметров.
Наконец, как только все операторы в сопрограммах будут выполнены, последующие вызовы вернутся в false и в качестве ответа оператор «не может возобновить мертвую сопрограмму».
Другой пример сопрограммы
Давайте посмотрим на простую сопрограмму, которая возвращает число от 1 до 5 с помощью функции yield и функции возобновления. Он создает сопрограмму, если она недоступна, или возобновляет существующую сопрограмму.
function getNumber()
local function getNumberHelper()
co = coroutine.create(function ()
coroutine.yield(1)
coroutine.yield(2)
coroutine.yield(3)
coroutine.yield(4)
coroutine.yield(5)
end)
return co
end
if(numberHelper) then
status, number = coroutine.resume(numberHelper);
if coroutine.status(numberHelper) == "dead" then
numberHelper = getNumberHelper()
status, number = coroutine.resume(numberHelper);
end
return number
else
numberHelper = getNumberHelper()
status, number = coroutine.resume(numberHelper);
return number
end
end
for index = 1, 10 do
print(index, getNumber())
end
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
1 1
2 2
3 3
4 4
5 5
6 1
7 2
8 3
9 4
10 5
Часто сопрограммы сравнивают с потоками языков мультипрограммирования, но мы должны понимать, что сопрограммы имеют схожие функции потоков, но они выполняются только по одному и никогда не выполняются одновременно.
Мы контролируем последовательность выполнения программы в соответствии с потребностями с предоставлением временного сохранения определенной информации. Использование глобальных переменных с сопрограммами обеспечивает еще большую гибкость сопрограмм.
Библиотека ввода-вывода используется для чтения и управления файлами в Lua. В Lua есть два типа файловых операций, а именно неявные файловые дескрипторы и явные файловые дескрипторы.
Для следующих примеров мы будем использовать образец файла test.lua, как показано ниже.
-- sample test.lua
-- sample2 test.lua
В простой операции открытия файла используется следующий оператор.
file = io.open (filename [, mode])
Различные режимы файлов перечислены в следующей таблице.
Sr.No. | Режим и описание |
---|---|
1 | "r" Режим только для чтения - это режим по умолчанию, в котором открывается существующий файл. |
2 | "w" Режим с включенной записью, который перезаписывает существующий файл или создает новый файл. |
3 | "a" Режим добавления, который открывает существующий файл или создает новый файл для добавления. |
4 | "r+" Режим чтения и записи для существующего файла. |
5 | "w+" Все существующие данные удаляются, если файл существует или создается новый файл с разрешениями на чтение и запись. |
6 | "a+" Режим добавления с включенным режимом чтения, который открывает существующий файл или создает новый файл. |
Неявные файловые дескрипторы
Неявные файловые дескрипторы используют стандартные режимы ввода / вывода или один файл ввода и один файл вывода. Пример использования неявных файловых дескрипторов показан ниже.
-- Opens a file in read
file = io.open("test.lua", "r")
-- sets the default input file as test.lua
io.input(file)
-- prints the first line of the file
print(io.read())
-- closes the open file
io.close(file)
-- Opens a file in append mode
file = io.open("test.lua", "a")
-- sets the default output file as test.lua
io.output(file)
-- appends a word test to the last line of the file
io.write("-- End of the test.lua file")
-- closes the open file
io.close(file)
Когда вы запустите программу, вы получите вывод первой строки файла test.lua. Для нашей программы мы получили следующий результат.
-- Sample test.lua
Для нас это была первая строка оператора в файле test.lua. Также к последней строке кода test.lua будет добавлена строка «- Конец файла test.lua».
В приведенном выше примере вы можете увидеть, как неявные дескрипторы работают с файловой системой, используя методы io. "X". В приведенном выше примере io.read () используется без необязательного параметра. Необязательный параметр может быть любым из следующих.
Sr.No. | Режим и описание |
---|---|
1 | "*n" Считывает из текущей позиции файла и возвращает число, если существует в этой позиции файла, или возвращает nil. |
2 | "*a" Возвращает все содержимое файла с текущей позиции файла. |
3 | "*l" Считывает строку из текущей позиции файла и перемещает позицию файла на следующую строку. |
4 | number Читает количество байтов, указанное в функции. |
Другие распространенные методы ввода-вывода включают:
io.tmpfile() - Возвращает временный файл для чтения и записи, который будет удален после выхода из программы.
io.type(file) - Возвращает файл, закрытый файл или ноль на основе входного файла.
io.flush() - Очищает выходной буфер по умолчанию.
io.lines(optional file name)- Предоставляет общий итератор цикла for, который перебирает файл и закрывает файл в конце, если указано имя файла или файл по умолчанию используется и не закрывается в конце цикла.
Явные файловые дескрипторы
Мы часто используем явный файловый дескриптор, который позволяет нам управлять несколькими файлами одновременно. Эти функции очень похожи на неявные файловые дескрипторы. Здесь мы используем file: function_name вместо io.function_name. Следующий пример версии файла того же примера неявных файловых дескрипторов показан ниже.
-- Opens a file in read mode
file = io.open("test.lua", "r")
-- prints the first line of the file
print(file:read())
-- closes the opened file
file:close()
-- Opens a file in append mode
file = io.open("test.lua", "a")
-- appends a word test to the last line of the file
file:write("--test")
-- closes the open file
file:close()
Когда вы запустите программу, вы получите результат, аналогичный приведенному в примере с неявными дескрипторами.
-- Sample test.lua
Все режимы открытия файла и параметры чтения для внешних дескрипторов такие же, как и для неявных дескрипторов файлов.
Другие распространенные файловые методы включают:
file:seek(optional whence, optional offset)- Откуда параметр "set", "cur" или "end". Устанавливает указатель нового файла с обновленной позицией файла от начала файла. В этой функции смещения отсчитываются от нуля. Смещение измеряется от начала файла, если первый аргумент установлен; с текущей позиции в файле, если это "cur"; или с конца файла, если это "конец". Значения аргументов по умолчанию - cur и 0, поэтому текущую позицию в файле можно получить, вызвав эту функцию без аргументов.
file:flush() - Очищает выходной буфер по умолчанию.
io.lines(optional file name)- Предоставляет общий итератор цикла for, который перебирает файл и закрывает файл в конце, если указано имя файла или файл по умолчанию используется и не закрывается в конце цикла.
Пример использования метода поиска показан ниже. Он смещает курсор с 25 позиций до конца файла. Функция чтения печатает остаток файла с позиции поиска.
-- Opens a file in read
file = io.open("test.lua", "r")
file:seek("end",-25)
print(file:read("*a"))
-- closes the opened file
file:close()
Вы получите результат, подобный следующему.
sample2 test.lua
--test
Вы можете поиграть со всеми различными режимами и параметрами, чтобы узнать все возможности файловых операций Lua.
Необходимость обработки ошибок
Обработка ошибок очень важна, поскольку в реальных операциях часто требуются сложные операции, в том числе файловые операции, транзакции с базой данных и вызовы веб-служб.
В любом программировании всегда есть потребность в обработке ошибок. Ошибки могут быть двух типов, включая:
- Синтаксические ошибки
- Ошибки времени выполнения
Ошибки синтаксиса
Синтаксические ошибки возникают из-за неправильного использования различных компонентов программы, таких как операторы и выражения. Ниже показан простой пример синтаксической ошибки.
a == 2
Как вы знаете, существует разница между использованием одинарного «равно» и двойного «равно». Использование одного вместо другого может привести к ошибке. Одно «равно» относится к присваиванию, а двойное «равно» относится к сравнению. Точно так же у нас есть выражения и функции, имеющие предопределенные способы реализации.
Другой пример синтаксической ошибки показан ниже -
for a= 1,10
print(a)
end
Когда мы запустим вышеуказанную программу, мы получим следующий вывод -
lua: test2.lua:2: 'do' expected near 'print'
Синтаксические ошибки намного легче обрабатывать, чем ошибки времени выполнения, поскольку интерпретатор Lua обнаруживает ошибку более четко, чем в случае ошибки времени выполнения. Из приведенной выше ошибки мы можем легко узнать, что в соответствии со структурой Lua требуется добавление оператора do перед оператором печати.
Ошибки времени выполнения
В случае ошибок времени выполнения программа выполняется успешно, но это может привести к ошибкам времени выполнения из-за ошибок ввода или неправильно обработанных функций. Ниже показан простой пример, показывающий ошибку времени выполнения.
function add(a,b)
return a+b
end
add(10)
Когда мы построим программу, она будет успешно построена и запущена. После запуска показывает ошибку времени выполнения.
lua: test2.lua:2: attempt to perform arithmetic on local 'b' (a nil value)
stack traceback:
test2.lua:2: in function 'add'
test2.lua:5: in main chunk
[C]: ?
Это ошибка времени выполнения, которая произошла из-за не передачи двух переменных. Вb ожидаемый параметр, здесь он равен нулю и выдает ошибку.
Функции утверждения и ошибки
Для обработки ошибок мы часто используем две функции: assert и error. Ниже показан простой пример.
local function add(a,b)
assert(type(a) == "number", "a is not a number")
assert(type(b) == "number", "b is not a number")
return a+b
end
add(10)
Когда мы запустим указанную выше программу, мы получим следующий вывод ошибки.
lua: test2.lua:3: b is not a number
stack traceback:
[C]: in function 'assert'
test2.lua:3: in function 'add'
test2.lua:6: in main chunk
[C]: ?
В error (message [, level])завершает последнюю вызванную защищенную функцию и возвращает сообщение в качестве сообщения об ошибке. Ошибка этой функции никогда не возвращается. Обычно ошибка добавляет некоторую информацию о позиции ошибки в начале сообщения. Аргумент уровня указывает, как получить позицию ошибки. При уровне 1 (по умолчанию) позиция ошибки - это место, где была вызвана функция ошибки. Уровень 2 указывает на ошибку, где была вызвана функция, вызвавшая ошибку; и так далее. Передача уровня 0 позволяет избежать добавления в сообщение информации о местоположении ошибки.
pcall и xpcall
В программировании на Lua, чтобы избежать появления этих ошибок и ошибок обработки, нам необходимо использовать функции pcall или xpcall.
В pcall (f, arg1, ...)функция вызывает запрошенную функцию в защищенном режиме. Если в функции f возникает какая-то ошибка, она не вызывает ошибки. Он просто возвращает статус ошибки. Ниже показан простой пример использования pcall.
function myfunction ()
n = n/nil
end
if pcall(myfunction) then
print("Success")
else
print("Failure")
end
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
Failure
В xpcall (f, err)функция вызывает запрошенную функцию, а также устанавливает обработчик ошибок. Любая ошибка внутри f не распространяется; вместо этого xpcall перехватывает ошибку, вызывает функцию err с исходным объектом ошибки и возвращает код состояния.
Ниже показан простой пример для xpcall.
function myfunction ()
n = n/nil
end
function myerrorhandler( err )
print( "ERROR:", err )
end
status = xpcall( myfunction, myerrorhandler )
print( status)
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
ERROR: test2.lua:2: attempt to perform arithmetic on global 'n' (a nil value)
false
Как программист, очень важно заботиться о правильной обработке ошибок в программах, которые вы пишете. Использование обработки ошибок может гарантировать, что непредвиденные условия, выходящие за рамки граничных условий, будут обработаны, не мешая пользователю программы.
Lua предоставляет библиотеку отладки, которая предоставляет нам все примитивные функции для создания нашего собственного отладчика. Несмотря на то, что нет встроенного отладчика Lua, у нас есть много отладчиков для Lua, созданных различными разработчиками, многие из которых имеют открытый исходный код.
Функции, доступные в библиотеке отладки Lua, перечислены в следующей таблице вместе с их использованием.
Sr.No. | Метод и цель |
---|---|
1 | debug() Переходит в интерактивный режим отладки, который остается активным, пока мы не введем в строку только cont и не нажмем Enter. Пользователь может проверять переменные в этом режиме с помощью других функций. |
2 | getfenv(object) Возвращает окружение объекта. |
3 | gethook(optional thread) Возвращает текущие настройки ловушки потока в виде трех значений - текущая функция ловушки, текущая маска ловушки и текущее количество ловушек. |
4 | getinfo(optional thread, function or stack level, optional flag) Возвращает таблицу с информацией о функции. Вы можете указать функцию напрямую или указать число в качестве значения функции, что означает, что функция работает на уровне функции стека вызовов данного потока - уровень 0 - это текущая функция (сама getinfo); уровень 1 - это функция, которая вызывала getinfo; и так далее. Если function - это число, большее, чем количество активных функций, getinfo возвращает nil. |
5 | getlocal(optional thread, stack level, local index) Возвращает имя и значение локальной переменной с локальным индексом функции на уровне стека. Возвращает nil, если нет локальной переменной с данным индексом, и вызывает ошибку при вызове с уровнем вне допустимого диапазона. |
6 | getmetatable(value) Возвращает метатаблицу данного объекта или nil, если у нее нет метатаблицы. |
7 | getregistry() Возвращает таблицу реестра, предопределенную таблицу, которая может использоваться любым кодом C для хранения любого значения Lua, которое ему нужно сохранить. |
8 | getupvalue(function, upvalue index) Эта функция возвращает имя и значение восходящего значения с индексом вверх функции func. Функция возвращает nil, если нет повышающего значения с данным индексом. |
9 | setfenv(function or thread or userdata, environment table) Устанавливает среду данного объекта в данную таблицу. Возвращает объект. |
10 | sethook(optional thread, hook function, hook mask string with "c" and/or "r" and/or "l", optional instruction count) Устанавливает данную функцию как ловушку. Маска строки и счетчик чисел описывают, когда будет вызвана ловушка. Здесь c, r и l вызываются каждый раз, когда Lua вызывает, возвращает и вводит каждую строку кода в функции соответственно. |
11 | setlocal(optional thread, stack level, local index, value) Присваивает значение локальной переменной с индексом local функции на уровне стека. Функция возвращает nil, если нет локальной переменной с данным индексом, и вызывает ошибку при вызове с уровнем вне допустимого диапазона. В противном случае он возвращает имя локальной переменной. |
12 | setmetatable(value, metatable) Устанавливает метатаблицу для данного объекта в данную таблицу (которая может быть нулевой). |
13 | setupvalue(function, upvalue index, value) Эта функция присваивает значение upvalue с индексом up функции func. Функция возвращает nil, если нет повышающего значения с данным индексом. В противном случае он возвращает имя повышенного значения. |
14 | traceback(optional thread, optional message string, optional level argument) Создает расширенное сообщение об ошибке с трассировкой. |
Приведенный выше список представляет собой полный список функций отладки в Lua, и мы часто используем библиотеку, которая использует указанные выше функции и обеспечивает более простую отладку. Использование этих функций и создание собственного отладчика довольно сложно и нежелательно. В любом случае мы увидим пример простого использования функций отладки.
function myfunction ()
print(debug.traceback("Stack trace"))
print(debug.getinfo(1))
print("Stack trace end")
return 10
end
myfunction ()
print(debug.getinfo(1))
Когда мы запустим вышеуказанную программу, мы получим трассировку стека, как показано ниже.
Stack trace
stack traceback:
test2.lua:2: in function 'myfunction'
test2.lua:8: in main chunk
[C]: ?
table: 0054C6C8
Stack trace end
В приведенном выше примере программы трассировка стека печатается с помощью функции debug.trace, доступной в библиотеке отладки. Debug.getinfo получает текущую таблицу функции.
Отладка - пример
Нам часто требуется знать локальные переменные функции для отладки. Для этого мы можем использовать getupvalue, а для установки этих локальных переменных - setupvalue. Ниже показан простой пример этого.
function newCounter ()
local n = 0
local k = 0
return function ()
k = n
n = n + 1
return n
end
end
counter = newCounter ()
print(counter())
print(counter())
local i = 1
repeat
name, val = debug.getupvalue(counter, i)
if name then
print ("index", i, name, "=", val)
if(name == "n") then
debug.setupvalue (counter,2,10)
end
i = i + 1
end -- if
until not name
print(counter())
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
1
2
index 1 k = 1
index 2 n = 2
11
В этом примере счетчик обновляется на единицу при каждом вызове. Мы можем увидеть текущее состояние локальной переменной с помощью функции getupvalue. Затем мы устанавливаем для локальной переменной новое значение. Здесь n равно 2 до вызова операции установки. Используя функцию setupvalue, он обновляется до 10. Теперь, когда мы вызываем функцию счетчика, она вернет 11 вместо 3.
Типы отладки
- Отладка командной строки
- Графическая отладка
Командная строка отладки
Отладка из командной строки - это тип отладки, при котором для отладки используется командная строка с помощью команд и операторов печати. Для Lua доступно множество отладчиков командной строки, некоторые из которых перечислены ниже.
RemDebug- RemDebug - удаленный отладчик для Lua 5.0 и 5.1. Он позволяет удаленно управлять выполнением другой программы Lua, устанавливать точки останова и проверять текущее состояние программы. RemDebug также может отлаживать сценарии CGILua.
clidebugger- Простой отладчик интерфейса командной строки для Lua 5.1, написанный на чистом Lua. Он не зависит ни от чего, кроме стандартных библиотек Lua 5.1. Он был вдохновлен RemDebug, но не имеет своих удаленных возможностей.
ctrace - Инструмент для отслеживания вызовов Lua API.
xdbLua - Простой отладчик командной строки Lua для платформы Windows.
LuaInterface - Debugger- Этот проект является расширением отладчика для LuaInterface. Он поднимает встроенный интерфейс отладки Lua на более высокий уровень. Взаимодействие с отладчиком осуществляется посредством событий и вызовов методов.
Rldb- Это удаленный отладчик Lua через сокет, доступный как в Windows, так и в Linux. Он может дать вам гораздо больше возможностей, чем любой существующий.
ModDebug - Это позволяет удаленно контролировать выполнение другой программы Lua, устанавливать точки останова и проверять текущее состояние программы.
Графическая отладка
Графическая отладка доступна с помощью IDE, где вам предоставляется визуальная отладка различных состояний, таких как значения переменных, трассировка стека и другая связанная информация. В IDE есть визуальное представление и пошаговое управление выполнением с помощью точек останова, перехода, перехода и других кнопок.
Для Lua существует ряд графических отладчиков, в том числе следующие.
SciTE - IDE Windows по умолчанию для Lua предоставляет несколько средств отладки, таких как точки останова, шаг, шаг, шаг, переменные наблюдения и т. Д.
Decoda - Это графический отладчик с поддержкой удаленной отладки.
ZeroBrane Studio- Lua IDE со встроенным удаленным отладчиком, представлением стека, представлением часов, удаленной консолью, статическим анализатором и т. Д. Работает с LuaJIT, Love2d, Moai и другими движками Lua; Windows, OSX и Linux. Открытый источник.
akdebugger - Плагин Lua отладчика и редактора для Eclipse.
luaedit - Это включает удаленную отладку, локальную отладку, выделение синтаксиса, список предложений завершения, механизм предложения параметров, расширенное управление точками останова (включая систему условий для точек останова и счетчик попаданий), список функций, список глобальных и локальных переменных, отслеживание, управление, ориентированное на решение.
Lua использует автоматическое управление памятью, которое использует сборку мусора на основе определенных алгоритмов, встроенных в Lua. В результате автоматического управления памятью, как разработчик -
- Не нужно беспокоиться о выделении памяти для объектов.
- Нет необходимости освобождать их, когда они больше не нужны, за исключением установки значения nil.
Lua использует сборщик мусора, который время от времени запускается для сбора мертвых объектов, когда они больше не доступны из программы Lua.
Все объекты, включая таблицы, пользовательские данные, функции, поток, строку и так далее, подлежат автоматическому управлению памятью. Lua использует инкрементный сборщик меток и очистки, который использует два числа для управления циклами сборки мусора, а именно:garbage collector pause и garbage collector step multiplier. Эти значения выражены в процентах, и значение 100 часто внутренне равно 1.
Пауза сборщика мусора
Пауза сборщика мусора используется для контроля того, как долго сборщик мусора должен ждать раньше; он снова вызывается автоматическим управлением памятью Lua. Значения меньше 100 означают, что Lua не будет ждать следующего цикла. Точно так же более высокие значения этого значения приведут к тому, что сборщик мусора будет медленным и менее агрессивным по своей природе. Значение 200 означает, что сборщик ожидает удвоения общей используемой памяти перед началом нового цикла. Следовательно, в зависимости от природы и скорости приложения может потребоваться изменить это значение, чтобы получить максимальную производительность в приложениях Lua.
Множитель шагов сборщика мусора
Этот множитель шагов управляет относительной скоростью сборщика мусора по отношению к скорости выделения памяти в программе Lua. Более высокие значения шага приведут к тому, что сборщик мусора будет более агрессивным, а также увеличит размер шага каждого инкрементного шага сборки мусора. Значения меньше 100 часто могут привести к тому, что сборщик мусора не завершит свой цикл, и это обычно не является предпочтительным. Значение по умолчанию - 200, что означает, что сборщик мусора работает вдвое быстрее, чем выделение памяти.
Функции сборщика мусора
Как разработчики, у нас есть некоторый контроль над автоматическим управлением памятью в Lua. Для этого у нас есть следующие методы.
collectgarbage("collect") - Выполняет один полный цикл сборки мусора.
collectgarbage("count") - Возвращает объем памяти, который в настоящее время используется программой в килобайтах.
collectgarbage("restart") - Если сборщик мусора был остановлен, он перезапускает его.
collectgarbage("setpause")- Устанавливает значение, указанное как второй параметр, деленное на 100 для переменной паузы сборщика мусора. Его использование описано немного выше.
collectgarbage("setstepmul")- Устанавливает значение, указанное как второй параметр, деленное на 100, для переменной множителя шага мусора. Его использование описано немного выше.
collectgarbage("step")- Выполняет один шаг сборки мусора. Чем больше второй аргумент, тем больше будет этот шаг. Сборщик мусора вернет истину, если запущенный шаг был последним шагом цикла сборки мусора.
collectgarbage("stop") - Останавливает сборщик мусора, если он запущен.
Ниже показан простой пример с использованием сборщика мусора.
mytable = {"apple", "orange", "banana"}
print(collectgarbage("count"))
mytable = nil
print(collectgarbage("count"))
print(collectgarbage("collect"))
print(collectgarbage("count"))
Когда мы запустим вышеуказанную программу, мы получим следующий результат. Обратите внимание, что этот результат будет отличаться из-за разницы в типах операционной системы, а также из-за функции автоматического управления памятью Lua.
23.1455078125 149
23.2880859375 295
0
22.37109375 380
Как видно из приведенной выше программы, после завершения сборки мусора объем используемой памяти уменьшился. Но называть это не обязательно. Даже если мы их не вызываем, он будет автоматически выполнен интерпретатором Lua на более позднем этапе после предопределенного периода.
Очевидно, что при необходимости мы можем изменить поведение сборщика мусора, используя эти функции. Эти функции предоставляют разработчику дополнительные возможности для работы в сложных ситуациях. В зависимости от типа памяти, необходимой для программы, вы можете использовать или не использовать эту функцию. Но очень полезно знать использование памяти в приложениях и проверять это во время самого программирования, чтобы избежать нежелательных результатов после развертывания.
Введение в ООП
Объектно-ориентированное программирование (ООП) - один из наиболее часто используемых методов программирования в современную эпоху программирования. Существует ряд языков программирования, поддерживающих ООП, в том числе:
- C++
- Java
- Objective-C
- Smalltalk
- C#
- Ruby
Особенности ООП
Class - Класс - это расширяемый шаблон для создания объектов, предоставляющий начальные значения для состояния (переменные-члены) и реализации поведения.
Objects - Это экземпляр класса, для которого выделена отдельная память.
Inheritance - Это концепция, согласно которой переменные и функции одного класса наследуются другим классом.
Encapsulation- Это процесс объединения данных и функций внутри класса. Доступ к данным можно получить вне класса с помощью функций. Это также известно как абстракция данных.
ООП в Lua
Вы можете реализовать объектную ориентацию в Lua с помощью таблиц и функций первого класса Lua. Помещая функции и связанные данные в таблицу, формируется объект. Наследование может быть реализовано с помощью метатаблиц, обеспечивающих механизм поиска несуществующих функций (методов) и полей в родительских объектах.
Таблицы в Lua имеют такие особенности объекта, как состояние и идентичность, которые не зависят от его значений. Два объекта (таблицы) с одним и тем же значением являются разными объектами, тогда как объект может иметь разные значения в разное время, но это всегда один и тот же объект. Как и объекты, жизненный цикл таблиц не зависит от того, кто их создал или где они были созданы.
Пример из реального мира
Концепция объектной ориентации широко используется, но вам необходимо четко понимать ее для правильной и максимальной пользы.
Рассмотрим простой математический пример. Мы часто сталкиваемся с ситуациями, когда работаем с разными формами, такими как круг, прямоугольник и квадрат.
Фигуры могут иметь общее свойство Area. Таким образом, мы можем расширить другие формы из формы базового объекта с помощью области общих свойств. Каждая из фигур может иметь свои собственные свойства и функции, например, прямоугольник может иметь свойства length, width, area в качестве свойств и printArea и calculateArea в качестве функций.
Создание простого класса
Ниже показана простая реализация класса для прямоугольника с тремя свойствами: area, length и width. Он также имеет функцию printArea для печати вычисленной площади.
-- Meta class
Rectangle = {area = 0, length = 0, breadth = 0}
-- Derived class method new
function Rectangle:new (o,length,breadth)
o = o or {}
setmetatable(o, self)
self.__index = self
self.length = length or 0
self.breadth = breadth or 0
self.area = length*breadth;
return o
end
-- Derived class method printArea
function Rectangle:printArea ()
print("The area of Rectangle is ",self.area)
end
Создание объекта
Создание объекта - это процесс выделения памяти для экземпляра класса. Каждый из объектов имеет свою собственную память и использует общие данные класса.
r = Rectangle:new(nil,10,20)
Доступ к свойствам
Мы можем получить доступ к свойствам в классе с помощью оператора точки, как показано ниже -
print(r.length)
Доступ к функции-члену
Вы можете получить доступ к функции-члену с помощью оператора двоеточия с объектом, как показано ниже -
r:printArea()
Распределяется память и устанавливаются начальные значения. Процесс инициализации можно сравнить с конструкторами других объектно-ориентированных языков. Это не что иное, как функция, которая позволяет устанавливать значения, как показано выше.
Полный пример
Давайте рассмотрим полный пример использования объектной ориентации в Lua.
-- Meta class
Shape = {area = 0}
-- Base class method new
function Shape:new (o,side)
o = o or {}
setmetatable(o, self)
self.__index = self
side = side or 0
self.area = side*side;
return o
end
-- Base class method printArea
function Shape:printArea ()
print("The area is ",self.area)
end
-- Creating an object
myshape = Shape:new(nil,10)
myshape:printArea()
Когда вы запустите вышеуказанную программу, вы получите следующий результат.
The area is 100
Наследование в Lua
Наследование - это процесс расширения простых базовых объектов, таких как форма, до прямоугольников, квадратов и так далее. Он часто используется в реальном мире для совместного использования и расширения основных свойств и функций.
Давайте посмотрим на простое расширение класса. У нас есть класс, как показано ниже.
-- Meta class
Shape = {area = 0}
-- Base class method new
function Shape:new (o,side)
o = o or {}
setmetatable(o, self)
self.__index = self
side = side or 0
self.area = side*side;
return o
end
-- Base class method printArea
function Shape:printArea ()
print("The area is ",self.area)
end
Мы можем расширить форму до квадратного класса, как показано ниже.
Square = Shape:new()
-- Derived class method new
function Square:new (o,side)
o = o or Shape:new(o,side)
setmetatable(o, self)
self.__index = self
return o
end
Основные базовые функции
Мы можем переопределить функции базового класса, то есть вместо использования функции в базовом классе производный класс может иметь свою собственную реализацию, как показано ниже -
-- Derived class method printArea
function Square:printArea ()
print("The area of square is ",self.area)
end
Полный пример наследования
Мы можем расширить реализацию простого класса в Lua, как показано выше, с помощью другого нового метода с помощью метатаблиц. Все переменные-члены и функции базового класса сохраняются в производном классе.
-- Meta class
Shape = {area = 0}
-- Base class method new
function Shape:new (o,side)
o = o or {}
setmetatable(o, self)
self.__index = self
side = side or 0
self.area = side*side;
return o
end
-- Base class method printArea
function Shape:printArea ()
print("The area is ",self.area)
end
-- Creating an object
myshape = Shape:new(nil,10)
myshape:printArea()
Square = Shape:new()
-- Derived class method new
function Square:new (o,side)
o = o or Shape:new(o,side)
setmetatable(o, self)
self.__index = self
return o
end
-- Derived class method printArea
function Square:printArea ()
print("The area of square is ",self.area)
end
-- Creating an object
mysquare = Square:new(nil,10)
mysquare:printArea()
Rectangle = Shape:new()
-- Derived class method new
function Rectangle:new (o,length,breadth)
o = o or Shape:new(o)
setmetatable(o, self)
self.__index = self
self.area = length * breadth
return o
end
-- Derived class method printArea
function Rectangle:printArea ()
print("The area of Rectangle is ",self.area)
end
-- Creating an object
myrectangle = Rectangle:new(nil,10,20)
myrectangle:printArea()
Когда мы запустим вышеуказанную программу, мы получим следующий вывод -
The area is 100
The area of square is 100
The area of Rectangle is 200
В приведенном выше примере мы создали два производных класса - Rectangle и Square из базового класса Square. Можно переопределить функции базового класса в производном классе. В этом примере производный класс переопределяет функцию printArea.
Lua - очень гибкий язык, который часто используется на нескольких платформах, включая веб-приложения. Сообщество Kepler, которое было сформировано в 2004 году для предоставления веб-компонентов с открытым исходным кодом на Lua.
Несмотря на то, что существуют и другие веб-фреймворки, использующие Lua, мы в первую очередь сосредоточимся на компонентах, предоставляемых сообществом Kepler.
Приложения и фреймворки
Orbit - это веб-фреймворк MVC для Lua, основанный на WSAPI.
WSAPI - это API, который абстрагирует сервер веб-хоста от веб-приложений Lua и является основой для многих проектов.
Xavante это веб-сервер Lua, который предлагает интерфейс WSAPI.
Sputnik это вики / CMS, разработанная на основе WSAPI для проекта Kepler, используемая для юмора и развлечений.
CGILuaпредлагает создание веб-страниц LuaPages и LuaScripts на основе WSAPI, но больше не поддерживается. Вместо этого используйте Orbit, Sputnik или WSAPI.
В этом руководстве мы постараемся объяснить вам, что может Lua, и узнать больше о его установке и использовании, обратитесь к веб-сайту kepler.
Орбита
Orbit - это веб-фреймворк MVC для Lua. Он полностью отказывается от модели «сценариев» CGILua в пользу приложений, где каждое приложение Orbit может поместиться в один файл, но вы можете разделить его на несколько файлов, если хотите.
Все приложения Orbit следуют протоколу WSAPI, поэтому в настоящее время они работают с Xavante, CGI и Fastcgi. Он включает в себя средство запуска, которое упрощает запуск экземпляра Xavante для разработки.
Самый простой способ установить Orbit - использовать LuaRocks. Luarocks install orbit - это команда для установки. Для этого вам необходимо сначала установить LuaRocks .
Если вы не установили все зависимости, вот шаги, которые необходимо выполнить для установки Orbit в среде Unix / Linux.
Установка Apache
Подключитесь к вашему серверу. Установите Apache2, его модули поддержки и включите необходимые модули Apache2, используя -
$ sudo apt-get install apache2 libapache2-mod-fcgid libfcgi-dev build-essential $ sudo a2enmod rewrite
$ sudo a2enmod fcgid $ sudo /etc/init.d/apache2 force-reload
Установите LuaRocks
$ sudo apt-get install luarocks
Установите WSAPI, FCGI, Orbit и Xavante
$ sudo luarocks install orbit
$ sudo luarocks install wsapi-xavante $ sudo luarocks install wsapi-fcgi
Настройка Apache2
$ sudo raj /etc/apache2/sites-available/default
Добавьте следующий раздел под разделом <Directory / var / www /> файла конфигурации. Если в этом разделе указано «AllowOverride None», вам необходимо изменить «None» на «All», чтобы файл .htaccess мог локально переопределить конфигурацию.
<IfModule mod_fcgid.c>
AddHandler fcgid-script .lua
AddHandler fcgid-script .ws
AddHandler fcgid-script .op
FCGIWrapper "/usr/local/bin/wsapi.fcgi" .ws
FCGIWrapper "/usr/local/bin/wsapi.fcgi" .lua
FCGIWrapper "/usr/local/bin/op.fcgi" .op
#FCGIServer "/usr/local/bin/wsapi.fcgi" -idle-timeout 60 -processes 1
#IdleTimeout 60
#ProcessLifeTime 60
</IfModule>
Перезапустите сервер, чтобы внесенные изменения вступили в силу.
Чтобы включить ваше приложение, вам необходимо добавить + ExecCGI в файл .htaccess в корне вашего приложения Orbit - в данном случае / var / www.
Options +ExecCGI
DirectoryIndex index.ws
Простой пример - орбита
#!/usr/bin/env index.lua
-- index.lua
require"orbit"
-- declaration
module("myorbit", package.seeall, orbit.new)
-- handler
function index(web)
return my_home_page()
end
-- dispatch
myorbit:dispatch_get(index, "/", "/index")
-- Sample page
function my_home_page()
return [[
<head></head>
<html>
<h2>First Page</h2>
</html>
]]
end
Теперь у вас должна быть возможность запустить свой веб-браузер. Перейдите по адресу http: // localhost: 8080 /, и вы должны увидеть следующий вывод -
First Page
Orbit предоставляет еще один вариант, то есть код Lua может генерировать html.
#!/usr/bin/env index.lua
-- index.lua
require"orbit"
function generate()
return html {
head{title "HTML Example"},
body{
h2{"Here we go again!"}
}
}
end
orbit.htmlify(generate)
print(generate())
Создание форм
Пример простой формы показан ниже -
#!/usr/bin/env index.lua
require"orbit"
function wrap (inner)
return html{ head(), body(inner) }
end
function test ()
return wrap(form (H'table' {
tr{td"First name",td( input{type = 'text', name='first'})},
tr{td"Second name",td(input{type = 'text', name='second'})},
tr{ td(input{type = 'submit', value = 'Submit!'}),
td(input{type = 'submit',value = 'Cancel'})
},
}))
end
orbit.htmlify(wrap,test)
print(test())
WSAPI
Как упоминалось ранее, WSAPI выступает в качестве основы для многих проектов и имеет множество встроенных функций. Вы можете использовать WSAPI и поддерживать следующие платформы,
- Windows
- Системы на базе UNIX
Поддерживаемые серверы и интерфейсы WSAPI включают:
- CGI
- FastCGI
- Xavante
WSAPI предоставляет ряд библиотек, которые упрощают нам веб-программирование с использованием Lua. Некоторые из поддерживаемых функций в Lua включают:
- Обработка запроса
- Буферизация вывода
- Authentication
- Загрузка файлов
- Запросить изоляцию
- Multiplexing
Ниже показан простой пример WSAPI -
#!/usr/bin/env wsapi.cgi
module(..., package.seeall)
function run(wsapi_env)
local headers = { ["Content-type"] = "text/html" }
local function hello_text()
coroutine.yield("<html><body>")
coroutine.yield("<p>Hello Wsapi!</p>")
coroutine.yield("<p>PATH_INFO: " .. wsapi_env.PATH_INFO .. "</p>")
coroutine.yield("<p>SCRIPT_NAME: " .. wsapi_env.SCRIPT_NAME .. "</p>")
coroutine.yield("</body></html>")
end
return 200, headers, coroutine.wrap(hello_text)
end
Вы можете видеть, что в приведенном выше коде создается и возвращается простая HTML-страница. Вы можете увидеть использование сопрограмм, которые позволяют возвращать оператор за оператором вызывающей функции. Наконец, возвращается код состояния html (200), заголовки и страница html.
Xavante
Xavante - это веб-сервер Lua HTTP 1.1, который использует модульную архитектуру, основанную на обработчиках с отображением URI. Хаванте в настоящее время предлагает,
- Обработчик файлов
- Обработчик перенаправления
- Обработчик WSAPI
Обработчик файлов используется для общих файлов. Обработчик перенаправления включает переназначение URI и обработчик WSAPI для работы с приложениями WSAPI.
Ниже показан простой пример.
require "xavante.filehandler"
require "xavante.cgiluahandler"
require "xavante.redirecthandler"
-- Define here where Xavante HTTP documents scripts are located
local webDir = XAVANTE_WEB
local simplerules = {
{ -- URI remapping example
match = "^[^%./]*/$",
with = xavante.redirecthandler,
params = {"index.lp"}
},
{ -- cgiluahandler example
match = {"%.lp$", "%.lp/.*$", "%.lua$", "%.lua/.*$" },
with = xavante.cgiluahandler.makeHandler (webDir)
},
{ -- filehandler example
match = ".",
with = xavante.filehandler,
params = {baseDir = webDir}
},
}
xavante.HTTP{
server = {host = "*", port = 8080},
defaultHost = {
rules = simplerules
},
}
Чтобы использовать виртуальные хосты с Xavante, вызов xavante.HTTP должен быть изменен на что-то вроде следующего:
xavante.HTTP{
server = {host = "*", port = 8080},
defaultHost = {},
virtualhosts = {
["www.sitename.com"] = simplerules
}
}
Веб-компоненты Lua
Copas, диспетчер на основе сопрограмм, которые могут использоваться серверами TCP / IP.
Cosmo, механизм «безопасных шаблонов», который защищает ваше приложение от произвольного кода в шаблонах.
Coxpcall инкапсулирует родные Lua pcall и xpcall с сопрограммами, совместимыми с ними.
LuaFileSystem, переносимый способ доступа к базовой структуре каталогов и атрибутам файлов.
Rings, библиотека, которая позволяет создавать новые состояния Lua изнутри Lua.
Конечная записка
Для нас доступно так много веб-фреймворков и компонентов на основе Lua, и в зависимости от потребности их можно выбрать. Доступны и другие веб-фреймворки, которые включают следующее:
Moonstalkобеспечивает эффективную разработку и размещение динамически генерируемых веб-проектов, созданных с помощью языка Lua; от простых страниц до сложных приложений.
Lapis, фреймворк для создания веб-приложений с использованием MoonScript (или Lua), который работает внутри настроенной версии Nginx под названием OpenResty.
Lua Server Pagesподключаемый модуль скриптового движка Lua, который превосходит любой другой подход к встраиваемой веб-разработке, предлагает резкий путь к традиционным страницам сервера C.
Эти веб-фреймворки могут использовать ваши веб-приложения и помочь вам в выполнении мощных операций.
Для простых операций с данными мы можем использовать файлы, но иногда эти операции с файлами могут быть неэффективными, масштабируемыми и мощными. Для этого мы часто можем переключаться на использование баз данных. LuaSQL - это простой интерфейс Lua для ряда систем управления базами данных. LuaSQL - это библиотека, которая обеспечивает поддержку различных типов SQL. Это включает,
- SQLite
- Mysql
- ODBC
В этом руководстве мы рассмотрим обработку баз данных MySQL и SQLite в Lua. Здесь используется общий интерфейс для обоих, и должна быть возможность перенести эту реализацию и на другие типы баз данных. Сначала давайте посмотрим, как вы можете выполнять операции в MySQL.
Настройка базы данных MySQL
Чтобы использовать следующие примеры для правильной работы, нам нужна начальная настройка базы данных. Предположения перечислены ниже.
Вы установили и настроили MySQL с пользователем по умолчанию как root и паролем «123456».
Вы создали тестовую базу данных.
Вы прошли обучение MySQL, чтобы понять основы MySQL.
Импорт MySQL
Мы можем использовать простой require оператор для импорта библиотеки sqlite при условии, что ваша реализация Lua была выполнена правильно.
mysql = require "luasql.mysql"
Переменная mysql предоставит доступ к функциям, ссылаясь на основную таблицу mysql.
Настройка подключения
Мы можем установить соединение, запустив среду MySQL, а затем создав соединение для этой среды. Это показано ниже.
local env = mysql.mysql()
local conn = env:connect('test','root','123456')
Вышеупомянутое соединение будет подключаться к существующему файлу MySQL и устанавливает соединение с вновь созданным файлом.
Выполнить функцию
Существует простая функция выполнения, доступная с подключением, которая поможет нам выполнять все операции с базой данных от создания, вставки, удаления, обновления и так далее. Синтаксис показан ниже -
conn:execute([[ 'MySQLSTATEMENT' ]])
В приведенном выше синтаксисе нам нужно убедиться, что conn открыто и существует соединение с MySQL, и заменить MySQLSTATEMENT правильным оператором.
Пример создания таблицы
Ниже показан простой пример создания таблицы. Он создает таблицу с двумя параметрами: id целочисленного типа и именем типа varchar.
mysql = require "luasql.mysql"
local env = mysql.mysql()
local conn = env:connect('test','root','123456')
print(env,conn)
status,errorString = conn:execute([[CREATE TABLE sample2 (id INTEGER, name TEXT);]])
print(status,errorString )
Когда вы запустите указанную выше программу, будет создана таблица с именем sample с двумя столбцами, а именно: id и name.
MySQL environment (004BB178) MySQL connection (004BE3C8)
0 nil
В случае какой-либо ошибки вам будет возвращено сообщение об ошибке вместо nil. Ниже показано простое сообщение об ошибке.
LuaSQL: Error executing query. MySQL: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '"id INTEGER, name TEXT)' at line 1
Вставить пример инструкции
Оператор вставки для MySQL показан ниже.
conn:execute([[INSERT INTO sample values('11','Raj')]])
Пример инструкции обновления
Оператор обновления для MySQL показан ниже.
conn:execute([[UPDATE sample3 SET name='John' where id ='12']])
Пример оператора удаления
Оператор удаления для MySQL показан ниже.
conn:execute([[DELETE from sample3 where id ='12']])
Выберите пример утверждения
Что касается оператора select, нам нужно перебрать каждую из строк и извлечь необходимые данные. Ниже показан простой оператор выбора.
cursor,errorString = conn:execute([[select * from sample]])
row = cursor:fetch ({}, "a")
while row do
print(string.format("Id: %s, Name: %s", row.id, row.name))
-- reusing the table of results
row = cursor:fetch (row, "a")
end
В приведенном выше коде conn - это открытое соединение MySQL. С помощью курсора, возвращаемого оператором execute, вы можете в цикле просмотреть ответ таблицы и получить необходимые данные выбора.
Полный пример
Полный пример, включающий все вышеперечисленные утверждения, приведен ниже.
mysql = require "luasql.mysql"
local env = mysql.mysql()
local conn = env:connect('test','root','123456')
print(env,conn)
status,errorString = conn:execute([[CREATE TABLE sample3 (id INTEGER, name TEXT)]])
print(status,errorString )
status,errorString = conn:execute([[INSERT INTO sample3 values('12','Raj')]])
print(status,errorString )
cursor,errorString = conn:execute([[select * from sample3]])
print(cursor,errorString)
row = cursor:fetch ({}, "a")
while row do
print(string.format("Id: %s, Name: %s", row.id, row.name))
row = cursor:fetch (row, "a")
end
-- close everything
cursor:close()
conn:close()
env:close()
Когда вы запустите вышеуказанную программу, вы получите следующий результат.
MySQL environment (0037B178) MySQL connection (0037EBA8)
0 nil
1 nil
MySQL cursor (003778A8) nil
Id: 12, Name: Raj
Выполнение транзакций
Транзакции - это механизм, обеспечивающий согласованность данных. Транзакции должны иметь следующие четыре свойства -
Atomicity - Либо транзакция завершается, либо вообще ничего не происходит.
Consistency - Транзакция должна начинаться в согласованном состоянии и оставлять систему в согласованном состоянии.
Isolation - Промежуточные результаты транзакции не видны вне текущей транзакции.
Durability - После фиксации транзакции последствия сохраняются даже после сбоя системы.
Транзакция начинается с START TRANSACTION; и заканчивается оператором фиксации или отката.
Начать транзакцию
Чтобы инициировать транзакцию, нам нужно выполнить следующий оператор в Lua, предполагая, что conn является открытым соединением MySQL.
conn:execute([[START TRANSACTION;]])
Откат транзакции
Нам нужно выполнить следующую инструкцию для отката изменений, сделанных после выполнения стартовой транзакции.
conn:execute([[ROLLBACK;]])
Подтвердить транзакцию
Нам нужно выполнить следующий оператор, чтобы зафиксировать изменения, сделанные после выполнения стартовой транзакции.
conn:execute([[COMMIT;]])
Мы узнали о MySQL в предыдущем разделе, а в следующем разделе объясняются основные операции SQL. Помните о транзакциях, хотя это не объясняется снова для SQLite3, но те же операторы должны работать и для SQLite3.
Импорт SQLite
Мы можем использовать простой оператор require для импорта библиотеки SQLite, предполагая, что ваша реализация Lua была выполнена правильно. Во время установки создается папка libsql, содержащая файлы, связанные с базой данных.
sqlite3 = require "luasql.sqlite3"
Переменная sqlite3 предоставит доступ к функциям, ссылаясь на основную таблицу sqlite3.
Настройка подключения
Мы можем установить соединение, запустив среду SQLite, а затем создав соединение для этой среды. Это показано ниже.
local env = sqlite3.sqlite3()
local conn = env:connect('mydb.sqlite')
Вышеупомянутое соединение будет подключаться к существующему файлу SQLite или создает новый файл SQLite и устанавливает соединение с вновь созданным файлом.
Выполнить функцию
Существует простая функция выполнения, доступная с подключением, которая поможет нам выполнять все операции с базой данных от создания, вставки, удаления, обновления и так далее. Синтаксис показан ниже -
conn:execute([[ 'SQLite3STATEMENT' ]])
В приведенном выше синтаксисе нам нужно убедиться, что conn открыто и существует соединение sqlite3, и заменить «SQLite3STATEMENT» правильным оператором.
Пример создания таблицы
Ниже показан простой пример создания таблицы. Он создает таблицу с двумя параметрами: id целочисленного типа и именем типа varchar.
sqlite3 = require "luasql.sqlite3"
local env = sqlite3.sqlite3()
local conn = env:connect('mydb.sqlite')
print(env,conn)
status,errorString = conn:execute([[CREATE TABLE sample ('id' INTEGER, 'name' TEXT)]])
print(status,errorString )
Когда вы запустите указанную выше программу, будет создана таблица с именем sample с двумя столбцами, а именно: id и name.
SQLite3 environment (003EC918) SQLite3 connection (00421F08)
0 nil
В случае ошибки вам будет возвращено сообщение об ошибке вместо nil. Ниже показано простое сообщение об ошибке.
LuaSQL: unrecognized token: ""'id' INTEGER, 'name' TEXT)"
Вставить пример инструкции
Оператор вставки для SQLite показан ниже.
conn:execute([[INSERT INTO sample values('11','Raj')]])
Выберите пример утверждения
Что касается оператора select, нам нужно перебрать каждую из строк и извлечь необходимые данные. Ниже показан простой оператор выбора.
cursor,errorString = conn:execute([[select * from sample]])
row = cursor:fetch ({}, "a")
while row do
print(string.format("Id: %s, Name: %s", row.id, row.name))
-- reusing the table of results
row = cursor:fetch (row, "a")
end
В приведенном выше коде conn - это открытое соединение sqlite3. С помощью курсора, возвращаемого оператором execute, вы можете в цикле просмотреть ответ таблицы и получить необходимые данные выбора.
Полный пример
Полный пример, включающий все вышеперечисленные утверждения, приведен ниже.
sqlite3 = require "luasql.sqlite3"
local env = sqlite3.sqlite3()
local conn = env:connect('mydb.sqlite')
print(env,conn)
status,errorString = conn:execute([[CREATE TABLE sample ('id' INTEGER, 'name' TEXT)]])
print(status,errorString )
status,errorString = conn:execute([[INSERT INTO sample values('1','Raj')]])
print(status,errorString )
cursor,errorString = conn:execute([[select * from sample]])
print(cursor,errorString)
row = cursor:fetch ({}, "a")
while row do
print(string.format("Id: %s, Name: %s", row.id, row.name))
row = cursor:fetch (row, "a")
end
-- close everything
cursor:close()
conn:close()
env:close()
Когда вы запустите вышеуказанную программу, вы получите следующий результат.
SQLite3 environment (005EC918) SQLite3 connection (005E77B0)
0 nil
1 nil
SQLite3 cursor (005E9200) nil
Id: 1, Name: Raj
Мы можем выполнить все доступные запросы с помощью этой библиотеки libsql. Поэтому, пожалуйста, не останавливайтесь на этих примерах. Поэкспериментируйте с различными операторами запроса, доступными в соответствующих MySQL, SQLite3 и других поддерживаемых базах данных в Lua.
Lua используется во многих игровых движках из-за его простой языковой структуры и синтаксиса. Функция сборки мусора часто бывает весьма полезна в играх, которые потребляют много памяти из-за использования богатой графики. Некоторые игровые движки, использующие Lua, включают:
- Corona SDK
- Gideros Mobile
- ShiVa3D
- Моаи SDK
- LOVE
- CryEngine
Каждый из этих игровых движков основан на Lua, и в каждом из этих движков доступен богатый набор API. Мы вкратце рассмотрим возможности каждого из них.
Corona SDK
Corona SDK - это кроссплатформенный движок для мобильных игр, поддерживающий платформы iPhone, iPad и Android. Существует бесплатная версия Corona SDK, которую можно использовать для небольших игр с ограниченными функциями. При необходимости вы можете перейти на другие версии.
Corona SDK предоставляет ряд функций, включая следующие:
- API физики и обработки столкновений
- Веб и сетевые API
- API игровой сети
- Ads API
- Analytics API
- API базы данных и файловой системы
- Крипто и математические API
- Аудио и медиа API
Проще и быстрее разработать приложение с использованием вышеуказанных API, чем использовать собственные API отдельно для iOS и Android.
Gideros Mobile
Gideros предоставляет кроссплатформенный SDK для создания игр для iOS и Android. Его можно бесплатно использовать с брызгами made with Gideros. Некоторые из поразительных преимуществ Gideoros включают следующее:
Development IDE - Он предоставляет собственную среду IDE, которая упрощает разработку приложений Gideros.
Instant testing- При разработке игры ее можно протестировать на реальном устройстве через Wi-Fi всего за 1 секунду. Вам не нужно тратить время на экспорт или развертывание.
Plugins- Вы можете легко расширить ядро с помощью плагинов. Импортируйте существующий код (C, C ++, Java или Obj-C), привяжите его к Lua и интерпретируйте его напрямую. Десятки плагинов с открытым исходным кодом уже разработаны и готовы к использованию.
Clean OOP approach - Gideros предоставляет собственную систему классов со всеми основными стандартами ООП, что позволяет вам писать чистый и многократно используемый код для любой из ваших будущих игр.
Native speed - Разработанная на основе C / C ++ и OpenGL, ваша игра работает с собственной скоростью и полностью использует мощность ЦП и графических процессоров.
ShiVa3D
ShiVa3D - это один из движков трехмерных игр, который предоставляет графический редактор, предназначенный для создания приложений и видеоигр для Интернета, консолей и мобильных устройств. Он поддерживает несколько платформ, включая Windows, Mac, Linux, iOS, Android, BlackBerry, Palm OS, Wii и WebOS.
Некоторые из основных функций включают
- Стандартные плагины
- API модификации сетки
- IDE
- Встроенный редактор ландшафта, океана и анимации
- Поддержка физического движка ODE
- Полный контроль карты освещения
- Предварительный просмотр материалов, частиц, следов и HUD в реальном времени
- Поддержка формата обмена Collada
Веб-версия Shiva3d полностью бесплатна, и на другие выпуски вы подписаны.
Моаи SDK
Moai SDK - это кроссплатформенный движок для мобильных игр, поддерживающий платформы iPhone, iPad и Android. Платформа Moai изначально состояла из Moai SDK, игрового движка с открытым исходным кодом, и Moai Cloud, облачной платформы как службы для хостинга и развертывания игровых сервисов. Теперь облако Moai отключено, и доступен только игровой движок.
Moai SDK работает на нескольких платформах, включая iOS, Android, Chrome, Windows, Mac и Linux.
ЛЮБИТЬ
LOVE - это фреймворк, который можно использовать для создания 2D-игр. Это бесплатно и с открытым исходным кодом. Он поддерживает платформы Windows, Mac OS X и Linux.
Он предоставляет несколько функций, которые включают:
- Аудио API
- API файловой системы
- API клавиатуры и джойстика
- Математический API
- API окна и мыши
- Физический API
- Системные и таймерные API
CryEngine
CryEngine - игровой движок, разработанный немецким разработчиком игр Crytek. Оно эволюционировало от поколения 1 до поколения 4 и представляет собой передовое решение для разработки. Он поддерживает игры для ПК, Xbox 360, PlayStation3 и WiiU.
Он предоставляет несколько функций, которые включают:
Визуальные эффекты, такие как естественное освещение и динамические мягкие тени, динамическое глобальное освещение в реальном времени, объем распространения света, затенение частиц, тесселяция и т. Д.
Система анимации персонажей и система индивидуализации персонажей.
Параметрическая скелетная анимация и уникальный редактор лицевой анимации
Системы искусственного интеллекта, такие как многослойная навигационная сетка и система тактических точек. Также предоставляет удобную для дизайнера систему редактирования AI.
В микшировании и профилировании игр, звуковой системе на основе данных, динамических звуках и интерактивной музыке и т. Д.
Физические функции, такие как процедурная деформация и продвинутая физика веревки.
Конечная записка
Каждый из этих игровых SDK / фреймворков имеет свои преимущества и недостатки. Правильный выбор между ними облегчит вашу задачу, и вы сможете лучше провести с ней время. Итак, прежде чем использовать его, вам нужно знать требования к вашей игре, а затем проанализировать, какая из них удовлетворяет все ваши потребности, и затем следует их использовать.
Стандартные библиотеки Lua предоставляют богатый набор функций, которые реализованы непосредственно с помощью C API и встроены в язык программирования Lua. Эти библиотеки предоставляют сервисы на языке программирования Lua, а также внешние сервисы, такие как операции с файлами и базами данных.
Эти стандартные библиотеки, встроенные в официальный API C, предоставляются как отдельные модули C. Он включает в себя следующее -
- Базовая библиотека, включающая подбиблиотеку сопрограмм
- Библиотека модулей
- Строковые манипуляции
- Манипуляции с таблицей
- Математическая библиотека
- Файловый ввод и вывод
- Возможности операционной системы
- Средства отладки
Базовая библиотека
Мы использовали базовую библиотеку на протяжении всего урока по разным темам. В следующей таблице приведены ссылки на связанные страницы и перечислены функции, которые рассматриваются в различных частях этого руководства по Lua.
Sr.No. | Библиотека / Метод и цель |
---|---|
1 | Error Handling Включает функции обработки ошибок, такие как assert, error, как описано в Lua - Обработка ошибок . |
2 | Memory Management Включает функции автоматического управления памятью, связанные со сборкой мусора, как описано в Lua - Сборка мусора . |
3 | dofile ([filename]) Он открывает файл и выполняет содержимое файла как фрагмент. Если параметр не передан, эта функция выполняет содержимое стандартного ввода. Ошибки будут переданы вызывающему абоненту. |
4 | _G Это глобальная переменная, которая содержит глобальную среду (то есть _G._G = _G). Сам Lua не использует эту переменную. |
5 | getfenv ([f]) Возвращает текущую среду, используемую функцией. f может быть функцией Lua или числом, определяющим функцию на этом уровне стека. Уровень 1 - это функция, вызывающая getfenv. Если данная функция не является функцией Lua или если f равно 0, getfenv возвращает глобальное окружение. Значение по умолчанию для f равно 1. |
6 | getmetatable (object) Если объект не имеет метатаблицы, возвращает ноль. В противном случае, если метатаблица объекта имеет поле «__metatable», возвращает связанное значение. В противном случае возвращает метатаблицу данного объекта. |
7 | ipairs (t) Эта функция извлекает индексы и значения таблиц. |
8 | load (func [, chunkname]) Загружает кусок, используя функцию func для получения его частей. Каждый вызов func должен возвращать строку, которая объединяется с предыдущими результатами. |
9 | loadfile ([filename])) Аналогично загрузке, но получает фрагмент из имени файла файла или из стандартного ввода, если имя файла не указано. |
10 | loadstring (string [, chunkname]) Аналогично load, но получает фрагмент из заданной строки. |
11 | next (table [, index]) Позволяет программе перемещаться по всем полям таблицы. Его первый аргумент - это таблица, а второй аргумент - это индекс в этой таблице. next возвращает следующий индекс таблицы и связанное с ним значение. |
12 | pairs (t) Приостанавливает работающую сопрограмму. Параметр, переданный этому методу, действует как дополнительные возвращаемые значения функции возобновления. |
13 | print (...) Приостанавливает работающую сопрограмму. Параметр, переданный этому методу, действует как дополнительные возвращаемые значения функции возобновления. |
14 | rawequal (v1, v2) Проверяет, равно ли v1 v2, без вызова каких-либо метаметодов. Возвращает логическое значение. |
15 | rawget (table, index) Получает реальное значение таблицы [index] без вызова каких-либо метаметодов. стол должен быть столом; index может иметь любое значение. |
16 | rawset (table, index, value) Устанавливает реальное значение таблицы [index] равным значению без вызова каких-либо метаметодов. table должен быть таблицей, индексировать любое значение, отличное от nil, и значение любое значение Lua. Эта функция возвращает таблицу. |
17 | select (index, ...) Если index является числом, возвращает все аргументы после индекса номера аргумента. В противном случае index должен быть строкой «#», а select возвращает общее количество полученных дополнительных аргументов. |
18 | setfenv (f, table) Устанавливает среду, которая будет использоваться данной функцией. f может быть функцией Lua или числом, определяющим функцию на этом уровне стека. Уровень 1 - это функция, вызывающая setfenv. setfenv возвращает заданную функцию. В качестве особого случая, когда f равно 0, setfenv изменяет среду работающего потока. В этом случае setfenv не возвращает значений. |
19 | setmetatable (table, metatable) Устанавливает метатаблицу для данной таблицы. (Вы не можете изменить метатаблицу других типов из Lua, только из C.) Если метатаблица равна nil, удаляет метатаблицу данной таблицы. Если исходная метатаблица имеет поле «__metatable», возникает ошибка. Эта функция возвращает таблицу. |
20 | tonumber (e [, base]) Пытается преобразовать свой аргумент в число. Если аргумент уже является числом или строкой, конвертируемой в число, то tonumber возвращает это число; в противном случае возвращается ноль. |
21 год | tostring (e) Получает аргумент любого типа и преобразует его в строку разумного формата. Для полного контроля над преобразованием чисел используйте string.format. |
22 | type (v) Возвращает тип своего единственного аргумента, закодированного в виде строки. Возможные результаты этой функции: «nil» (строка, а не значение nil), «number», «string», «boolean», «table», «function», «thread» и «userdata». |
23 | unpack (list [, i [, j]]) Возвращает элементы из данной таблицы. |
24 | _VERSION Глобальная переменная (не функция), которая содержит строку, содержащую текущую версию интерпретатора. Текущее содержимое этой переменной - «Lua 5.1». |
25 | Coroutines Включает функции манипулирования сопрограммами, как описано в Lua - Coroutines . |
Библиотека модулей
Библиотека модулей предоставляет основные функции для загрузки модулей в Lua. Он экспортирует одну функцию непосредственно в глобальную среду: require. Все остальное экспортируется в табличном пакете. Подробности о библиотеке модулей объяснены в предыдущей главе Lua - Учебник по модулям .
Строковые манипуляции
Lua предоставляет богатый набор функций для работы со строками. В предыдущем руководстве по Lua - Strings это подробно описано.
Манипуляции с таблицей
Lua зависит от таблиц почти во всех своих операциях. В предыдущем руководстве по Lua - Tables это подробно описано.
Файловый ввод и вывод
Нам часто требуется хранилище данных при программировании, и это обеспечивается стандартными библиотечными функциями для файлового ввода-вывода в Lua. Это обсуждалось в предыдущем руководстве Lua - File I / O.
Средства отладки
Lua предоставляет библиотеку отладки, которая предоставляет нам все примитивные функции для создания нашего собственного отладчика. Это обсуждалось в предыдущем руководстве по Lua - Отладка .
Нам часто нужны математические операции в научных и инженерных расчетах, и мы можем воспользоваться этим, используя стандартную математическую библиотеку Lua. Список функций, доступных в математической библиотеке, показан в следующей таблице.
Sr.No. | Библиотека / Метод и цель |
---|---|
1 | math.abs (x) Возвращает абсолютное значение x. |
2 | math.acos (x) Возвращает арккосинус x (в радианах). |
3 | math.asin (x) Возвращает арксинус x (в радианах). |
4 | math.atan (x) Возвращает арктангенс x (в радианах). |
5 | math.atan2 (y, x) Возвращает арктангенс y / x (в радианах), но использует знаки обоих параметров, чтобы найти квадрант результата. (Он также правильно обрабатывает случай, когда x равен нулю.) |
6 | math.ceil (x) Возвращает наименьшее целое число, большее или равное x. |
7 | math.cos (x) Возвращает косинус x (предполагается, что он выражен в радианах). |
8 | math.cosh (x) Возвращает гиперболический косинус x. |
9 | math.deg (x) Возвращает угол x (в радианах) в градусах. |
10 | math.exp (x) Возвращает значение e power x. |
11 | math.floor (x) Возвращает наибольшее целое число, меньшее или равное x. |
12 | math.fmod (x, y) Возвращает остаток от деления x на y, округляющий частное до нуля. |
13 | math.frexp (x) Возвращает m и e так, что x = m2e, e является целым числом, а абсолютное значение m находится в диапазоне [0,5, 1) (или ноль, если x равно нулю). |
14 | math.huge Значение HUGE_VAL, значение больше или равное любому другому числовому значению. |
15 | math.ldexp (m, e) Возвращает m2e (e должно быть целым числом). |
16 | math.log (x) Возвращает натуральный логарифм x. |
17 | math.log10 (x) Возвращает десятичный логарифм числа x. |
18 | math.max (x, ...) Возвращает максимальное значение среди своих аргументов. |
19 | math.min (x, ...) Возвращает минимальное значение среди своих аргументов. |
20 | math.modf (x) Возвращает два числа: целую часть x и дробную часть x. |
21 год | math.pi Значение пи. |
22 | math.pow (x, y) Возвращает xy. (Вы также можете использовать выражение x ^ y для вычисления этого значения.) |
23 | math.rad (x) Возвращает угол x (в градусах) в радианах. |
24 | math.random ([m [, n]]) Эта функция является интерфейсом к простой функции псевдослучайного генератора rand, предоставляемой ANSI C. При вызове без аргументов возвращает однородное псевдослучайное действительное число в диапазоне [0,1). При вызове с целым числом m math.random возвращает однородное псевдослучайное целое число в диапазоне [1, m]. При вызове с двумя целыми числами m и n math.random возвращает однородное псевдослучайное целое число в диапазоне [m, n]. |
25 | math.randomseed (x) Устанавливает x как «начальное число» для псевдослучайного генератора: равные начальные числа производят равные последовательности чисел. |
26 | math.sin (x) Возвращает синус x (предполагается, что он выражен в радианах). |
27 | math.sinh (x) Возвращает гиперболический синус x. |
28 | math.sqrt (x) Возвращает квадратный корень из x. (Вы также можете использовать выражение x ^ 0.5 для вычисления этого значения.) |
29 | math.tan (x) Возвращает тангенс x (предполагается, что он выражен в радианах). |
30 | math.tanh (x) Возвращает гиперболический тангенс x. |
Тригонометрические функции
Ниже показан простой пример использования тригонометрической функции.
radianVal = math.rad(math.pi / 2)
io.write(radianVal,"\n")
-- Sin value of 90(math.pi / 2) degrees
io.write(string.format("%.1f ", math.sin(radianVal)),"\n")
-- Cos value of 90(math.pi / 2) degrees
io.write(string.format("%.1f ", math.cos(radianVal)),"\n")
-- Tan value of 90(math.pi / 2) degrees
io.write(string.format("%.1f ", math.tan(radianVal)),"\n")
-- Cosh value of 90(math.pi / 2) degrees
io.write(string.format("%.1f ", math.cosh(radianVal)),"\n")
-- Pi Value in degrees
io.write(math.deg(math.pi),"\n")
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
0.027415567780804
0.0
1.0
0.0
1.0
180
Другие общие математические функции
Ниже показан простой пример использования общих математических функций.
-- Floor
io.write("Floor of 10.5055 is ", math.floor(10.5055),"\n")
-- Ceil
io.write("Ceil of 10.5055 is ", math.ceil(10.5055),"\n")
-- Square root
io.write("Square root of 16 is ",math.sqrt(16),"\n")
-- Power
io.write("10 power 2 is ",math.pow(10,2),"\n")
io.write("100 power 0.5 is ",math.pow(100,0.5),"\n")
-- Absolute
io.write("Absolute value of -10 is ",math.abs(-10),"\n")
--Random
math.randomseed(os.time())
io.write("Random number between 1 and 100 is ",math.random(),"\n")
--Random between 1 to 100
io.write("Random number between 1 and 100 is ",math.random(1,100),"\n")
--Max
io.write("Maximum in the input array is ",math.max(1,100,101,99,999),"\n")
--Min
io.write("Minimum in the input array is ",math.min(1,100,101,99,999),"\n")
Когда мы запустим вышеуказанную программу, мы получим следующий результат.
Floor of 10.5055 is 10
Ceil of 10.5055 is 11
Square root of 16 is 4
10 power 2 is 100
100 power 0.5 is 10
Absolute value of -10 is 10
Random number between 1 and 100 is 0.22876674703207
Random number between 1 and 100 is 7
Maximum in the input array is 999
Minimum in the input array is 1
Приведенные выше примеры - это лишь некоторые из распространенных примеров, мы можем использовать математическую библиотеку в зависимости от наших потребностей, поэтому попробуйте использовать все функции, чтобы быть более знакомыми.
В любом приложении он часто требуется для доступа к функциям уровня операционной системы, и он предоставляется с помощью библиотеки операционной системы. Список доступных функций приведен в следующей таблице.
Sr.No. | Библиотека / Метод и цель |
---|---|
1 | os.clock () Возвращает приблизительное количество процессорного времени в секундах, использованного программой. |
2 | os.date ([format [, time]]) Возвращает строку или таблицу, содержащую дату и время, отформатированные в соответствии с заданным форматом строки. |
3 | os.difftime (t2, t1) Возвращает количество секунд от момента t1 до момента t2. В POSIX, Windows и некоторых других системах это значение равно t2-t1. |
4 | os.execute ([command]) Эта функция эквивалентна системе функций ANSI C. Он передает команду для выполнения оболочкой операционной системы. Его первый результат - истина, если команда завершилась успешно, или ноль в противном случае. |
5 | os.exit ([code [, close]) Вызывает функцию выхода ANSI C для завершения хост-программы. Если код верен, возвращается статус EXIT_SUCCESS; если код ложный, возвращается статус EXIT_FAILURE; если код - это число, возвращаемый статус - это число. |
6 | os.getenv (varname) Возвращает значение переменной среды процесса varname или nil, если переменная не определена. |
7 | os.remove (filename) Удаляет файл (или пустой каталог в системах POSIX) с заданным именем. Если эта функция не работает, она возвращает ноль плюс строку с описанием ошибки и ее код. |
8 | os.rename (oldname, newname) Переименовывает файл или каталог с именем oldname в newname. Если эта функция не работает, она возвращает ноль плюс строку с описанием ошибки и ее код. |
9 | os.setlocale (locale [, category]) Устанавливает текущий языковой стандарт программы. locale - это системно-зависимая строка, определяющая языковой стандарт; category - это необязательная строка, описывающая, какую категорию следует изменить: «all», «collate», «ctype», «monetary», «numeric» или «time»; категория по умолчанию - «все». Функция возвращает имя новой локали или ноль, если запрос не может быть выполнен. |
10 | os.time ([table]) Возвращает текущее время при вызове без аргументов или время, представляющее дату и время, указанные в данной таблице. В этой таблице должны быть поля год, месяц и день, а также могут быть поля: час (по умолчанию 12), мин (по умолчанию 0), сек (по умолчанию 0) и isdst (по умолчанию ноль). Описание этих полей см. В функции os.date. |
11 | os.tmpname () Возвращает строку с именем файла, которое можно использовать для временного файла. Файл должен быть явно открыт перед его использованием и явно удален, когда он больше не нужен. |
Общие функции ОС
Ниже показан простой пример использования общих математических функций.
-- Date with format
io.write("The date is ", os.date("%m/%d/%Y"),"\n")
-- Date and time
io.write("The date and time is ", os.date(),"\n")
-- Time
io.write("The OS time is ", os.time(),"\n")
-- Wait for some time
for i=1,1000000 do
end
-- Time since Lua started
io.write("Lua started before ", os.clock(),"\n")
Когда мы запустим вышеуказанную программу, мы получим результат, аналогичный приведенному ниже.
The date is 01/25/2014
The date and time is 01/25/14 07:38:40
The OS time is 1390615720
Lua started before 0.013
Приведенные выше примеры - это лишь некоторые из общих примеров, мы можем использовать библиотеку ОС в зависимости от наших потребностей, поэтому попробуйте использовать все функции, чтобы быть более знакомыми. Есть функции, такие как remove, который помогает удалить файл, execute, который помогает нам выполнять команды ОС, как описано выше.