Lua — Обзор
Lua — это расширяемый, легкий язык программирования, написанный на языке C. Он начался как собственный проект в 1993 году Роберто Иерусалимши, Луиса Энрике де Фигейредо и Вальдемара Селеса.
С самого начала оно было разработано как программное обеспечение, которое может быть интегрировано с кодом, написанным на C и других традиционных языках. Эта интеграция приносит много преимуществ. Он не пытается делать то, что C уже может сделать, но стремится предложить то, что C не очень хорошо: хорошее расстояние от аппаратного обеспечения, динамические структуры, отсутствие избыточности, простота тестирования и отладки. Для этого Lua имеет безопасную среду, автоматическое управление памятью и хорошие возможности для обработки строк и других видов данных с динамическим размером.
Характеристики
Lua предоставляет набор уникальных функций, которые отличают его от других языков. К ним относятся —
- растяжимый
- просто
- эффективное
- портативный
- Свободно и открыто
Пример кода
print("Hello World!")
Как реализуется Lua?
Lua состоит из двух частей — части интерпретатора Lua и функционирующей системы программного обеспечения. Функциональная система программного обеспечения — это реальное компьютерное приложение, которое может интерпретировать программы, написанные на языке программирования Lua. Интерпретатор Lua написан на языке ANSI C, поэтому он очень переносим и может работать на широком спектре устройств — от высокопроизводительных сетевых серверов до небольших устройств.
И язык Луа, и его переводчик зрелые, маленькие и быстрые. Он произошел от других языков программирования и высочайших стандартов программного обеспечения. Небольшой размер позволяет запускать его на небольших устройствах с небольшим объемом памяти.
Учим Луа
Самый важный момент при изучении Lua — это сосредоточиться на концепциях, не теряясь в технических деталях.
Цель изучения языка программирования — стать лучшим программистом; то есть, чтобы стать более эффективным в разработке и внедрении новых систем и в поддержании старых.
Некоторые варианты использования Lua
-
Программирование игр
-
Сценарии в автономных приложениях
-
Сценарии в Интернете
-
Расширения и дополнения для баз данных, таких как MySQL Proxy и MySQL WorkBench
-
Системы безопасности, такие как система обнаружения вторжений.
Программирование игр
Сценарии в автономных приложениях
Сценарии в Интернете
Расширения и дополнения для баз данных, таких как 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 разработана отдельная среда разработки под названием «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, IDE Lua является IDE по умолчанию, предоставляемой командой создателей Lua. Доступна альтернативная IDE от ZeroBrane Studio, которая доступна на нескольких платформах, таких как Windows, Mac и Linux.
Есть также плагины для затмения, которые позволяют разработку Lua. Использование IDE облегчает разработку благодаря таким функциям, как завершение кода, и настоятельно рекомендуется. Среда IDE также обеспечивает программирование в интерактивном режиме, аналогичное версии Lua для командной строки.
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")
Здесь мы предположили, что в вашем каталоге / usr / local / bin есть интерпретатор Lua. Первая строка игнорируется интерпретатором, если она начинается со знака #. Теперь попробуйте запустить эту программу следующим образом:
$ chmod a+rx test.lua $./test.lua
Мы получим следующий вывод.
test
Давайте теперь посмотрим на базовую структуру программы 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-идентификатор — это имя, используемое для идентификации переменной, функции или любого другого пользовательского элемента. Идентификатор начинается с буквы «от А до Я» или «от А до Я» или со знака подчеркивания «_», за которым следуют ноль или более букв, подчеркиваний и цифр (от 0 до 9).
Lua не допускает знаки препинания, такие как @, $ и% в идентификаторах. Lua — чувствительный к регистру язык программирования. Таким образом, рабочая сила и рабочая сила — два разных идентификатора в Lua. Вот несколько примеров допустимых идентификаторов:
mohd zara abc move_name a_123 myname50 _temp j a23b9 retVal
Ключевые слова
Следующий список показывает несколько зарезервированных слов в Lua. Эти зарезервированные слова не могут использоваться в качестве констант или переменных или любых других имен идентификаторов.
а также | перерыв | делать | еще |
ElseIf | конец | ложный | за |
функция | если | в | местный |
ноль | не | или же | повторение |
вернуть | затем | правда | до тех пор |
в то время как |
Пробелы в Луа
Строка, содержащая только пробел, возможно, с комментарием, называется пустой строкой, и интерпретатор Lua полностью игнорирует ее.
Пробел — это термин, используемый в Lua для описания пробелов, вкладок, символов новой строки и комментариев. Пробелы отделяют одну часть оператора от другой и позволяют интерпретатору определить, где заканчивается один элемент в выражении, например, int, и начинается следующий элемент. Поэтому в следующем утверждении —
local age
Должен быть хотя бы один пробельный символ (обычно пробел) между местным и возрастом, чтобы переводчик мог их различить. С другой стороны, в следующем утверждении —
fruit = apples + oranges --get the total fruit
Никаких пробельных символов не требуется между фруктами и = или между = и яблоками, хотя вы можете включить некоторые из них, если хотите, чтобы они были удобочитаемыми.
Lua — переменные
Переменная — это не что иное, как имя, данное области памяти, которой могут манипулировать наши программы. Он может содержать различные типы значений, включая функции и таблицы.
Имя переменной может состоять из букв, цифр и символа подчеркивания. Он должен начинаться либо с буквы, либо с подчеркивания. Прописные и строчные буквы различны, потому что Lua чувствителен к регистру. В Lua есть восемь основных типов ценностей:
В Lua, хотя у нас нет переменных типов данных, у нас есть три типа, основанные на области действия переменной.
-
Глобальные переменные — все переменные считаются глобальными, если они явно не объявлены как локальные.
-
Локальные переменные — когда тип указан как локальный для переменной, тогда его область действия ограничена функциями внутри их области.
-
Поля таблицы — это специальный тип переменной, который может содержать все, кроме nil, включая функции.
Глобальные переменные — все переменные считаются глобальными, если они явно не объявлены как локальные.
Локальные переменные — когда тип указан как локальный для переменной, тогда его область действия ограничена функциями внутри их области.
Поля таблицы — это специальный тип переменной, который может содержать все, кроме nil, включая функции.
Определение переменной в Lua
Определение переменной означает сообщить интерпретатору, где и сколько создать хранилище для переменной. Определение переменной имеет необязательный тип и содержит список из одной или нескольких переменных этого типа следующим образом:
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. В приведенном выше примере локального 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 относится к значению данных, которое хранится по некоторому адресу в памяти. Значение r — это выражение, которому не может быть присвоено значение, что означает, что значение r может появляться в правой части, но не в левой части присваивания.
lvalue — Выражения, которые ссылаются на ячейку памяти, называются выражением «lvalue». Lvalue может отображаться как левая или правая сторона задания.
rvalue — термин rvalue относится к значению данных, которое хранится по некоторому адресу в памяти. Значение r — это выражение, которому не может быть присвоено значение, что означает, что значение r может появляться в правой части, но не в левой части присваивания.
Переменные являются lvalues и могут отображаться в левой части назначения. Числовые литералы являются r-значениями и поэтому не могут быть назначены и не могут отображаться слева. Следующее является действительным утверждением —
g = 20
Но следующее не является действительным утверждением и может привести к ошибке времени сборки —
10 = 20
В языке программирования Lua, помимо вышеупомянутых типов присваивания, можно иметь несколько значений l и r в одном и том же операторе. Это показано ниже.
g,l = 20,30
В приведенном выше утверждении 20 назначено для g и 30 назначено для l.
Lua — Типы данных
Lua — это язык с динамической типизацией, поэтому переменные не имеют типов, только значения имеют типы. Значения могут храниться в переменных, передаваться как параметры и возвращаться как результаты.
В Lua, хотя у нас нет переменных типов данных, но у нас есть типы для значений. Список типов данных для значений приведен ниже.
Sr.No | Тип значения и описание |
---|---|
1 |
ноль Используется для дифференциации значения от наличия данных или отсутствия (ноль) данных. |
2 |
логический Включает в себя значения true и false как значения. Обычно используется для проверки состояния. |
3 |
число Представляет действительные числа (числа с плавающей запятой двойной точности). |
4 |
строка Представляет массив символов. |
5 |
функция Представляет метод, который написан на C или Lua. |
6 |
данные пользователя Представляет произвольные данные Си. |
7 |
нить Представляет независимые потоки выполнения и используется для реализации сопрограмм. |
8 |
Таблица Представляет обычные массивы, таблицы символов, наборы, записи, графики, деревья и т. Д. И реализует ассоциативные массивы. Может содержать любое значение (кроме нуля). |
ноль
Используется для дифференциации значения от наличия данных или отсутствия (ноль) данных.
логический
Включает в себя значения true и false как значения. Обычно используется для проверки состояния.
число
Представляет действительные числа (числа с плавающей запятой двойной точности).
строка
Представляет массив символов.
функция
Представляет метод, который написан на C или Lua.
данные пользователя
Представляет произвольные данные Си.
нить
Представляет независимые потоки выполнения и используется для реализации сопрограмм.
Таблица
Представляет обычные массивы, таблицы символов, наборы, записи, графики, деревья и т. Д. И реализует ассоциативные массивы. Может содержать любое значение (кроме нуля).
Тип Функция
В 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, тогда —
оператор | Описание | пример |
---|---|---|
+ | Добавляет два операнда | А + Б даст 30 |
— | Вычитает второй операнд из первого | A — B даст -10 |
* | Умножьте оба операнда | А * Б даст 200 |
/ | Разделите числитель на числитель | Б / у даст 2 |
% | Оператор модуля и остаток от целочисленного деления | B% A даст 0 |
^ | Экспонент Оператор принимает экспоненты | А ^ 2 даст 100 |
— | Унарный — оператор действует как отрицание | -А даст -10 |
Операторы отношений
Следующая таблица показывает все реляционные операторы, поддерживаемые языком Lua. Предположим, что переменная A содержит 10, а переменная B содержит 20, тогда —
оператор | Описание | пример |
---|---|---|
== | Проверяет, равны ли значения двух операндов или нет, если да, тогда условие становится истинным. | (A == B) не соответствует действительности. |
~ = | Проверяет, равны ли значения двух операндов или нет, если значения не равны, тогда условие становится истинным. | (A ~ = B) верно. |
> | Проверяет, больше ли значение левого операнда, чем значение правого операнда, если да, тогда условие становится истинным. | (A> B) не соответствует действительности. |
< | Проверяет, меньше ли значение левого операнда, чем значение правого операнда, если да, тогда условие становится истинным. | (A <B) верно. |
> = | Проверяет, больше ли значение левого операнда или равно значению правого операнда, если да, тогда условие становится истинным. | (A> = B) не соответствует действительности. |
<= | Проверяет, меньше ли значение левого операнда или равно значению правого операнда, если да, тогда условие становится истинным. | (A <= B) верно. |
Логические Операторы
В следующей таблице приведены все логические операторы, поддерживаемые языком Lua. Предположим, что переменная A имеет значение true, а переменная B содержит значение false тогда —
оператор | Описание | пример |
---|---|---|
а также | Называется логический оператор И. Если оба операнда отличны от нуля, условие становится истинным. | (А и В) ложно. |
или же | Вызывается логическим оператором ИЛИ. Если любой из двух операндов отличен от нуля, условие становится истинным. | (А или В) это правда. |
не | Вызывается логическим оператором НЕ. Используйте для изменения логического состояния своего операнда. Если условие истинно, то оператор Логический НЕ будет делать ложь. | ! (А и Б) это правда. |
Разные Операторы
Различные операторы, поддерживаемые Lua Language, включают конкатенацию и длину .
оператор | Описание | пример |
---|---|---|
.. | Объединяет две строки. | a..b, где a — «Hello», а b — «World», вернет «Hello World». |
# | Унарный оператор, который возвращает длину строки или таблицы. | # «Привет» вернется 5 |
Приоритет операторов в Lua
Приоритет оператора определяет группировку терминов в выражении. Это влияет на то, как оценивается выражение. Некоторые операторы имеют более высокий приоритет, чем другие; например, оператор умножения имеет более высокий приоритет, чем оператор сложения —
Например, х = 7 + 3 * 2; Здесь x назначено 13, а не 20, потому что оператор * имеет более высокий приоритет, чем +, поэтому он сначала умножается на 3 * 2, а затем прибавляется к 7.
Здесь операторы с самым высоким приоритетом отображаются вверху таблицы, а операторы с самым низким — внизу. Внутри выражения операторы с более высоким приоритетом будут оцениваться первыми.
категория | оператор | Ассоциативность |
---|---|---|
Одинарный | не № — | Справа налево |
конкатенация | .. | Справа налево |
Multiplicative | * /% | Слева направо |
присадка | + — | Слева направо |
реляционный | <> <=> = == ~ = | Слева направо |
равенство | == ~ = | Слева направо |
Логическое И | а также | Слева направо |
Логическое ИЛИ | или же | Слева направо |
Луа — Петли
Может возникнуть ситуация, когда вам нужно выполнить блок кода несколько раз. В общем случае операторы выполняются последовательно: первый оператор в функции выполняется первым, затем второй и так далее.
Языки программирования предоставляют различные управляющие структуры, которые допускают более сложные пути выполнения.
Оператор цикла позволяет нам выполнять оператор или группу операторов несколько раз. Ниже приводится общая форма оператора цикла в большинстве языков программирования:
Lua предоставляет следующие типы циклов для обработки требований циклов.
Sr.No. | Тип и описание петли |
---|---|
1 | в то время как цикл
Повторяет оператор или группу операторов, пока данное условие выполняется. Он проверяет условие перед выполнением тела цикла. |
2 | для цикла
Выполняет последовательность операторов несколько раз и сокращает код, который управляет переменной цикла. |
3 | повторить … пока не получится
Повторяет операцию группы операторов до тех пор, пока не будет выполнено условие. |
4 | вложенные циклы
Вы можете использовать один или несколько циклов внутри любого другого цикла while, for или do.. while. |
Повторяет оператор или группу операторов, пока данное условие выполняется. Он проверяет условие перед выполнением тела цикла.
Выполняет последовательность операторов несколько раз и сокращает код, который управляет переменной цикла.
Повторяет операцию группы операторов до тех пор, пока не будет выполнено условие.
Вы можете использовать один или несколько циклов внутри любого другого цикла while, for или do.. while.
Loop Control Statement
Оператор управления циклом изменяет выполнение от своей обычной последовательности. Когда выполнение покидает область действия, все автоматические объекты, созданные в этой области, уничтожаются.
Lua поддерживает следующие контрольные операторы.
Sr.No. | Контрольное заявление и описание |
---|---|
1 | заявление о нарушении
Завершает цикл и передает выполнение оператору сразу после цикла или переключателя. |
Завершает цикл и передает выполнение оператору сразу после цикла или переключателя.
Бесконечный цикл
Цикл становится бесконечным, если условие никогда не становится ложным. Цикл while часто используется для этой цели. Поскольку мы прямо выражаем истинность условия, оно выполняется вечно. Мы можем использовать оператор break, чтобы разорвать этот цикл.
while( true ) do print("This loop will run forever.") end
Луа — Принятие решений
Структуры принятия решений требуют, чтобы программист определял одно или несколько условий, которые должны быть оценены или протестированы программой, вместе с оператором или инструкциями, которые должны быть выполнены, если условие определено как истинное, и, необязательно, другие операторы, которые должны быть выполнены, если условие определяется как ложное.
Ниже приводится общая форма типичной структуры принятия решений, встречающейся в большинстве языков программирования.
Язык программирования Lua предполагает любую комбинацию логических значений true и не-nil как true , и если это либо логическое значение false, либо nil , то оно принимается за значение false . Следует отметить, что в Lua ноль будет считаться истинным.
Язык программирования Lua предоставляет следующие типы операторов принятия решений.
Sr.No. | Заявление и описание |
---|---|
1 | если заявление
Оператор if состоит из логического выражения, за которым следует одно или несколько операторов. |
2 | если … еще заявление
За оператором if может следовать необязательный оператор else , который выполняется, когда логическое выражение имеет значение false. |
3 | вложенные операторы if
Вы можете использовать один оператор if или else if внутри другого оператора if или else if . |
Оператор if состоит из логического выражения, за которым следует одно или несколько операторов.
За оператором if может следовать необязательный оператор else , который выполняется, когда логическое выражение имеет значение false.
Вы можете использовать один оператор if или else if внутри другого оператора if или else if .
Lua — Функции
Функция — это группа операторов, которые вместе выполняют задачу. Вы можете разделить ваш код на отдельные функции. Как вы делите свой код между различными функциями, зависит от вас, но логически разделение обычно уникально, поэтому каждая функция выполняет определенную задачу.
Язык Lua предоставляет множество встроенных методов, которые может вызывать ваша программа. Например, метод print () для печати аргумента, переданного в качестве ввода в консоли.
Функция известна под разными именами, например, метод, подпрограмма, процедура и т. Д.
Определение функции
Общая форма определения метода в языке программирования Lua выглядит следующим образом:
optional_function_scope function function_name( argument1, argument2, argument3........, argumentn) function_body return result_params_comma_separated end
Определение метода в языке программирования Lua состоит из заголовка метода и тела метода . Вот все части метода —
-
Необязательная область действия функции. Вы можете использовать ключевое слово local, чтобы ограничить область действия функции или игнорировать раздел области действия, что сделает ее глобальной функцией.
-
Имя функции — это фактическое имя функции. Имя функции и список параметров вместе составляют сигнатуру функции.
-
Аргументы — Аргумент похож на заполнитель. Когда вызывается функция, вы передаете значение аргументу. Это значение называется фактическим параметром или аргументом. Список параметров относится к типу, порядку и количеству аргументов метода. Аргументы необязательны; то есть метод может не содержать аргументов.
-
Тело функции — Тело метода содержит коллекцию операторов, которые определяют, что делает метод.
-
Return — в Lua можно вернуть несколько значений, следуя ключевому слову return с возвращаемыми значениями через запятую.
Необязательная область действия функции. Вы можете использовать ключевое слово local, чтобы ограничить область действия функции или игнорировать раздел области действия, что сделает ее глобальной функцией.
Имя функции — это фактическое имя функции. Имя функции и список параметров вместе составляют сигнатуру функции.
Аргументы — Аргумент похож на заполнитель. Когда вызывается функция, вы передаете значение аргументу. Это значение называется фактическим параметром или аргументом. Список параметров относится к типу, порядку и количеству аргументов метода. Аргументы необязательны; то есть метод может не содержать аргументов.
Тело функции — Тело метода содержит коллекцию операторов, которые определяют, что делает метод.
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
Аргументы функции
Если функция должна использовать аргументы, она должна объявлять переменные, которые принимают значения аргументов. Эти переменные называются формальными параметрами функции.
Формальные параметры ведут себя как другие локальные переменные внутри функции и создаются при входе в функцию и уничтожаются при выходе.
Вызов функции
При создании функции 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-последовательности используются в строке для изменения обычной интерпретации символов. Например, чтобы напечатать двойные кавычки («»), мы использовали \ «в приведенном выше примере. Экранирующая последовательность и ее использование перечислены ниже в таблице.
Последовательность побега | использование |
---|---|
\ а | колокол |
\ б | возврат на одну позицию |
\ е | Под.стр |
\ п | Новая линия |
\р | Возврат каретки |
\ т | табуляция |
\ v | Вертикальная вкладка |
\\ | бэкслэш |
\» | Двойные кавычки |
\» | Одинарные кавычки |
\ [ | Левая квадратная скобка |
\] | Правая квадратная скобка |
Манипуляция строк
Lua поддерживает строку для работы со строками —
Sr.No. | Метод и цель |
---|---|
1 |
string.upper (аргумент) Возвращает заглавное представление аргумента. |
2 |
string.lower (аргумент) Возвращает строчное представление аргумента. |
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) и string.byte (arg) Возвращает внутренние числовые и символьные представления входного аргумента. |
8 |
string.len (Arg) Возвращает длину переданной строки. |
9 |
string.rep (string, n)) Возвращает строку, повторяя одну и ту же строку n раз. |
10 |
.. Таким образом, оператор объединяет две строки. |
string.upper (аргумент)
Возвращает заглавное представление аргумента.
string.lower (аргумент)
Возвращает строчное представление аргумента.
string.gsub (mainString, FindString, replaceString)
Возвращает строку путем замены вхождений findString на replaceString.
string.find (mainString, FindString,
optionalStartIndex, optionalEndIndex)
Возвращает начальный индекс и конечный индекс findString в основной строке и nil, если не найден.
string.reverse (Arg)
Возвращает строку путем обращения символов переданной строки.
String.Format (…)
Возвращает отформатированную строку.
string.char (arg) и string.byte (arg)
Возвращает внутренние числовые и символьные представления входного аргумента.
string.len (Arg)
Возвращает длину переданной строки.
string.rep (string, n))
Возвращает строку, повторяя одну и ту же строку n раз.
..
Таким образом, оператор объединяет две строки.
Теперь давайте рассмотрим несколько примеров, чтобы точно увидеть, как ведут себя эти функции манипуляции со строками.
Манипуляция делами
Пример кода для управления строками в верхнем и нижнем регистре приведен ниже.
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 — Итераторы
Итератор — это конструкция, позволяющая перемещаться по элементам так называемой коллекции или контейнера. В Lua эти коллекции часто ссылаются на таблицы, которые используются для создания различных структур данных, таких как массив.
Универсальный для Итератора
Универсальный для итератора предоставляет пары ключ-значение каждого элемента в коллекции. Простой пример приведен ниже.
array = {"Lua", "Tutorial"} for key,value in ipairs(array) do print(key, value) end
Когда мы запустим приведенный выше код, мы получим следующий вывод:
1 Lua 2 Tutorial
В приведенном выше примере используется итератор ipairs по умолчанию, предоставленный Lua.
В Lua мы используем функции для представления итераторов. Основываясь на поддержании состояния в этих функциях итератора, мы имеем два основных типа:
- Итераторы без состояния
- Stateful Iterators
Итераторы без состояния
По самому имени мы можем понять, что этот тип функции итератора не сохраняет никакого состояния.
Давайте теперь посмотрим на пример создания нашего собственного итератора, используя простую функцию, которая печатает квадраты 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
Stateful Iterators
Предыдущий пример итерации с использованием функции не сохраняет состояние. Каждый раз, когда вызывается функция, она возвращает следующий элемент коллекции на основе второй переменной, отправленной в функцию. Для хранения состояния текущего элемента используются замыкания. Закрытие сохраняет значения переменных через вызовы функций. Чтобы создать новое замыкание, мы создаем две функции, включая само замыкание и фабрику, функцию, которая создает замыкание.
Давайте теперь посмотрим на пример создания нашего собственного итератора, в котором мы будем использовать замыкания.
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 есть еще один метод, который использует индекс локальных внешних переменных и count для возврата каждого элемента в коллекции путем увеличения индекса каждый раз, когда вызывается функция.
Мы можем создавать свои собственные итераторы функций, используя замыкание, как показано выше, и оно может возвращать несколько элементов для каждого итерации цикла.
Луа — Столы
Вступление
Таблицы — единственная структура данных, доступная в Lua, которая помогает нам создавать различные типы, такие как массивы и словари. Lua использует ассоциативные массивы, которые можно индексировать не только числами, но и строками, кроме nil. Таблицы не имеют фиксированного размера и могут расти в зависимости от наших потребностей.
Lua использует таблицы во всех представлениях, включая представление пакетов. Когда мы обращаемся к методу string.format, это означает, что мы обращаемся к функции форматирования, доступной в пакете string.
Представление и использование
Таблицы называются объектами и не являются ни значениями, ни переменными. 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("mytable 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 mytable 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 (таблица, [pos,] значение) Вставляет значение в таблицу в указанной позиции. |
3 |
table.maxn (таблица) Возвращает самый большой числовой индекс. |
4 |
table.remove (таблица [, pos]) Удаляет значение из таблицы. |
5 |
table.sort (table [, comp]) Сортирует таблицу на основе необязательного аргумента компаратора. |
table.concat (table [, sep [, i [, j]]])
Объединяет строки в таблицах на основе заданных параметров. Смотрите пример для деталей.
table.insert (таблица, [pos,] значение)
Вставляет значение в таблицу в указанной позиции.
table.maxn (таблица)
Возвращает самый большой числовой индекс.
table.remove (таблица [, pos])
Удаляет значение из таблицы.
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
Lua — модули
Что такое модуль?
Модуль похож на библиотеку, которая может быть загружена с помощью 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.lua, а имя файла — 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, и, следовательно, модуль должен быть предпочтительно реализован, как показано выше, даже если вы можете найти другие типы реализаций в другом месте.
Поместите оба модуля и файл, который вы запускаете, в один каталог.
Имя модуля и его имя файла должны совпадать.
Рекомендуется возвращать модули для функции 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 — Metatables
Метатабельная таблица — это таблица, которая помогает изменить поведение таблицы, к которой она присоединена, с помощью набора ключей и связанных мета-методов. Эти мета-методы являются мощной функциональностью Lua, которая включает такие функции, как —
-
Изменение / добавление функций к операторам на таблицах.
-
Поиск метатаблиц, когда ключ недоступен в таблице, с помощью __index в метатаблице.
Изменение / добавление функций к операторам на таблицах.
Поиск метатаблиц, когда ключ недоступен в таблице, с помощью __index в метатаблице.
Есть два важных метода, которые используются в обработке метатаблиц, которые включают в себя:
-
setmetatable (table, metatable) — этот метод используется для установки метатаблицы для таблицы.
-
getmetatable (table) — этот метод используется для получения метатаблицы таблицы.
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 здесь {key1 = «value1»} .
Metatable устанавливается для mytable, который содержит функцию для __index, которую мы называем метаметодом.
Метаметод выполняет простую работу по поиску индекса «key2», если он найден, он возвращает «metatablevalue», в противном случае возвращает значение mytable для соответствующего индекса.
У нас может быть упрощенная версия вышеуказанной программы, как показано ниже.
mytable = setmetatable({key1 = "value1"}, { __index = { key2 = "metatablevalue" } }) print(mytable.key1,mytable.key2)
__newindex
Когда мы добавляем __newindex в metatable, если ключи не доступны в таблице, поведение новых ключей будет определяться мета-методами. Простой пример, когда индекс метатаблицы устанавливается, когда индекс не доступен в основной таблице, приведен ниже.
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
Вы можете видеть в приведенной выше программе, если ключ существует в основной таблице, он просто обновляет его. Когда ключ недоступен в maintable, он добавляет этот ключ в метатаблицу.
Другой пример, который обновляет ту же таблицу с помощью функции 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 для metatable. Точно так же есть 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 включен в metatable для добавления поведения оператора +. Таблица ключей и соответствующего оператора показана ниже.
Sr.No. | Режим и описание |
---|---|
1 |
__добавлять Изменяет поведение оператора ‘+’. |
2 |
__sub Изменяет поведение оператора ‘-‘. |
3 |
__mul Изменяет поведение оператора ‘*’. |
4 |
__div Изменяет поведение оператора ‘/’. |
5 |
__mod Изменяет поведение оператора «%». |
6 |
__unm Изменяет поведение оператора ‘-‘. |
7 |
__concat Изменяет поведение оператора ‘..’. |
8 |
__eq Изменяет поведение оператора ‘==’. |
9 |
__lt Изменяет поведение оператора ‘<‘. |
10 |
__le Изменяет поведение оператора ‘<=’. |
__добавлять
Изменяет поведение оператора ‘+’.
__sub
Изменяет поведение оператора ‘-‘.
__mul
Изменяет поведение оператора ‘*’.
__div
Изменяет поведение оператора ‘/’.
__mod
Изменяет поведение оператора «%».
__unm
Изменяет поведение оператора ‘-‘.
__concat
Изменяет поведение оператора ‘..’.
__eq
Изменяет поведение оператора ‘==’.
__lt
Изменяет поведение оператора ‘<‘.
__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
__нанизывать
Чтобы изменить поведение оператора print, мы можем использовать метаметод __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
Если вы полностью знакомы с возможностями мета-таблицы, вы действительно можете выполнить множество операций, которые были бы очень сложными без ее использования. Поэтому постарайтесь больше работать над использованием метатаблиц с различными опциями, доступными в мета таблицах, как описано в примерах, а также создавайте свои собственные образцы.
Луа — сопрограммы
Вступление
Сопрограммы по своей природе являются совместными, что позволяет двум или более методам выполняться контролируемым образом. С сопрограммами в любой момент времени выполняется только одна сопрограмма, и эта запущенная сопрограмма только приостанавливает свое выполнение, когда она явно запрашивает приостановку.
Приведенное выше определение может выглядеть расплывчато. Предположим, у нас есть два метода, один из которых является основным методом программы и сопрограммой. Когда мы вызываем сопрограмму с помощью функции resume, она начинает выполняться, а когда мы вызываем функцию yield, она приостанавливает выполнение. Снова та же самая сопрограмма может продолжить выполнение с другим вызовом функции возобновления, с которого это было приостановлено. Этот процесс может продолжаться до конца выполнения сопрограммы.
Функции, доступные в сопрограммах
В следующей таблице перечислены все доступные функции для сопрограмм в Lua и их соответствующее использование.
Sr.No. | Метод и цель |
---|---|
1 |
coroutine.create (f) Создает новую сопрограмму с функцией f и возвращает объект типа «поток». |
2 |
coroutine.resume (co [, val1, …]) Возобновляет сопрограмму co и передает параметры, если таковые имеются. Возвращает статус операции и необязательные другие возвращаемые значения. |
3 |
coroutine.running () Возвращает запущенную сопрограмму или ноль, если вызывается в основном потоке. |
4 |
coroutine.status (со) Возвращает одно из значений: запущено, нормально, приостановлено или не работает в зависимости от состояния сопрограммы. |
5 |
coroutine.wrap (f) Как и coroutine.create, функция coroutine.wrap также создает сопрограмму, но вместо возврата самой сопрограммы она возвращает функцию, которая при вызове возобновляет сопрограмму. |
6 |
coroutine.yield (…) Приостанавливает запущенную сопрограмму. Параметр, передаваемый этому методу, действует как дополнительные возвращаемые значения функции возобновления. |
coroutine.create (f)
Создает новую сопрограмму с функцией f и возвращает объект типа «поток».
coroutine.resume (co [, val1, …])
Возобновляет сопрограмму co и передает параметры, если таковые имеются. Возвращает статус операции и необязательные другие возвращаемые значения.
coroutine.running ()
Возвращает запущенную сопрограмму или ноль, если вызывается в основном потоке.
coroutine.status (со)
Возвращает одно из значений: запущено, нормально, приостановлено или не работает в зависимости от состояния сопрограммы.
coroutine.wrap (f)
Как и coroutine.create, функция coroutine.wrap также создает сопрограмму, но вместо возврата самой сопрограммы она возвращает функцию, которая при вызове возобновляет сопрограмму.
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 и оператор «не может возобновить мертвую сопрограмму» в качестве ответа.
Сначала мы создаем сопрограмму и присваиваем ей имя переменной co, и сопрограмма принимает в качестве параметров две переменные.
Когда мы вызываем первую функцию возобновления, значения 3 и 2 сохраняются во временных переменных value1 и value2 до конца сопрограммы.
Чтобы вы поняли это, мы использовали tempvar3, который изначально равен 10, и он обновляется до 13 и 16 последующими вызовами сопрограмм, поскольку значение1 сохраняется как 3 на протяжении всего выполнения сопрограммы.
Первый файл coroutine.yield возвращает два значения 4 и 3 в функцию возобновления, которую мы получаем, обновляя входные параметры 3 и 2 в операторе yield. Он также получает истинный / ложный статус выполнения сопрограммы.
Еще одна вещь, связанная с сопрограммами, заключается в том, как обрабатываются следующие параметры вызова возобновления в приведенном выше примере; Вы можете видеть, что переменная coroutine.yield получает параметры следующего вызова, что обеспечивает мощный способ выполнения новой операции с сохранением существующих значений параметров.
Наконец, как только все операторы в сопрограммах будут выполнены, последующие вызовы вернутся в false и оператор «не может возобновить мертвую сопрограмму» в качестве ответа.
Другой пример сопрограммы
Давайте посмотрим на простую сопрограмму, которая возвращает число от 1 до 5 с помощью функции yield и функции resume. Он создает сопрограмму, если она недоступна, или возобновляет существующую сопрограмму.
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 — File I / O
Библиотека ввода / вывода используется для чтения и управления файлами в Lua. В Lua существует два вида файловых операций, а именно неявные файловые дескрипторы и явные файловые дескрипторы.
Для следующих примеров мы будем использовать пример файла test.lua, как показано ниже.
-- sample test.lua -- sample2 test.lua
Простая операция открытия файла использует следующее утверждение.
file = io.open (filename [, mode])
Различные режимы файлов перечислены в следующей таблице.
Sr.No. | Режим и описание |
---|---|
1 |
«р» Режим только для чтения. Это режим по умолчанию, в котором открывается существующий файл. |
2 |
«ж» Режим записи включен, который перезаписывает существующий файл или создает новый файл. |
3 |
«а» Режим добавления, который открывает существующий файл или создает новый файл для добавления. |
4 |
«г +» Режим чтения и записи для существующего файла. |
5 |
«ш +» Все существующие данные удаляются, если файл существует или создается новый файл с разрешениями на чтение и запись. |
6 |
«а +» Режим добавления с включенным режимом чтения, который открывает существующий файл или создает новый файл. |
«р»
Режим только для чтения. Это режим по умолчанию, в котором открывается существующий файл.
«ж»
Режим записи включен, который перезаписывает существующий файл или создает новый файл.
«а»
Режим добавления, который открывает существующий файл или создает новый файл для добавления.
«г +»
Режим чтения и записи для существующего файла.
«ш +»
Все существующие данные удаляются, если файл существует или создается новый файл с разрешениями на чтение и запись.
«а +»
Режим добавления с включенным режимом чтения, который открывает существующий файл или создает новый файл.
Неявные файловые дескрипторы
Неявные файловые дескрипторы используют стандартные режимы ввода / вывода или используют один входной и один выходной файл. Пример использования неявных файловых дескрипторов показан ниже.
-- 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 |
«* п» Читает из текущей позиции файла и возвращает число, если существует в позиции файла или возвращает ноль. |
2 |
«* а» Возвращает все содержимое файла из текущей позиции файла. |
3 |
«* л» Читает строку из текущей позиции файла и перемещает позицию файла на следующую строку. |
4 |
число Читает количество байтов, указанных в функции. |
«* п»
Читает из текущей позиции файла и возвращает число, если существует в позиции файла или возвращает ноль.
«* а»
Возвращает все содержимое файла из текущей позиции файла.
«* л»
Читает строку из текущей позиции файла и перемещает позицию файла на следующую строку.
число
Читает количество байтов, указанных в функции.
Другие распространенные методы ввода / вывода включают в себя:
-
io.tmpfile () — возвращает временный файл для чтения и записи, который будет удален после завершения работы программы.
-
io.type (file) — возвращает ли файл, закрытый файл или ноль на основе входного файла.
-
io.flush () — очищает выходной буфер по умолчанию.
-
io.lines (необязательное имя файла) — предоставляет универсальный итератор цикла, который циклически просматривает файл и закрывает файл в конце, если указано имя файла или файл по умолчанию используется и не закрывается в конце цикла ,
io.tmpfile () — возвращает временный файл для чтения и записи, который будет удален после завершения работы программы.
io.type (file) — возвращает ли файл, закрытый файл или ноль на основе входного файла.
io.flush () — очищает выходной буфер по умолчанию.
io.lines (необязательное имя файла) — предоставляет универсальный итератор цикла, который циклически просматривает файл и закрывает файл в конце, если указано имя файла или файл по умолчанию используется и не закрывается в конце цикла ,
Явные файловые дескрипторы
Мы часто используем явный файловый дескриптор, который позволяет нам манипулировать несколькими файлами одновременно. Эти функции очень похожи на неявные файловые дескрипторы. Здесь мы используем 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 (необязательный fromce, необязательное смещение) — параметр Fromce имеет значение «set», «cur» или «end». Устанавливает новый указатель файла с обновленной позицией файла от начала файла. Смещения в этой функции начинаются с нуля. Смещение измеряется от начала файла, если первый аргумент «установлен»; из текущей позиции в файле, если это «cur»; или из конца файла, если это «конец». Значения аргумента по умолчанию — «cur» и 0, поэтому текущую позицию файла можно получить, вызвав эту функцию без аргументов.
-
file: flush () — очищает выходной буфер по умолчанию.
-
io.lines (необязательное имя файла) — предоставляет универсальный итератор цикла, который циклически просматривает файл и закрывает файл в конце, если указано имя файла или файл по умолчанию используется и не закрывается в конце цикла ,
file: seek (необязательный fromce, необязательное смещение) — параметр Fromce имеет значение «set», «cur» или «end». Устанавливает новый указатель файла с обновленной позицией файла от начала файла. Смещения в этой функции начинаются с нуля. Смещение измеряется от начала файла, если первый аргумент «установлен»; из текущей позиции в файле, если это «cur»; или из конца файла, если это «конец». Значения аргумента по умолчанию — «cur» и 0, поэтому текущую позицию файла можно получить, вызвав эту функцию без аргументов.
file: flush () — очищает выходной буфер по умолчанию.
io.lines (необязательное имя файла) — предоставляет универсальный итератор цикла, который циклически просматривает файл и закрывает файл в конце, если указано имя файла или файл по умолчанию используется и не закрывается в конце цикла ,
Пример использования метода поиска показан ниже. Он смещает курсор от 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.
Lua — Обработка ошибок
Необходимость обработки ошибок
Обработка ошибок очень важна, поскольку реальные операции часто требуют использования сложных операций, которые включают файловые операции, транзакции базы данных и вызовы веб-служб.
В любом программировании всегда есть требование для обработки ошибок. Ошибки могут быть двух типов, которые включают в себя,
- Синтаксические ошибки
- Ошибки во время выполнения
Синтаксические ошибки
Синтаксические ошибки возникают из-за неправильного использования различных компонентов программы, таких как операторы и выражения. Простой пример синтаксической ошибки показан ниже.
a == 2
Как вы знаете, существует разница между использованием одного «равно» и двойного «равно». Использование одного вместо другого может привести к ошибке. Одно «равно» относится к присвоению, а двойное «равно» относится к сравнению. Точно так же у нас есть выражения и функции, имеющие предопределенные способы реализации.
Другой пример синтаксической ошибки показан ниже —
for a= 1,10 print(a) end
Когда мы запустим вышеупомянутую программу, мы получим следующий вывод —
lua: test2.lua:2: 'do' expected near 'print'
Синтаксические ошибки гораздо легче обрабатывать, чем ошибки времени выполнения, поскольку интерпретатор Lua обнаруживает ошибку более четко, чем в случае ошибки времени выполнения. Из вышеприведенной ошибки мы можем легко узнать, что добавление оператора do перед оператором print требуется согласно структуре Lua.
Ошибки времени выполнения
В случае ошибок во время выполнения, программа выполняется успешно, но это может привести к ошибкам во время выполнения из-за ошибок во входных или неправильно обработанных функциях. Простой пример отображения ошибки времени выполнения показан ниже.
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]: ?
Ошибка (сообщение [, уровень]) завершает последнюю вызванную защищенную функцию и возвращает сообщение как сообщение об ошибке. Эта ошибка функции никогда не возвращается. Обычно ошибка добавляет некоторую информацию о позиции ошибки в начале сообщения. Аргумент уровня указывает, как получить позицию ошибки. На уровне 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, созданных различными разработчиками, многие из которых являются открытыми.
Функции, доступные в библиотеке отладки Lua, перечислены в следующей таблице вместе с их использованием.
Sr.No. | Метод и цель |
---|---|
1 |
отладки () Переходит в интерактивный режим отладки, который остается активным до тех пор, пока мы не введем только строку в строке и не нажмем клавишу ввода Пользователь может проверять переменные в этом режиме, используя другие функции. |
2 |
getfenv (объект) Возвращает среду объекта. |
3 |
gethook (необязательная тема) Возвращает текущие настройки ловушек потока в виде трех значений — текущей функции ловушек, текущей маски ловушек и текущего счетчика ловушек. |
4 |
getinfo (необязательный поток, функция или уровень стека, необязательный флаг) Возвращает таблицу с информацией о функции. Вы можете передать функцию напрямую или указать число в качестве значения функции, что означает, что функция выполняется на уровне функции стека вызовов данного потока — уровень 0 является текущей функцией (сама getinfo); уровень 1 — это функция, которая вызвала getinfo; и так далее. Если функция на число больше, чем количество активных функций, getinfo возвращает nil. |
5 |
getlocal (необязательный поток, уровень стека, локальный индекс) Возвращает имя и значение локальной переменной с индексом local функции на уровне стека. Возвращает nil, если локальная переменная с указанным индексом отсутствует, и выдает ошибку при вызове с уровнем вне диапазона. |
6 |
GetMetaTable (значение) Возвращает метатабельность данного объекта или ноль, если у него нет метатаблицы. |
7 |
getregistry () Возвращает таблицу реестра, предопределенную таблицу, которая может использоваться любым кодом C для хранения любого значения Lua, которое необходимо сохранить. |
8 |
getupvalue (функция, индекс upvalue) Эта функция возвращает имя и значение upvalue с индексом вверх функции func. Функция возвращает nil, если нет никакого значения с данным индексом. |
9 |
setfenv (функция или поток или пользовательские данные, таблица окружения) Устанавливает среду данного объекта в данную таблицу. Возвращает объект. |
10 |
sethook (необязательный поток, функция ловушки, строка маски крюка с «c» и / или «r» и / или «l», необязательный счетчик команд) Устанавливает данную функцию как хук. Строковая маска и счетчик чисел описывают, когда будет вызываться ловушка. Здесь c, r и l вызываются каждый раз, когда Lua вызывает, возвращает и вводит каждую строку кода в функцию соответственно. |
11 |
setlocal (необязательный поток, уровень стека, локальный индекс, значение) Назначает значение локальной переменной с индексом local функции на уровне стека. Функция возвращает nil, если нет локальной переменной с данным индексом, и выдает ошибку при вызове с уровнем вне диапазона. В противном случае он возвращает имя локальной переменной. |
12 |
setmetatable (значение, метатабельный) Устанавливает метатабельность для данного объекта в данной таблице (которая может быть ноль). |
13 |
setupvalue (функция, индекс upvalue, значение) Эта функция присваивает значение повышающему значению с индексом вверх функции func. Функция возвращает nil, если нет никакого значения с данным индексом. В противном случае он возвращает имя upvalue. |
14 |
traceback (необязательный поток, необязательная строка сообщения, необязательный аргумент уровня) Создает расширенное сообщение об ошибке с трассировкой. |
отладки ()
Переходит в интерактивный режим отладки, который остается активным до тех пор, пока мы не введем только строку в строке и не нажмем клавишу ввода Пользователь может проверять переменные в этом режиме, используя другие функции.
getfenv (объект)
Возвращает среду объекта.
gethook (необязательная тема)
Возвращает текущие настройки ловушек потока в виде трех значений — текущей функции ловушек, текущей маски ловушек и текущего счетчика ловушек.
getinfo (необязательный поток, функция или уровень стека, необязательный флаг)
Возвращает таблицу с информацией о функции. Вы можете передать функцию напрямую или указать число в качестве значения функции, что означает, что функция выполняется на уровне функции стека вызовов данного потока — уровень 0 является текущей функцией (сама getinfo); уровень 1 — это функция, которая вызвала getinfo; и так далее. Если функция на число больше, чем количество активных функций, getinfo возвращает nil.
getlocal (необязательный поток, уровень стека, локальный индекс)
Возвращает имя и значение локальной переменной с индексом local функции на уровне стека. Возвращает nil, если локальная переменная с указанным индексом отсутствует, и выдает ошибку при вызове с уровнем вне диапазона.
GetMetaTable (значение)
Возвращает метатабельность данного объекта или ноль, если у него нет метатаблицы.
getregistry ()
Возвращает таблицу реестра, предопределенную таблицу, которая может использоваться любым кодом C для хранения любого значения Lua, которое необходимо сохранить.
getupvalue (функция, индекс upvalue)
Эта функция возвращает имя и значение upvalue с индексом вверх функции func. Функция возвращает nil, если нет никакого значения с данным индексом.
setfenv (функция или поток или пользовательские данные, таблица окружения)
Устанавливает среду данного объекта в данную таблицу. Возвращает объект.
sethook (необязательный поток, функция ловушки, строка маски крюка с «c» и / или «r» и / или «l», необязательный счетчик команд)
Устанавливает данную функцию как хук. Строковая маска и счетчик чисел описывают, когда будет вызываться ловушка. Здесь c, r и l вызываются каждый раз, когда Lua вызывает, возвращает и вводит каждую строку кода в функцию соответственно.
setlocal (необязательный поток, уровень стека, локальный индекс, значение)
Назначает значение локальной переменной с индексом local функции на уровне стека. Функция возвращает nil, если нет локальной переменной с данным индексом, и выдает ошибку при вызове с уровнем вне диапазона. В противном случае он возвращает имя локальной переменной.
setmetatable (значение, метатабельный)
Устанавливает метатабельность для данного объекта в данной таблице (которая может быть ноль).
setupvalue (функция, индекс upvalue, значение)
Эта функция присваивает значение повышающему значению с индексом вверх функции func. Функция возвращает nil, если нет никакого значения с данным индексом. В противном случае он возвращает имя upvalue.
traceback (необязательный поток, необязательная строка сообщения, необязательный аргумент уровня)
Создает расширенное сообщение об ошибке с трассировкой.
Приведенный выше список является полным списком функций отладки в 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 до вызова операции set. Используя функцию 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, устанавливать точки останова и проверять текущее состояние программы.
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 — стандартная Windows IDE для Lua предоставляет несколько средств отладки, таких как точки останова, шаг, шаг, шаг, просмотр переменных и так далее.
-
Decoda — это графический отладчик с поддержкой удаленной отладки.
-
ZeroBrane Studio — Lua IDE со встроенным удаленным отладчиком, просмотром стека, просмотром часов, удаленной консолью, статическим анализатором и многим другим. Работает с LuaJIT, Love2d, Moai и другими двигателями Lua; Windows, OSX и Linux. Открытый исходный код.
-
akdebugger — Отладчик и редактор Lua для Eclipse.
-
luaedit — Это включает в себя удаленную отладку, локальную отладку, подсветку синтаксиса, список предложений завершения, механизм предложения параметров, предварительное управление точками останова (включая систему условий на точках останова и числе обращений), список функций, список глобальных и локальных переменных, наблюдения, управление, ориентированное на решение.
SciTE — стандартная Windows IDE для Lua предоставляет несколько средств отладки, таких как точки останова, шаг, шаг, шаг, просмотр переменных и так далее.
Decoda — это графический отладчик с поддержкой удаленной отладки.
ZeroBrane Studio — Lua IDE со встроенным удаленным отладчиком, просмотром стека, просмотром часов, удаленной консолью, статическим анализатором и многим другим. Работает с LuaJIT, Love2d, Moai и другими двигателями Lua; Windows, OSX и Linux. Открытый исходный код.
akdebugger — Отладчик и редактор Lua для Eclipse.
luaedit — Это включает в себя удаленную отладку, локальную отладку, подсветку синтаксиса, список предложений завершения, механизм предложения параметров, предварительное управление точками останова (включая систему условий на точках останова и числе обращений), список функций, список глобальных и локальных переменных, наблюдения, управление, ориентированное на решение.
Луа — Сборка мусора
Lua использует автоматическое управление памятью, которое использует сборку мусора на основе определенных алгоритмов, встроенных в Lua. В результате автоматического управления памятью, как разработчик —
- Не нужно беспокоиться о выделении памяти для объектов.
- Нет необходимости освобождать их, когда они больше не нужны, за исключением установки на ноль.
Lua использует сборщик мусора, который запускается время от времени для сбора мертвых объектов, когда они больше не доступны из программы Lua.
Все объекты, включая таблицы, пользовательские данные, функции, потоки, строки и т. Д., Подлежат автоматическому управлению памятью. Lua использует инкрементный сборщик меток и очистки, который использует два числа для управления циклами сборки мусора, а именно паузу сборщика мусора и множитель шага сборщика мусора . Эти значения в процентах, а значение 100 часто равно 1 внутри.
Сборщик мусора Пауза
Пауза сборщика мусора используется для контроля того, как долго должен ждать сборщик мусора; он снова вызывается автоматическим управлением памятью Lua. Значения меньше 100 означают, что Lua не будет ждать следующего цикла. Аналогично, более высокие значения этого значения приведут к тому, что сборщик мусора будет медленным и менее агрессивным по своей природе. Значение 200 означает, что сборщик ожидает удвоения общего объема используемой памяти, прежде чем начинать новый цикл. Следовательно, в зависимости от характера и скорости приложения может потребоваться изменить это значение, чтобы получить лучшую производительность в приложениях Lua.
Множитель шага сборщика мусора
Этот множитель шага управляет относительной скоростью сборщика мусора и скоростью выделения памяти в программе Lua. Большие значения шага приведут к тому, что сборщик мусора станет более агрессивным, а также увеличит размер шага каждого добавочного шага сборки мусора. Значения меньше 100 часто могут привести к тому, что сборщик мусора не завершит свой цикл, и это обычно не является предпочтительным. Значение по умолчанию равно 200, что означает, что сборщик мусора работает в два раза быстрее, чем скорость выделения памяти.
Функции сборщика мусора
Как разработчики, у нас есть некоторый контроль над автоматическим управлением памятью в Lua. Для этого у нас есть следующие методы.
-
collectgarbage («собирать») — запускает один полный цикл сборки мусора.
-
collectgarbage («count») — Возвращает объем памяти, используемой в настоящее время программой в килобайтах.
-
collectgarbage («restart») — Если сборщик мусора был остановлен, он перезапускает его.
-
collectgarbage («setpause») — Устанавливает значение, заданное в качестве второго параметра, деленное на 100 для переменной паузы сборщика мусора. Его использование — как обсуждено немного выше.
-
collectgarbage («setstepmul») — Устанавливает значение, заданное в качестве второго параметра, деленное на 100 для переменной множителя шага мусора. Его использование — как обсуждено немного выше.
-
collectgarbage («шаг») — Запускает один шаг сборки мусора. Чем больше второй аргумент, тем больше будет этот шаг. Параметр collectgarbage будет возвращать значение true, если запущенный шаг был последним этапом цикла сбора мусора.
-
collectgarbage («стоп») — останавливает сборщик мусора, если он работает.
collectgarbage («собирать») — запускает один полный цикл сборки мусора.
collectgarbage («count») — Возвращает объем памяти, используемой в настоящее время программой в килобайтах.
collectgarbage («restart») — Если сборщик мусора был остановлен, он перезапускает его.
collectgarbage («setpause») — Устанавливает значение, заданное в качестве второго параметра, деленное на 100 для переменной паузы сборщика мусора. Его использование — как обсуждено немного выше.
collectgarbage («setstepmul») — Устанавливает значение, заданное в качестве второго параметра, деленное на 100 для переменной множителя шага мусора. Его использование — как обсуждено немного выше.
collectgarbage («шаг») — Запускает один шаг сборки мусора. Чем больше второй аргумент, тем больше будет этот шаг. Параметр collectgarbage будет возвращать значение true, если запущенный шаг был последним этапом цикла сбора мусора.
collectgarbage («стоп») — останавливает сборщик мусора, если он работает.
Простой пример с использованием примера сборщика мусора показан ниже.
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 после предварительно определенного периода.
Очевидно, что мы можем изменить поведение сборщика мусора, используя эти функции, если это необходимо. Эти функции предоставляют разработчику немного дополнительных возможностей для решения сложных ситуаций. В зависимости от типа памяти, необходимого для программы, вы можете или не можете использовать эту функцию. Но очень полезно знать использование памяти в приложениях и проверять ее во время самого программирования, чтобы избежать нежелательных результатов после развертывания.
Lua — объектно-ориентированный
Введение в ООП
Объектно-ориентированное программирование (ООП) — это один из наиболее часто используемых методов программирования, который используется в современную эпоху программирования. Существует ряд языков программирования, которые поддерживают ООП, включая:
- C ++
- Джава
- Objective-C
- Болтовня
- C #
- Рубин
Особенности ООП
-
Класс — класс — это расширяемый шаблон для создания объектов, предоставляющий начальные значения для состояния (переменные-члены) и реализации поведения.
-
Объекты — это экземпляр класса, для которого выделена отдельная память.
-
Наследование — это понятие, посредством которого переменные и функции одного класса наследуются другим классом.
-
Инкапсуляция — это процесс объединения данных и функций внутри класса. Данные могут быть доступны вне класса с помощью функций. Это также известно как абстракция данных.
Класс — класс — это расширяемый шаблон для создания объектов, предоставляющий начальные значения для состояния (переменные-члены) и реализации поведения.
Объекты — это экземпляр класса, для которого выделена отдельная память.
Наследование — это понятие, посредством которого переменные и функции одного класса наследуются другим классом.
Инкапсуляция — это процесс объединения данных и функций внутри класса. Данные могут быть доступны вне класса с помощью функций. Это также известно как абстракция данных.
ООП в Луа
Вы можете реализовать ориентацию объекта в Lua с помощью таблиц и первоклассных функций Lua. Помещая функции и связанные данные в таблицу, формируется объект. Наследование может быть реализовано с помощью метатаблиц, обеспечивающих механизм поиска несуществующих функций (методов) и полей в родительском объекте (ах).
Таблицы в Lua имеют свойства объекта, такие как состояние и идентичность, которые не зависят от его значений. Два объекта (таблицы) с одинаковым значением являются разными объектами, тогда как объект может иметь разные значения в разное время, но это всегда один и тот же объект. Как и у объектов, таблицы имеют жизненный цикл, который не зависит от того, кто их создал или где они были созданы.
Пример из реального мира
Концепция объектной ориентации широко используется, но вам необходимо четко понимать ее для правильной и максимальной выгоды.
Давайте рассмотрим простой математический пример. Мы часто сталкиваемся с ситуациями, когда работаем с разными формами, такими как круг, прямоугольник и квадрат.
Формы могут иметь общее свойство Area. Таким образом, мы можем расширить другие фигуры из формы базового объекта с помощью общей области свойств. Каждая из фигур может иметь свои собственные свойства и функции, например, прямоугольник может иметь свойства length, width, area в качестве своих свойств, а printArea и defineArea в качестве своих функций.
Создание простого класса
Простая реализация класса для прямоугольника с тремя свойствами: площадь, длина и ширина показаны ниже. Он также имеет функцию 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 — веб-программирование
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.
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 включают в себя:
- Обработка запросов
- Буферизация вывода
- Аутентификация
- Загрузка файлов
- Запросить изоляцию
- мультиплексирование
Простой пример 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 Web Components
-
Copas , диспетчер, основанный на сопрограммах, которые могут использоваться серверами TCP / IP.
-
Cosmo , движок «безопасных шаблонов», защищающий ваше приложение от произвольного кода в шаблонах.
-
Coxpcall инкапсулирует Lua нативный pcall и xpcall с сопрограмм-совместимыми.
-
LuaFileSystem , переносимый способ доступа к базовой структуре каталогов и атрибутам файлов.
-
Rings , библиотека, которая обеспечивает способ создания новых состояний Lua из 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-сервера.
Moonstalk позволяет эффективно разрабатывать и размещать динамически генерируемые веб-проекты, построенные на языке Lua; от базовых страниц до сложных приложений.
Lapis , фреймворк для создания веб-приложений с использованием MoonScript (или Lua), который работает внутри настроенной версии Nginx под названием OpenResty.
Lua Server Pages , плагин скриптового движка Lua, который отбрасывает любой другой подход к встроенной веб-разработке, предлагает впечатляющий краткий путь к традиционным страницам C-сервера.
Эти веб-фреймворки могут использовать ваши веб-приложения и помочь вам в выполнении мощных операций.
Lua — доступ к базе данных
Для простых операций с данными мы можем использовать файлы, но иногда эти файловые операции могут быть неэффективными, масштабируемыми и мощными. Для этого мы можем часто переходить на использование баз данных. LuaSQL — это простой интерфейс от Lua к ряду систем управления базами данных. LuaSQL — это библиотека, которая обеспечивает поддержку различных типов SQL. Это включает в себя,
- SQLite
- Mysql
- ODBC
В этом уроке мы рассмотрим обработку базы данных MySQL и SQLite на Lua. Он использует общий интерфейс для обоих и должен иметь возможность портировать эту реализацию на другие типы баз данных. Сначала давайте посмотрим, как вы можете делать операции в MySQL.
Настройка базы данных MySQL
Чтобы использовать следующие примеры для правильной работы, нам нужна начальная настройка БД. Допущения перечислены ниже.
-
Вы установили и настроили MySQL с пользователем по умолчанию в качестве пользователя root и паролем «123456».
-
Вы создали тест базы данных.
-
Вы прошли учебник по 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 и установит соединение с вновь созданным файлом.
Выполнить функцию
В соединении есть простая функция execute, которая поможет нам выполнить все операции с базами данных: создание, вставка, удаление, обновление и так далее. Синтаксис показан ниже —
conn:execute([[ 'MySQLSTATEMENT' ]])
В приведенном выше синтаксисе мы должны убедиться, что conn открыта и существует соединение MySQL, и заменить MySQLSTATEMENT на правильное выражение.
Пример создания таблицы
Простой пример создания таблицы показан ниже. Создает таблицу с двумя параметрами id типа integer и именем типа 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
Выполнение транзакций
Транзакции — это механизм, который обеспечивает согласованность данных. Транзакции должны иметь следующие четыре свойства —
-
Атомарность — либо транзакция завершена, либо ничего не происходит вообще.
-
Согласованность — транзакция должна начинаться в согласованном состоянии и оставлять систему в согласованном состоянии.
-
Изоляция — промежуточные результаты транзакции не видны за пределами текущей транзакции.
-
Долговечность — после совершения транзакции последствия сохраняются даже после сбоя системы.
Атомарность — либо транзакция завершена, либо ничего не происходит вообще.
Согласованность — транзакция должна начинаться в согласованном состоянии и оставлять систему в согласованном состоянии.
Изоляция — промежуточные результаты транзакции не видны за пределами текущей транзакции.
Долговечность — после совершения транзакции последствия сохраняются даже после сбоя системы.
Транзакция начинается с START TRANSACTION; и заканчивается оператором commit или rollback.
Начать транзакцию
Чтобы инициировать транзакцию, нам нужно выполнить следующую инструкцию в 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 и установит соединение с вновь созданным файлом.
Выполнить функцию
В соединении есть простая функция execute, которая поможет нам выполнить все операции с базами данных: создание, вставка, удаление, обновление и так далее. Синтаксис показан ниже —
conn:execute([[ 'SQLite3STATEMENT' ]])
В приведенном выше синтаксисе мы должны убедиться, что conn открыта и существует соединение sqlite3, и заменить SQLite3STATEMENT на правильное выражение.
Пример создания таблицы
Простой пример создания таблицы показан ниже. Создает таблицу с двумя параметрами id типа integer и именем типа 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 используется во многих игровых движках благодаря своей простой языковой структуре и синтаксису. Функция сборки мусора часто очень полезна в играх, которые потребляют много памяти из-за богатой графики, которая используется. Некоторые игровые движки, которые используют Lua, включают в себя —
- Corona SDK
- Гидерос Мобайл
- ShiVa3D
- Моаи SDK
- ЛЮБИТЬ
- CryEngine
Каждый из этих игровых движков основан на Lua, и в каждом из этих движков доступен богатый набор API. Мы рассмотрим возможности каждого вкратце.
Corona SDK
Corona SDK — это кроссплатформенный движок для мобильных игр, который поддерживает платформы iPhone, iPad и Android. Существует бесплатная версия Corona SDK, которую можно использовать для небольших игр с ограниченными возможностями. При необходимости вы можете перейти на другие версии.
Corona SDK предоставляет ряд функций, которые включают в себя следующее —
- API для обработки физики и столкновений
- Веб и сетевые API
- API игровой сети
- API объявлений
- API аналитики
- API базы данных и файловой системы
- Крипто и математические API
- Аудио и медиа API
Легче и быстрее разрабатывать приложения с использованием вышеуказанных API, а не использовать собственные API отдельно для iOS и Android.
Гидерос Мобайл
Gideros предоставляет кроссплатформенный SDK для создания игр для iOS и Android. Его можно использовать с выплеском Gideros. Некоторые из поразительных преимуществ Gideoros включают в себя следующее:
-
Разработка IDE — предоставляет собственную IDE, которая облегчает разработку приложений Gideros.
-
Мгновенное тестирование. При разработке игры ее можно протестировать на реальном устройстве через Wi-Fi всего за 1 секунду. Вам не нужно тратить свое время на процесс экспорта или развертывания.
-
Плагины — Вы можете легко расширить ядро с помощью плагинов. Импортируйте свой существующий (C, C ++, Java или Obj-C) код, свяжите его с Lua и интерпретируйте их напрямую. Десятки плагинов с открытым исходным кодом уже разработаны и готовы к использованию.
-
Чистый ООП подход — Gideros предоставляет собственную систему классов со всеми основными стандартами ООП, что позволяет вам писать чистый и многократно используемый код для любой из ваших будущих игр.
-
Собственная скорость — разработанная на основе C / C ++ и OpenGL, ваша игра работает на родной скорости и полностью использует мощность процессоров и графических процессоров.
Разработка IDE — предоставляет собственную IDE, которая облегчает разработку приложений Gideros.
Мгновенное тестирование. При разработке игры ее можно протестировать на реальном устройстве через Wi-Fi всего за 1 секунду. Вам не нужно тратить свое время на процесс экспорта или развертывания.
Плагины — Вы можете легко расширить ядро с помощью плагинов. Импортируйте свой существующий (C, C ++, Java или Obj-C) код, свяжите его с Lua и интерпретируйте их напрямую. Десятки плагинов с открытым исходным кодом уже разработаны и готовы к использованию.
Чистый ООП подход — Gideros предоставляет собственную систему классов со всеми основными стандартами ООП, что позволяет вам писать чистый и многократно используемый код для любой из ваших будущих игр.
Собственная скорость — разработанная на основе C / C ++ и OpenGL, ваша игра работает на родной скорости и полностью использует мощность процессоров и графических процессоров.
ShiVa3D
ShiVa3D — это один из игровых 3D-движков, который предоставляет графический редактор, предназначенный для создания приложений и видеоигр для Интернета, консолей и мобильных устройств. Он поддерживает несколько платформ, включая Windows, Mac, Linux, iOS, Android, BlackBerry, Palm OS, Wii и WebOS.
Некоторые из основных функций включают в себя
- Стандартные плагины
- API модификации сетки
- IDE
- Встроенный редактор Terrain, Ocean и анимации
- Поддержка физического движка ODE
- Полный контроль над картой света
- Предварительный просмотр материалов, частиц, следов и HUD
- Поддержка формата обмена Collada
Веб-версия Shiva3d абсолютно бесплатна, и другие издания, на которые вы подписаны.
Моаи SDK
Moai SDK — это кроссплатформенный движок для мобильных игр, который поддерживает платформы iPhone, iPad и Android. Платформа Moai изначально состояла из Moai SDK, игрового движка с открытым исходным кодом, и Moai Cloud, облачной платформы как службы для размещения и развертывания игровых сервисов. Теперь Moai Cloud отключен и доступен только игровой движок.
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.
-
В микшировании и профилировании игр, управляемой данными звуковой системе, динамических звуках, интерактивной музыке и т. Д.
-
Физические особенности как Процессуальная Деформация и Продвинутая Физика Веревки.
Визуальные эффекты, такие как Естественное освещение и Динамические мягкие тени, Динамическое глобальное освещение в реальном времени, Объем распространения света, Затенение частиц, Тесселяция и так далее.
Система анимации персонажей и система индивидуализации персонажей.
Параметрическая анимация скелета и уникальный специализированный редактор анимации лица
Системы искусственного интеллекта, такие как многослойная навигационная сетка и система тактических точек. Также предоставляет Дизайнерскую систему редактирования AI.
В микшировании и профилировании игр, управляемой данными звуковой системе, динамических звуках, интерактивной музыке и т. Д.
Физические особенности как Процессуальная Деформация и Продвинутая Физика Веревки.
Конечная записка
Каждый из этих игровых SDK / фреймворков имеет свои преимущества и недостатки. Правильный выбор между ними облегчит вашу задачу, и вы сможете лучше с ней справиться. Поэтому, прежде чем использовать его, вам необходимо знать требования к вашей игре, а затем проанализировать, которые удовлетворяют все ваши потребности, а затем использовать их.
Lua — Стандартные библиотеки
Стандартные библиотеки Lua предоставляют богатый набор функций, которые реализуются непосредственно с C API и встроены в язык программирования Lua. Эти библиотеки предоставляют сервисы на языке программирования Lua, а также сторонние сервисы, такие как операции с файлами и БД.
Эти стандартные библиотеки, встроенные в официальный C API, предоставляются как отдельные модули C. Это включает в себя следующее —
- Основная библиотека, которая включает в себя подпрограмму сопрограммы
- Библиотека модулей
- Струнные манипуляции
- Таблица манипуляций
- Математическая библиотека
- Ввод и вывод файла
- Средства операционной системы
- Средства отладки
Основная библиотека
Мы использовали базовую библиотеку на протяжении всего урока по различным темам. В следующей таблице приведены ссылки на связанные страницы и перечислены функции, которые рассматриваются в различных частях этого учебного пособия по Lua.
Sr.No. | Библиотека / Метод и Цель |
---|---|
1 |
Обработка ошибок Включает в себя функции обработки ошибок, такие как assert, error, как описано в Lua — Error Errorling . |
2 |
Управление памятью Включает функции автоматического управления памятью, связанные со сборкой мусора, как описано в Lua — Сборка мусора . |
3 |
dofile ([имя файла]) Он открывает файл и выполняет содержимое файла как чанк. Если параметр не передан, то эта функция выполняет содержимое стандартного ввода. Ошибки будут переданы вызывающей стороне. |
4 |
_Г Таким образом, глобальная переменная содержит глобальную среду (то есть _G._G = _G). Сам Lua не использует эту переменную. |
5 |
getfenv ([f]) Возвращает текущую среду, используемую функцией. f может быть функцией Lua или числом, которое определяет функцию на этом уровне стека. Уровень 1 — это функция, вызывающая getfenv. Если данная функция не является функцией Lua или если f равно 0, getfenv возвращает глобальную среду. Значением по умолчанию для f является 1. |
6 |
getmetatable (объект) Если объект не имеет метатаблицы, возвращает ноль. В противном случае, если у метатаблицы объекта есть поле «__metatable», возвращается соответствующее значение. В противном случае возвращает метатаблицу данного объекта. |
7 |
ipairs (t) Эта функция выбирает индексы и значения таблиц. |
8 |
load (func [, chunkname]) Загружает кусок, используя функцию func, чтобы получить его части. Каждый вызов func должен возвращать строку, которая объединяется с предыдущими результатами. |
9 |
файл загрузки ([имя файла])) Аналогичен загрузке, но получает фрагмент из имени файла или из стандартного ввода, если имя файла не указано. |
10 |
loadstring (строка [, chunkname]) Аналогично загрузке, но получает фрагмент из заданной строки. |
11 |
следующий (таблица [, индекс]) Позволяет программе пересекать все поля таблицы. Его первый аргумент — это таблица, а второй аргумент — это индекс в этой таблице. next возвращает следующий индекс таблицы и связанное с ней значение. |
12 |
пары (т) Приостанавливает запущенную сопрограмму. Параметр, передаваемый этому методу, действует как дополнительные возвращаемые значения функции возобновления. |
13 |
Распечатать (…) Приостанавливает запущенную сопрограмму. Параметр, передаваемый этому методу, действует как дополнительные возвращаемые значения функции возобновления. |
14 |
rawequal (v1, v2) Проверяет, равен ли v1 v2, не вызывая метаметод. Возвращает логическое значение. |
15 |
rawget (таблица, индекс) Получает реальное значение таблицы [index], не вызывая метаметод. таблица должна быть таблицей; Индекс может быть любым значением. |
16 |
rawset (таблица, индекс, значение) Устанавливает реальное значение таблицы [индекс] в значение, не вызывая метаметод. table должен быть таблицей, индексировать любое значение, отличное от nil, и value любое значение Lua. Эта функция возвращает таблицу. |
17 |
выберите (индекс, …) Если index является числом, возвращает все аргументы после индекса номера аргумента. В противном случае index должен быть строкой «#», а select возвращает общее количество дополнительных аргументов, которые он получил. |
18 |
setfenv (f, таблица) Устанавливает среду, которая будет использоваться данной функцией. f может быть функцией Lua или числом, которое определяет функцию на этом уровне стека. Уровень 1 — это функция, вызывающая setfenv. setfenv возвращает данную функцию. В качестве особого случая, когда f равно 0, setfenv изменяет среду работающего потока. В этом случае setfenv не возвращает значений. |
19 |
setmetatable (таблица, метатабельный) Устанавливает метатаблицу для данной таблицы. (Вы не можете изменить метатабель других типов из Lua, только из C.) Если метатабил равен нулю, удаляет метатабиль данной таблицы. Если исходный метатабль имеет поле «__metatable», возникает ошибка. Эта функция возвращает таблицу. |
20 |
tonumber (e [, base]) Пытается преобразовать свой аргумент в число. Если аргумент уже является числом или строкой, конвертируемой в число, то tonumber возвращает это число; в противном случае возвращается ноль. |
21 |
tostring (e) Получает аргумент любого типа и преобразует его в строку в приемлемом формате. Для полного контроля над тем, как числа конвертируются, используйте string.format. |
22 |
тип (v) Возвращает тип единственного аргумента, закодированного в виде строки. Возможные результаты этой функции: «nil» (строка, а не значение nil), «number», «string», «boolean», «table», «function», «thread» и «userdata». |
23 |
распаковать (список [, i [, j]]) Возвращает элементы из данной таблицы. |
24 |
_ВЕРСИЯ Глобальная переменная (не функция), которая содержит строку, содержащую текущую версию интерпретатора. Текущее содержимое этой переменной — «Lua 5.1». |
25 |
Сопрограммы Включает функции манипулирования сопрограммой, как описано в Lua — Coroutines . |
Обработка ошибок
Включает в себя функции обработки ошибок, такие как assert, error, как описано в Lua — Error Errorling .
Управление памятью
Включает функции автоматического управления памятью, связанные со сборкой мусора, как описано в Lua — Сборка мусора .
dofile ([имя файла])
Он открывает файл и выполняет содержимое файла как чанк. Если параметр не передан, то эта функция выполняет содержимое стандартного ввода. Ошибки будут переданы вызывающей стороне.
_Г
Таким образом, глобальная переменная содержит глобальную среду (то есть _G._G = _G). Сам Lua не использует эту переменную.
getfenv ([f])
Возвращает текущую среду, используемую функцией. f может быть функцией Lua или числом, которое определяет функцию на этом уровне стека. Уровень 1 — это функция, вызывающая getfenv. Если данная функция не является функцией Lua или если f равно 0, getfenv возвращает глобальную среду. Значением по умолчанию для f является 1.
getmetatable (объект)
Если объект не имеет метатаблицы, возвращает ноль. В противном случае, если у метатаблицы объекта есть поле «__metatable», возвращается соответствующее значение. В противном случае возвращает метатаблицу данного объекта.
ipairs (t)
Эта функция выбирает индексы и значения таблиц.
load (func [, chunkname])
Загружает кусок, используя функцию func, чтобы получить его части. Каждый вызов func должен возвращать строку, которая объединяется с предыдущими результатами.
файл загрузки ([имя файла]))
Аналогичен загрузке, но получает фрагмент из имени файла или из стандартного ввода, если имя файла не указано.
loadstring (строка [, chunkname])
Аналогично загрузке, но получает фрагмент из заданной строки.
следующий (таблица [, индекс])
Позволяет программе пересекать все поля таблицы. Его первый аргумент — это таблица, а второй аргумент — это индекс в этой таблице. next возвращает следующий индекс таблицы и связанное с ней значение.
пары (т)
Приостанавливает запущенную сопрограмму. Параметр, передаваемый этому методу, действует как дополнительные возвращаемые значения функции возобновления.
Распечатать (…)
Приостанавливает запущенную сопрограмму. Параметр, передаваемый этому методу, действует как дополнительные возвращаемые значения функции возобновления.
rawequal (v1, v2)
Проверяет, равен ли v1 v2, не вызывая метаметод. Возвращает логическое значение.
rawget (таблица, индекс)
Получает реальное значение таблицы [index], не вызывая метаметод. таблица должна быть таблицей; Индекс может быть любым значением.
rawset (таблица, индекс, значение)
Устанавливает реальное значение таблицы [индекс] в значение, не вызывая метаметод. table должен быть таблицей, индексировать любое значение, отличное от nil, и value любое значение Lua. Эта функция возвращает таблицу.
выберите (индекс, …)
Если index является числом, возвращает все аргументы после индекса номера аргумента. В противном случае index должен быть строкой «#», а select возвращает общее количество дополнительных аргументов, которые он получил.
setfenv (f, таблица)
Устанавливает среду, которая будет использоваться данной функцией. f может быть функцией Lua или числом, которое определяет функцию на этом уровне стека. Уровень 1 — это функция, вызывающая setfenv. setfenv возвращает данную функцию. В качестве особого случая, когда f равно 0, setfenv изменяет среду работающего потока. В этом случае setfenv не возвращает значений.
setmetatable (таблица, метатабельный)
Устанавливает метатаблицу для данной таблицы. (Вы не можете изменить метатабель других типов из Lua, только из C.) Если метатабил равен нулю, удаляет метатабиль данной таблицы. Если исходный метатабль имеет поле «__metatable», возникает ошибка. Эта функция возвращает таблицу.
tonumber (e [, base])
Пытается преобразовать свой аргумент в число. Если аргумент уже является числом или строкой, конвертируемой в число, то tonumber возвращает это число; в противном случае возвращается ноль.
tostring (e)
Получает аргумент любого типа и преобразует его в строку в приемлемом формате. Для полного контроля над тем, как числа конвертируются, используйте string.format.
тип (v)
Возвращает тип единственного аргумента, закодированного в виде строки. Возможные результаты этой функции: «nil» (строка, а не значение nil), «number», «string», «boolean», «table», «function», «thread» и «userdata».
распаковать (список [, i [, j]])
Возвращает элементы из данной таблицы.
_ВЕРСИЯ
Глобальная переменная (не функция), которая содержит строку, содержащую текущую версию интерпретатора. Текущее содержимое этой переменной — «Lua 5.1».
Сопрограммы
Включает функции манипулирования сопрограммой, как описано в Lua — Coroutines .
Библиотека модулей
Библиотека модулей предоставляет основные функции для загрузки модулей в Lua. Он экспортирует одну функцию напрямую в глобальную среду: требуется. Все остальное экспортируется в пакет таблицы. Подробности о библиотеке модулей описаны в предыдущей главе Lua — Модули .
Струнные манипуляции
Lua предоставляет богатый набор функций для работы со строками. В предыдущем уроке по Lua — Strings это подробно описано.
Таблица манипуляций
Lua зависит от таблиц почти во всех операциях. В предыдущем уроке Lua — Tables это подробно описано.
Ввод и вывод файла
Нам часто требуется средство хранения данных при программировании, и это обеспечивается стандартными библиотечными функциями для файлового ввода-вывода в Lua. Это обсуждалось в предыдущем уроке Lua — File I / O.
Средства отладки
Lua предоставляет библиотеку отладки, которая предоставляет нам все примитивные функции для создания нашего собственного отладчика. Это обсуждалось ранее в Lua — Руководство по отладке .
Lua — математическая библиотека
Нам часто нужны математические операции в научных и инженерных расчетах, и мы можем использовать это, используя стандартную библиотеку математики Lua. Список функций, доступных в математической библиотеке, показан в следующей таблице.
Sr.No. | Библиотека / Метод и Цель |
---|---|
1 |
math.abs (x) Возвращает абсолютное значение х. |
2 |
math.acos (x) Возвращает арккосинус от x (в радианах). |
3 |
math.asin (x) Возвращает арксинус x (в радианах). |
4 |
математика (х) Возвращает арктангенс х (в радианах). |
5 |
math.atan2 (у, х) Возвращает арктангенс y / 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 (м, е) Возвращает m2e (e должно быть целым числом). |
16 |
math.log (x) Возвращает натуральный логарифм x. |
17 |
math.log10 (x) Возвращает основание-10 логарифм х. |
18 |
math.max (x, …) Возвращает максимальное значение среди своих аргументов. |
19 |
math.min (x, …) Возвращает минимальное значение среди своих аргументов. |
20 |
math.modf (x) Возвращает два числа, неотъемлемую часть x и дробную часть x. |
21 |
math.pi Значение пи. |
22 |
math.pow (x, y) Возвращает ху. (Вы также можете использовать выражение x ^ y для вычисления этого значения.) |
23 |
math.rad (x) Возвращает угол x (в градусах) в радианах. |
24 |
math.random ([m [, n]]) Эта функция является интерфейсом к простой функции генератора псевдослучайных рандов, предоставляемой ANSI C. При вызове без аргументов возвращает равномерное псевдослучайное действительное число в диапазоне [0,1). При вызове с целым числом m, math.random возвращает равномерное псевдослучайное целое число в диапазоне [1, m]. При вызове с двумя целыми числами m и n math.random возвращает равномерное псевдослучайное целое число в диапазоне [m, n]. |
25 |
математика. случайное семя (х) Устанавливает x в качестве «начального числа» для псевдослучайного генератора: равные начальные числа создают равные последовательности чисел. |
26 |
математика (х) Возвращает синус х (предполагается в радианах). |
27 |
math.sinh (x) Возвращает гиперболический синус x. |
28 |
math.sqrt (x) Возвращает квадратный корень из х. (Вы также можете использовать выражение x ^ 0.5 для вычисления этого значения.) |
29 |
математика (х) Возвращает тангенс x (предполагается в радианах). |
30 |
математика (х) Возвращает гиперболический тангенс x. |
math.abs (x)
Возвращает абсолютное значение х.
math.acos (x)
Возвращает арккосинус от x (в радианах).
math.asin (x)
Возвращает арксинус x (в радианах).
математика (х)
Возвращает арктангенс х (в радианах).
math.atan2 (у, х)
Возвращает арктангенс y / x (в радианах), но использует знаки обоих параметров, чтобы найти квадрант результата. (Он также правильно обрабатывает случай, когда х равен нулю.)
math.ceil (x)
Возвращает наименьшее целое число, большее или равное x.
math.cos (x)
Возвращает косинус x (предполагается в радианах).
math.cosh (x)
Возвращает гиперболический косинус x.
math.deg (x)
Возвращает угол x (в радианах) в градусах.
math.exp (x)
Возвращает значение e power x.
math.floor (x)
Возвращает наибольшее целое число, меньшее или равное x.
math.fmod (x, y)
Возвращает остаток от деления x на y, которое округляет частное к нулю.
math.frexp (x)
Возвращает m и e, такие что x = m2e, e является целым числом, а абсолютное значение m находится в диапазоне [0,5, 1) (или ноль, когда x равен нулю).
math.huge
Значение HUGE_VAL, значение больше или равно любому другому числовому значению.
math.ldexp (м, е)
Возвращает m2e (e должно быть целым числом).
math.log (x)
Возвращает натуральный логарифм x.
math.log10 (x)
Возвращает основание-10 логарифм х.
math.max (x, …)
Возвращает максимальное значение среди своих аргументов.
math.min (x, …)
Возвращает минимальное значение среди своих аргументов.
math.modf (x)
Возвращает два числа, неотъемлемую часть x и дробную часть x.
math.pi
Значение пи.
math.pow (x, y)
Возвращает ху. (Вы также можете использовать выражение x ^ y для вычисления этого значения.)
math.rad (x)
Возвращает угол x (в градусах) в радианах.
math.random ([m [, n]])
Эта функция является интерфейсом к простой функции генератора псевдослучайных рандов, предоставляемой ANSI C. При вызове без аргументов возвращает равномерное псевдослучайное действительное число в диапазоне [0,1). При вызове с целым числом m, math.random возвращает равномерное псевдослучайное целое число в диапазоне [1, m]. При вызове с двумя целыми числами m и n math.random возвращает равномерное псевдослучайное целое число в диапазоне [m, n].
математика. случайное семя (х)
Устанавливает x в качестве «начального числа» для псевдослучайного генератора: равные начальные числа создают равные последовательности чисел.
математика (х)
Возвращает синус х (предполагается в радианах).
math.sinh (x)
Возвращает гиперболический синус x.
math.sqrt (x)
Возвращает квадратный корень из х. (Вы также можете использовать выражение x ^ 0.5 для вычисления этого значения.)
математика (х)
Возвращает тангенс 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
Приведенные выше примеры являются лишь некоторыми из распространенных примеров, мы можем использовать математическую библиотеку в зависимости от наших потребностей, поэтому попробуйте использовать все функции, чтобы быть более знакомыми.
Lua — Возможности операционной системы
В любом приложении это часто требуется для доступа к функциям уровня операционной системы, и оно доступно с библиотекой операционной системы. Список доступных функций приведен в следующей таблице.
Sr.No. | Библиотека / Метод и Цель |
---|---|
1 |
os.clock () Возвращает приблизительную величину в секундах процессорного времени, используемого программой. |
2 |
os.date ([формат [, время]]) Возвращает строку или таблицу, содержащую дату и время, отформатированные в соответствии с заданным форматом строки. |
3 |
os.difftime (t2, t1) Возвращает количество секунд от времени t1 до времени t2. В POSIX, Windows и некоторых других системах это значение точно равно t2-t1. |
4 |
os.execute ([команда]) Эта функция эквивалентна системе функций ANSI C. Он передает команду для выполнения оболочкой операционной системы. Его первый результат — true, если команда завершилась успешно, или nil в противном случае. |
5 |
os.exit ([code [, close]) Вызывает выход из функции ANSI C, чтобы завершить программу хоста. Если код равен true, возвращаемый статус — EXIT_SUCCESS; если код ложен, возвращаемый статус — EXIT_FAILURE; если код — число, возвращаемое состояние — это число. |
6 |
os.getenv (varname) Возвращает значение переменной среды процесса varname или nil, если переменная не определена. |
7 |
os.remove (имя файла) Удаляет файл (или пустой каталог в системах POSIX) с указанным именем. Если эта функция завершается ошибкой, она возвращает nil плюс строку, описывающую ошибку и код ошибки. |
8 |
os.rename (старое имя, новое имя) Переименовывает файл или каталог с именем oldname в newname. Если эта функция завершается ошибкой, она возвращает nil плюс строку, описывающую ошибку и код ошибки. |
9 |
os.setlocale (locale [, category]) Устанавливает текущую локаль программы. locale — системно-зависимая строка, определяющая локаль; категория — необязательная строка, описывающая, какую категорию изменить: «all», «collate», «ctype», «денежный», «числовой» или «время»; категория по умолчанию — «все». Функция возвращает имя новой локали или nil, если запрос не может быть выполнен. |
10 |
os.time ([таблица]) Возвращает текущее время при вызове без аргументов или время, представляющее дату и время, указанные в данной таблице. Эта таблица должна содержать поля year, month и day и может иметь поля hour (по умолчанию 12), min (по умолчанию 0), sec (по умолчанию 0) и isdst (по умолчанию nil). Описание этих полей см. В функции os.date. |
11 |
os.tmpname () Возвращает строку с именем файла, которую можно использовать для временного файла. Файл должен быть явно открыт перед использованием и явно удален, когда он больше не нужен. |
os.clock ()
Возвращает приблизительную величину в секундах процессорного времени, используемого программой.
os.date ([формат [, время]])
Возвращает строку или таблицу, содержащую дату и время, отформатированные в соответствии с заданным форматом строки.
os.difftime (t2, t1)
Возвращает количество секунд от времени t1 до времени t2. В POSIX, Windows и некоторых других системах это значение точно равно t2-t1.
os.execute ([команда])
Эта функция эквивалентна системе функций ANSI C. Он передает команду для выполнения оболочкой операционной системы. Его первый результат — true, если команда завершилась успешно, или nil в противном случае.
os.exit ([code [, close])
Вызывает выход из функции ANSI C, чтобы завершить программу хоста. Если код равен true, возвращаемый статус — EXIT_SUCCESS; если код ложен, возвращаемый статус — EXIT_FAILURE; если код — число, возвращаемое состояние — это число.
os.getenv (varname)
Возвращает значение переменной среды процесса varname или nil, если переменная не определена.
os.remove (имя файла)
Удаляет файл (или пустой каталог в системах POSIX) с указанным именем. Если эта функция завершается ошибкой, она возвращает nil плюс строку, описывающую ошибку и код ошибки.
os.rename (старое имя, новое имя)
Переименовывает файл или каталог с именем oldname в newname. Если эта функция завершается ошибкой, она возвращает nil плюс строку, описывающую ошибку и код ошибки.
os.setlocale (locale [, category])
Устанавливает текущую локаль программы. locale — системно-зависимая строка, определяющая локаль; категория — необязательная строка, описывающая, какую категорию изменить: «all», «collate», «ctype», «денежный», «числовой» или «время»; категория по умолчанию — «все». Функция возвращает имя новой локали или nil, если запрос не может быть выполнен.
os.time ([таблица])
Возвращает текущее время при вызове без аргументов или время, представляющее дату и время, указанные в данной таблице. Эта таблица должна содержать поля year, month и day и может иметь поля hour (по умолчанию 12), min (по умолчанию 0), sec (по умолчанию 0) и isdst (по умолчанию nil). Описание этих полей см. В функции os.date.
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
Приведенные выше примеры являются лишь некоторыми из распространенных примеров, мы можем использовать библиотеку ОС в зависимости от наших потребностей, поэтому попробуйте использовать все функции, чтобы быть более знакомыми. Существуют такие функции, как удаление, которое помогает в удалении файла, выполнение, которое помогает нам выполнять команды ОС, как описано выше.