Луа (язык программирования)

Два

Снимок экрана с кодом Lua из модуля Lua Википедии с использованием MediaWiki Scribunto . расширения
Парадигма	Мультипарадигмальность : скриптовая , императивная ( процедурная , на основе прототипов , объектно-ориентированная ), функциональная , мета , рефлексивная.
Разработано	Роберто Иерусалимский Вальдемар Селес Луис Энрике де Фигейредо
Впервые появился	1993 год ( 1993 )
Стабильная версия	5.4.6  / 14 мая 2023 г ( 14 мая 2023 г. )
Дисциплина набора текста	Динамичный , слабый , дак
Язык реализации	АНСИ С
ТЫ	Кросс-платформенный
Лицензия	МОЯ лицензия
Расширения имен файлов	.lua
Веб-сайт	www .два .org
Основные реализации
Луа , ЛуаЖИТ , ЛуаВела , MoonSharp , Лувит , LuaRT , Lua u
Диалекты
Metalua , Холостой ход , GSL Shell
Под влиянием
C++ , CLU , Модуль , Схема , СНОБОЛ
Под влиянием
GameMonkey , Io , JavaScript , Юля , MiniD, Красный , Кольцо , Рубин , Белка , MoonScript, C--

Lua ( / ˈ l uː ə / LOO -ə ; от португальского : lua [ˈlu(w)ɐ] означает луна ) — легкий , высокоуровневый , многопарадигмальный язык программирования, разработанный в первую очередь для встроенного использования в приложениях. Lua является кроссплатформенным , поскольку интерпретатор скомпилированного ANSI байт-кода написан на C , а у Lua есть относительно простой C API для встраивания его в приложения.

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

История

Lua был создан в 1993 году Роберто Иерусалимским , Луисом Энрике де Фигейредо и Вальдемаром Селесом, членами группы технологий компьютерной графики (Tecgraf) Папского католического университета Рио-де-Жанейро в Бразилии .

С 1977 по 1992 год Бразилия проводила политику жестких торговых барьеров (так называемых рыночных резервов) для компьютерного оборудования и программного обеспечения, полагая, что Бразилия может и должна производить собственное оборудование и программное обеспечение. В такой атмосфере клиенты Tecgraf не могли позволить себе ни политически, ни финансово покупать специализированное программное обеспечение за границей; В рамках рыночного резерва клиентам придется пройти через сложный бюрократический процесс, чтобы доказать, что их потребности не могут быть удовлетворены бразильскими компаниями. Эти причины побудили Tecgraf реализовать необходимые базовые инструменты с нуля.

Предшественниками Lua были языки описания/конфигурации данных SOL (простой объектный язык) и DEL (язык ввода данных). Они были независимо разработаны в Tecgraf в 1992–1993 годах, чтобы добавить некоторую гибкость двум различным проектам (оба представляли собой интерактивные графические программы для инженерных приложений в компании Petrobras ). В SOL и DEL отсутствовали какие-либо структуры управления потоком данных, и Petrobras чувствовала растущую потребность добавить к ним полную мощь программирования.

В «Эволюции Lua» авторы языка писали:

В 1993 году единственным реальным претендентом был Tcl , который был специально разработан для внедрения в приложения. Однако Tcl имел незнакомый синтаксис, не обеспечивал хорошей поддержки описания данных и работал только на платформах Unix. Мы не рассматривали LISP или Scheme из-за их недружественного синтаксиса. Python все еще находился в зачаточном состоянии. В свободной атмосфере «сделай сам», царившей тогда в Tecgraf, было вполне естественно попытаться разработать собственный скриптовый язык... Поскольку многие потенциальные пользователи языка не были профессиональными программистами, в языке следует избегать загадочных синтаксис и семантика. Реализация нового языка должна быть высокопереносимой, поскольку у клиентов Tecgraf была очень разнообразная коллекция компьютерных платформ. Наконец, поскольку мы ожидали, что в другие продукты Tecgraf также потребуется встроить язык сценариев, новый язык должен следовать примеру SOL и предоставляться в виде библиотеки с C API.

Lua 1.0 был разработан таким образом, что его конструкторы объектов, которые тогда немного отличались от нынешнего легкого и гибкого стиля, включали синтаксис описания данных SOL (отсюда и название Lua: Sol означает «Солнце» на португальском языке, а Lua означает "Луна"). Lua Синтаксис для управляющих структур в основном был заимствован из Modula ( if, while, repeat/ until), но также испытал влияние CLU (множественные присваивания и множественные возвраты из вызовов функций как более простая альтернатива ссылочным параметрам или явным указателям ), C++ («изящная идея, позволяющая локальную переменную только там, где она нам нужна» объявлять ), SNOBOL и AWK ( ассоциативные массивы ). В статье, опубликованной в журнале Dr. Dobb's Journal , создатели Lua также заявляют, что LISP и Scheme с их единственным, вездесущим механизмом структуры данных ( списком ) оказали большое влияние на их решение разработать таблицу в качестве основной структуры данных Lua.

Lua Семантика со временем все больше подвергалась влиянию Scheme. особенно с введением анонимных функций и полной лексической области видимости . В новых версиях Lua было добавлено несколько функций.

Версии Lua до версии 5.0 выпускались под лицензией, аналогичной лицензии BSD . Начиная с версии 5.0, Lua лицензируется по лицензии MIT . Обе лицензии являются разрешительными лицензиями на свободное программное обеспечение и практически идентичны.

Особенности

Lua обычно называют « мультипарадигмальным » языком, предоставляющим небольшой набор общих функций, которые можно расширить для решения различных типов задач. Lua не содержит явной поддержки наследования , но позволяет реализовать его с помощью метатаблиц . Точно так же Lua позволяет программистам реализовывать пространства имен , классы и другие связанные функции, используя реализацию одной таблицы; первоклассные функции позволяют использовать многие методы функционального программирования , а полная лексическая область видимости позволяет скрывать детализированную информацию, чтобы обеспечить соблюдение принципа наименьших привилегий .

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

Будучи динамически типизированным языком, предназначенным для использования в качестве языка расширения или языка сценариев , Lua достаточно компактен, чтобы соответствовать множеству хост-платформ. Он поддерживает лишь небольшое количество атомарных структур данных, таких как логические двойной точности значения, числа ( с плавающей запятой и 64-битные целые числа по умолчанию) и строки . Типичные структуры данных, такие как массивы , наборы , списки и записи , могут быть представлены с использованием единственной собственной структуры данных Lua — таблицы, которая по сути представляет собой гетерогенный ассоциативный массив .

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

Синтаксис

Классический «Привет, мир!» Программу можно записать следующим образом, с круглыми скобками или без них:

print  (  «Привет, Мир!»  ) 

напечатать   «Привет, Мир!» 

Комментарий в Lua начинается с двойного дефиса и продолжается до конца строки, аналогично Ada , Eiffel , Haskell , SQL и VHDL . Многострочные строки и комментарии оформляются двойными квадратными скобками.

-- Однострочный комментарий 
 --[[ 
 Многострочный комментарий 
 ]] 

реализована В этом примере функция факториал как функция:

функция   факториал  (  n  ) 
   локальный   x   =   1 
   для   i   =   2  ,   n   do 
     x   =   x   *   i 
   end 
   return   x 
 end 

Поток управления

В Lua есть один тип условной проверки: if then end с дополнительным else и elseif then Конструкции управления выполнением.

Общий if then end оператор требует всех трех ключевых слов:

if   условие   then 
	 --statement тело 
 конец 

The else Ключевое слово может быть добавлено вместе с сопровождающим блоком операторов для управления выполнением, когда if состояние оценивается как false:

if   условие   then 
	 --statement body 
 else 
	 --statement body 
 end 

Выполнением также можно управлять в соответствии с несколькими условиями с помощью elseif then ключевые слова:

if   условие   then 
	 --тело оператора 
 elseif   условие   then 
	 --тело оператора 
 else   -- необязательный 
	 --optional тело оператора по умолчанию 
 конец 

В Lua есть четыре типа условных циклов: while петля , repeat цикл (аналогично do while цикл ), числовой for цикл и общий for петля.

--condition = true 

 while   условие   do 
   --statements 
 end 

 повторять 
   --statements 
 до тех пор, пока   условие 

 для   i   =   first  ,   last  ,   delta   do    --delta может быть отрицательным, позволяя циклу for вести обратный или обратный отсчет 
   --statements 
   --example: распечатать(я) 
 конец 

Этот универсальный for цикл будет перебирать таблицу _G используя стандартную функцию итератора pairs, пока не вернется nil:

для   ключа  ,   значения   в   парах  (  _G  )   do 
   print  (  key  ,   value  ) 
 end 

Циклы также могут быть вложенными (помещаться внутри другого цикла).

локальная   сетка   =   { 
   {   11  ,   12  ,   13   } , 
   {   21  ,   22  ,   23   } , 
   {   31  ,   32  ,   33   } 
 } 

 для   y  ,   строка   в   парах  (  сетка  )   сделать 
   для   x  ,   значение   в   парах  (  строка  )   сделать 
     печать  (  x  ,   y  ,   значение  ) 
   конец 
 конец 

Функции

Обработка функций в Lua как значений первого класса показана в следующем примере, где изменено поведение функции печати:

do 
   local   oldprint   =   print 
   -- Сохранить текущую функцию печати как 
   функцию   oldprint print  (  s  ) 
     --[[ Переопределить функцию печати.   Обычную функцию печати по-прежнему можно использовать 
 через oldprint.   Новый имеет только один аргумент.]] 
     oldprint  (  s   ==   "foo"   и   "bar"   или   s  ) 
   end 
 end 

Любые будущие вызовы print теперь будет маршрутизироваться через новую функцию, а из-за лексической области видимости Lua старая функция печати будет доступна только для новой, модифицированной печати.

Lua также поддерживает замыкания , как показано ниже:

function   addto  (  x  ) 
   -- Возвращает новую функцию, которая добавляет x к аргументу 
   return   function  (  y  ) 
     --[[ Когда мы ссылаемся на переменную x, которая находится за пределами текущей 
 области видимости и время жизни которой будет короче, чем у этой анонимная 
 функция, Lua создает замыкание.]] 
     return   x   +   y 
   end 
 end 
 fourplus   =   addto  (  4  ) 
 print  (  fourplus  (  3  ))   -- печатает 7 

 -- Этого также можно добиться, вызвав функцию следующим образом: 
 print  (  addto  (  4  )(  3  )) 
 --[[ Это потому, что мы вызываем функцию, возвращаемую из 'addto(4)' напрямую с аргументом '3'. 
  Это также помогает снизить стоимость данных и повысить производительность при итеративном вызове.]] 

Новое замыкание для переменной x создается каждый раз addto вызывается, так что каждая новая возвращаемая анонимная функция всегда будет иметь доступ к своей собственной xпараметр. Закрытием управляет сборщик мусора Lua, как и любой другой объект.

Таблицы

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

Таблица представляет собой набор пар ключей и данных, где на данные ссылается ключ; другими словами, это хешированный гетерогенный ассоциативный массив.

Таблицы создаются с помощью {} синтаксис конструктора.

a_table   =   {}   — Создает новую пустую таблицу. 

Таблицы всегда передаются по ссылке (см. Вызов путем совместного использования ).

Ключ (индекс) может иметь любое значение, кроме nil и NaN , включая функции.

a_table   =   {  x   =   10  }    — Создает новую таблицу, в которой одна запись сопоставляет «x» с числом 10. 
 print  (  a_table  [  «x»  ])   — Печатает значение, связанное со строковым ключом, в данном случае 10 . 
 b_table   =   a_table 
 b_table  [  "x"  ]   =   20     -- Значение в таблице изменено на 20. 
 print  (  b_table  [  "x"  ])   -- Печатает 20. 
 print  (  a_table  [  "x"  ])   -- Также печатает 20, поскольку a_table и b_table ссылаются на одну и ту же таблицу. 

Таблица часто используется как структура (или запись ), используя строки в качестве ключей. Поскольку такое использование очень распространено, Lua имеет специальный синтаксис для доступа к таким полям.

point   =   {   x   =   10  ,   y   =   20   }     -- Создать новую таблицу 
 print  (  point  [  "x"  ])              -- Печатает 10 
 print  (  point  .  x  )                 -- Имеет то же значение, что и строка выше.   Более понятная точечная запись — это просто синтаксический сахар. 

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

Точка   =   {} 

 Точка  .   new   =   function  (  x  ,   y  ) 
   return   {  x   =   x  ,   y   =   y  }    -- return {["x"] = x, ["y"] = y} 
 end 

 Point  .   set_x   =   функция  (  точка  ,   x  ) 
   точка  .   x   =   x    -- точка["x"] = x; 
  конец 

Таблицам автоматически присваивается числовой ключ, что позволяет использовать их в качестве типа данных массива . Первый автоматический индекс равен 1, а не 0, как во многих других языках программирования (хотя допускается явный индекс 0).

Цифровой ключ 1 отличается от строкового ключа "1".

array   =   {   "a"  ,   "b"  ,   "c"  ,   "d"   }     — Индексы назначаются автоматически. 
  print  (  array  [  2  ])                    — печатает «b».   Автоматическое индексирование в Lua начинается с 1. 
 print  (  #  array  )                      — печатает 4. # — оператор длины для таблиц и строк. 
  array  [  0  ]   =   "z"                     — ноль является допустимым индексом. 
  print  (  #  array  )                      — по-прежнему печатает 4, поскольку массивы Lua основаны на 1. 

Длина стола t определяется как любой целочисленный индекс n такой, что t[n] не является nil и t[n+1] является nil; более того, если t[1] является nil, nможет быть нулевым. Для обычного массива с ненулевыми значениями от 1 до заданного n, его длина именно такая n, индекс его последнего значения. Если в массиве есть «дыры» (то есть нулевые значения между другими ненулевыми значениями), то #t может быть любым из индексов, который непосредственно предшествует nil value (то есть любое такое нулевое значение может считаться концом массива).

exampleTable   = 
 { 
   {  1  ,   2  ,   3  ,   4  }, 
   {  5  ,   6  ,   7  ,   8  } 
 } 
 print  (  exampleTable  [  1  ][  3  ])   -- печатает "3" 
 print  (  exampleTable  [  2  ][  4  ])   - - Печатает «8» 

Таблица может представлять собой массив объектов.

function   Point  (  x  ,   y  )          -- Конструктор объекта "Точка" 
   return   {   x   =   x  ,   y   =   y   }     -- Создает и возвращает новый объект (таблицу) 
 end 
 array   =   {   Point  (  10  ,   20  ),   Point  (  30  ,   40  ),   Point  (  50  ,   60  )   }     -- Создает массив точек 
                         -- array = { { x = 10, y = 20 }, { x = 30, y = 40 }, { x = 50, y = 60 } }; 
  print  (  массив  [  2  ].y  )  —                                           печатает 40 

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

Метатаблицы

Расширяемая семантика — ключевая особенность Lua, а концепция метатаблиц обеспечивает мощную настройку таблиц. В следующем примере демонстрируется «бесконечная» таблица. Для любого n, fibs[n] даст n-е число Фибоначчи с использованием динамического программирования и мемоизации .

fibs   =   {   1  ,   1   }                                  — Начальные значения для fibs[1] и fibs[2]. 
  setmetatable  (  fibs  ,   { 
   __index   =   function  (  values  ​​,   n  )                  --[[__index — это функция, предопределенная Lua, 
 она вызывается, если ключ «n» не существует.]] 
     значения  [  n  ]   =   значения  [  n   -   1  ]   +   значения  [  n   -   2  ]    -- Вычислить и запомнить 
     возвращаемые   значения  fibs [  n  ] 
   end 
 }) 

Объектно-ориентированное программирование

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

В этих методах нет такого понятия, как «класс»; скорее, прототипы используются , подобные Self или JavaScript . Новые объекты создаются либо с помощью фабричного метода (который создает новые объекты с нуля), либо путем клонирования существующего объекта.

Создание базового векторного объекта:

local   Vector   =   {} 
 local   VectorMeta   =   {   __index   =   Vector  } 

 function   Vector  .   new  (  x  ,   y  ,   z  )      — Конструктор 
   возвращает   setmetatable  ({  x   =   x  ,   y   =   y  ,   z   =   z  },   VectorMeta  ) 
 конечную 

 функцию   Vector  .   величина  (  self  )       — Другой метод 
   return   math.sqrt  (  self  .  x  ^  2   +   self  .  y  ^  2   +   self  .  z  ^  2  ) 
 end 

 local   vec   =   Vector  .   new  (  0  ,   1  ,   0  )   -- Создать векторную 
 печать  (  vec  .  величину  (  vec  ))         -- Вызвать метод (выходные данные: 1) 
 print  (  vec  .  x  )                      -- Получить доступ к переменной-члену (выходные данные: 0) 

Здесь, setmetatable сообщает Lua искать элемент в Vector таблице, если ее нет в vec стол. vec.magnitude, что эквивалентно vec["magnitude"], впервые смотрит в vec стол для magnitudeэлемент. vec таблица не имеет magnitude элемент, но его метатаблица делегирует Vector стол для magnitude элемент, когда он не найден в vec стол.

Lua предоставляет некоторый синтаксический сахар для облегчения объектной ориентации. Чтобы объявить функции-члены внутри таблицы прототипов, можно использовать function table:func(args), что эквивалентно function table.func(self, args). При вызове методов класса также используется двоеточие: object:func(args) эквивалентно object.func(object, args).

Имея это в виду, вот соответствующий класс с : синтаксический сахар:

локальный   вектор   =   {} 
 вектор  .   __index   =   векторная 

 функция   Vector  :  new  (  x  ,   y  ,   z  )      -- Конструктор 
   -- Поскольку в определении функции используется двоеточие, 
   -- ее первым аргументом является "self", который ссылается 
   -- на "Vector" 
   return   setmetatable  ({  x   =   x  ,   y   =   y  ,   z   =   z  },   self  ) 
 end 

 function   Vector  :  unit  ()       -- Другой метод 
   -- Ссылка на неявный объект с использованием self 
   return   math.sqrt  (  self  .  x  ^  2   +   self  .  y  ^  2   +   self  .  z  ^  2  ) 
 end 

 local   vec   =   Vector  :  new  (  0  ,   1  ,   0  )   — Создать векторную 
 печать  (  vec  :  величину  ())            — Вызвать метод (выход: 1) 
 print  (  vec  .  x  )                      — - Доступ к переменной-члену (выход: 0) 

Наследование

Lua поддерживает использование метатаблиц для наследования классов Lua. В этом примере мы разрешаем векторам умножать свои значения на константу в производном классе.

локальный   вектор   =   {} 
 вектор  .   __index   =   векторная 

 функция   Vector  :  new  (  x  ,   y  ,   z  )      — Конструктор 
   — Здесь self относится к «новому» — методу любого класса, который 
   мы вызываем.   В производном классе self будет 
   — производным классом;   в классе Vector self 
   -- будет Vector 
   return   setmetatable  ({  x   =   x  ,   y   =   y  ,   z   =   z  },   self  ) 
 конечная 

 функция   Vector  :  величина  ()       -- Другой метод 
   -- Ссылка на неявный объект с использованием 
   самовозврата   math.sqrt  (  self  .  x  ^  2   +   self  .  y  ^  2   +   self  .  z  ^  2  ) 
 end 

 — Пример наследования классов 
 local   VectorMult   =   {} 
 VectorMult  .   __index   =   VectorMult 
 setmetatable  (  VectorMult  ,   Vector  )   — Сделать VectorMult дочерним элементом 

 функции   Vector VectorMult  :  умножить  (  значение  )  
   self  .   х   =   сам  .   x   *   значение 
   себя  .   у   =   сам  .   y   *   ценю 
   себя  .   z   =   сам  .   z   *   value 
   return   self 
 end 

 local   vec   =   VectorMult  :  new  (  0  ,   1  ,   0  )   -- Создание векторной 
 печати  (  vec  :  величина  ())            -- Вызов метода (выход: 1) 
 print  (  vec  .  y  )                      -- Доступ к переменной-члену (выход: 1) 
 vec  :  Multiple  (  2  )                   -- Умножить все компоненты вектора на 2 
 print  (  vec  .  y  )                      -- Снова получить доступ к элементу (выход: 2) 

Lua также поддерживает множественное наследование ; __index может быть функцией или таблицей. перегрузка операторов Также возможна ; Метатаблицы Lua могут содержать такие элементы, как __add, __sub и так далее.

Реализация

Программы Lua не интерпретируются напрямую из текстового файла Lua, а компилируются в байт-код, который затем запускается на виртуальной машине Lua . Процесс компиляции обычно невидим для пользователя и выполняется во время выполнения , особенно когда используется JIT-компилятор , но его можно выполнять и в автономном режиме, чтобы повысить производительность загрузки или уменьшить объем памяти, занимаемой средой хоста, исключив компилятор. Байт-код Lua также можно создать и выполнить изнутри Lua, используя команду dump функция из библиотеки строк и load/loadstring/loadfileфункции. Lua версии 5.3.4 реализован примерно в 24 000 строк кода C.

Как и большинство процессоров и в отличие от большинства виртуальных машин (которые основаны на стеке ), виртуальная машина Lua основана на регистрах и, следовательно, более похожа на реальную аппаратную конструкцию. Архитектура регистров позволяет избежать чрезмерного копирования значений и уменьшает общее количество инструкций на функцию. Виртуальная машина Lua 5 — одна из первых чистых виртуальных машин на основе регистров, получивших широкое распространение. Parrot и Android от Dalvik — две другие известные виртуальные машины на основе регистров. Виртуальная машина PCScheme также была основана на регистрах.

Этот пример представляет собой листинг байт-кода функции факториала, определенной выше (как показано в luac 5.1 компилятор):

функция <factorial.lua:1,7> (9 инструкций, 36 байт по адресу 0x8063c60)
 1 параметр, 6 слотов, 0 повышений, 6 локальных переменных, 2 константы, 0 функций
	 1 [2] НАГРУЗКА 1 -1 ;  1
	 2 [3] НАГРУЗКА 2 -2 ;  2
	 3 [3] ДВИЖЕНИЕ 3 0
	 4 [3] НАГРУЗКА 4 -1 ;  1
	 5 [3] ФОРПРЭП 2 1 ;  до 7
	 6 [4] МУЛ 1 1 5
	 7 [3] FORLOOP 2 -2 ;  до 6
	 8 [6] ВОЗВРАТ 1 2
	 9 [7] ВОЗВРАТ 0 1
 

C API

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

API Lua C основан на стеке . Lua предоставляет функции для отправки и извлечения наиболее простых типов данных C (целые числа, числа с плавающей запятой и т. д.) в стек и из него, а также функции для управления таблицами через стек. Стек Lua несколько отличается от традиционного стека; например, стек можно индексировать напрямую. Отрицательные индексы указывают на смещение от вершины стека. Например, −1 — это верхнее значение (последнее введенное значение), а положительные индексы указывают на смещение от нижнего (самое старое значение). Маршалинг данных между функциями C и Lua также выполняется с использованием стека. Чтобы вызвать функцию Lua, аргументы помещаются в стек, а затем lua_callиспользуется для вызова фактической функции. При написании функции C для прямого вызова из Lua аргументы считываются из стека.

Вот пример вызова функции Lua из C:

#include   <stdio.h> 
 #include   <lua.h>  // Основная библиотека Lua (lua_*) 
 #include   <lauxlib.h>  // Вспомогательная библиотека Lua (luaL_*) 

 int   main  (  void  ) 
 { 
     // создаем Lua состояние 
     lua_State   *  L   =   luaL_newstate  (); 

      // загружаем и выполняем строку 
     if   (  luaL_dostring  (  L  ,   "function foo (x,y) return x+y end"  ))   { 
         lua_close  (  L  ); 
          вернуть   -1  ; 
      } 

     // помещаем значение глобального "foo" (функция, определенная выше) 
     // в стек, за которым следуют целые числа 5 и 3 
     lua_getglobal  (  L  ,   "foo"  ); 
      lua_pushinteger  (  L  ,   5  ); 
      lua_pushinteger  (  L  ,   3  ); 
      lua_call  (  L  ,   2  ,   1  );    // вызов функции с двумя аргументами и одним возвращаемым значением 
     printf  (  "Result: %d  \n  "  ,   lua_tointeger  (  L  ,   -1  ));    // распечатываем целочисленное значение элемента на вершине стека 
     lua_pop  (  L  ,   1  );    // возвращаем стек в исходное состояние 
     lua_close  (  L  );    // закрываем состояние Lua 
     return   0  ; 
  } 

Запуск этого примера дает:

$  cc   -o   пример   example.c   -llua 
  $  ./пример 
  Результат: 8 

C API также предоставляет несколько специальных таблиц, расположенных в различных «псевдоиндексах» стека Lua. В LUA_GLOBALSINDEX до Lua 5.2 это таблица глобальных переменных, _Gизнутри Lua, которое является основным пространством имен . Также существует реестр, расположенный по адресу LUA_REGISTRYINDEX где программы C могут хранить значения Lua для последующего извлечения.

Модули

Помимо модулей стандартной библиотеки (ядра), можно писать расширения с использованием Lua API. Модули расширения — это общие объекты , которые можно использовать для расширения функциональности интерпретатора путем предоставления собственных возможностей сценариям Lua. Скрипты Lua могут загружать модули расширения, используя require, точно так же, как модули, написанные на самом Lua или с помощью package.loadlib. Когда библиотека C загружается через require('foo') Lua будет искать функцию luaopen_fooи вызвать ее, которая действует как любая функция C, вызываемая из Lua, и обычно возвращает таблицу, заполненную методами. Растущая коллекция модулей, известных как , доступна через систему управления пакетами LuaRocks . Rocks в духе CPAN , RubyGems и Python egg . Lua Предварительно написанные привязки существуют для большинства популярных языков программирования, включая другие языки сценариев. Для C++ существует ряд подходов на основе шаблонов и несколько автоматических генераторов привязок.

Приложения

Основная статья: Список приложений, использующих Lua

В разработке видеоигр Lua широко используется в качестве языка сценариев , в основном из-за его кажущейся простоты внедрения, быстрого выполнения и короткой кривой обучения . Известные игры, использующие Lua, включают Roblox , Garry's Mod , World of Warcraft , Payday 2 , Phantasy Star Online 2 , Dota 2 , Crysis , и многие другие. В некоторые игры, которые изначально не поддерживают программирование или сценарии Lua, эта функциональность добавляется с помощью модов, например, ComputerCraft для Minecraft . Кроме того, Lua также используется в программном обеспечении, не связанном с видеоиграми, таком как Adobe Lightroom , Moho , iClone , Aerospike и определенном системном программном обеспечении во FreeBSD и NetBSD , а также используется в качестве языка сценариев шаблонов в MediaWiki с использованием расширения Scribunto.

В 2003 году опрос, проведенный GameDev.net, показал, что Lua является самым популярным языком сценариев для программирования игр. 12 января 2012 года Lua был объявлен победителем премии Front Line Award 2011 журнала Game Developer в категории «Инструменты программирования».

Большое количество неигровых приложений также используют Lua для расширяемости, например LuaTeX , реализация TeX языка набора текста , Redis , база данных «ключ-значение» , ScyllaDB , хранилище с широкими колонками , Neovim , текстовый редактор, Nginx — веб-сервер и Wireshark — анализатор сетевых пакетов.

Благодаря расширению Scribunto Lua доступен в качестве серверного языка сценариев для программного обеспечения MediaWiki , которое поддерживает Википедию и другие вики. Среди его применений — возможность интеграции данных из Викиданных в статьи, и питание автоматизированной системы Taxobox .

Производные языки

Языки, компилируемые в Lua

• MoonScript — это динамический , пробелам чувствительный к язык сценариев , вдохновленный CoffeeScript , который скомпилирован в Lua. Это означает, что вместо использования do и end (или { и }) для разделения разделов кода используются разрывы строк и стиль отступов . сайт распространения видеоигр Itch.io. Примечательным примером использования MoonScript является
• Haxe поддерживает компиляцию в целевой Lua, поддерживая Lua 5.1-5.3, а также LuaJIT 2.0 и 2.1.
• Фенхель — диалект Лиспа, ориентированный на Lua.
• Urn — диалект Лиспа , построенный на Lua.
• Amulet — ML -подобный функциональный язык , компилятор которого выводит файлы Lua.

Диалекты

• LuaJIT — своевременный компилятор Lua 5.1.
• Lua u от Roblox , язык Lua 5.1 с постепенной наборкой текста и эргономичными дополнениями.
• Ravi, язык Lua 5.3 с поддержкой JIT и дополнительной статической типизацией. JIT руководствуется информацией о типе.
• Shine — ответвление LuaJIT со множеством расширений, включая систему модулей и систему макросов.
• Glua, модифицированная версия, встроенная в игру Garry's Mod в качестве языка сценариев.
• Бирюзовый — статически типизированный диалект Lua, написанный на Lua.

Кроме того, сообщество пользователей Lua предоставляет некоторые исправления мощности поверх эталонной реализации C.

См. также

• Сравнение языков программирования

Дальнейшее чтение

• Иерусалимский, Р. (2013). Программирование на Lua (3-е изд.). Луа.орг. ISBN  978-85-903798-5-0 . (Первое издание доступно в Интернете .)
• Гутшмидт, Т. (2003). Программирование игр на Python, Lua и Ruby . Курс Технологии ПТР. ISBN  978-1-59200-077-7 .
• Шуйтема, П.; Маньен, М. (2005). Разработка игр на Lua . Чарльз Ривер Медиа. ISBN  978-1-58450-404-7 .
• Юнг, К.; Браун, А. (2007). Начало программирования на Lua . Врокс Пресс . ISBN  978-0-470-06917-2 . Архивировано из оригинала 8 июля 2018 года . Проверено 7 июля 2018 г.
• Фигейредо, ЛХ; Селес, В.; Иерусалимский Р., ред. (2008). Жемчужины Lua-программирования . Луа.орг. ISBN  978-85-903798-4-3 .
• Тахтеев, Юрий (2012). Места кодирования: практика разработки программного обеспечения в южноамериканском городе . Массачусетский технологический институт Пресс . ISBN  978-0-262-01807-4 . Архивировано из оригинала 2 ноября 2012 года. Главы 6 и 7 посвящены Lua, а другие рассматривают программное обеспечение в Бразилии в более широком смысле.
• Варма, Джаянт (2012). Изучите Lua для разработки игр для iOS . Апресс . ISBN  978-1-4302-4662-6 .
• Мэтисон, Эш (29 апреля 2003 г.). «Введение в Lua» . GameDev.net . Архивировано из оригинала 18 декабря 2012 года . Проверено 3 января 2013 г.
• Филдхаус, Кейт (16 февраля 2006 г.). «Знакомство с Луа» . ONLamp.com . О'Рейли Медиа . Архивировано из оригинала 12 марта 2006 года . Проверено 28 февраля 2006 г.
• Штрайхер, Мартин (28 апреля 2006 г.). «Встраиваемые сценарии с помощью Lua» . РазработчикWorks . ИБМ . Архивировано из оригинала 2 июля 2009 года . Проверено 7 июля 2018 г.
• Куигли, Джозеф (1 июня 2007 г.). «Взгляд на Луа» . Linux-журнал .
• Гамильтон, Наоми (11 сентября 2008 г.). «А-Я языков программирования: Lua» . Компьютерный мир . ИДГ . Архивировано из оригинала 8 июля 2018 года . Проверено 7 июля 2018 г. Интервью с Роберто Иерусалимским.
• Иерусалимский, Роберто; де Фигейредо, Луис Энрике; Селес, Вальдемар (12 мая 2011 г.). «Пропуская язык сквозь игольное ушко» . Очередь АКМ . 9 (5): 20–29. дои : 10.1145/1978862.1983083 . S2CID   19484689 . Как встраиваемость Lua повлияла на его дизайн.
• Иерусалимский, Роберто; де Фигейредо, Луис Энрике; Селес, Вальдемар (ноябрь 2018 г.). «Взгляд на дизайн Lua» . Коммуникации АКМ . 61 (11): 114–123. дои : 10.1145/3186277 . S2CID   53114923 .
• Статьи и диссертации по Lua

Внешние ссылки

• Официальный веб-сайт
• Пользователи Lua. Архивировано 16 декабря 2010 г. на Wayback Machine , Сообщество.
• Форум Lua. Архивировано 28 сентября 2021 г. на Wayback Machine.
• ЛуаДист
• Lua Rocks — Менеджер пакетов
• Проекты на Lua