Lua
Lua (/ ˈl uː ə / LOO -ə ; ад партугальскай : lua [ ˈlu(w)ɐ ], што азначае Месяц ) — высокаўзроўневая шматпарадыгмавая скрыптовая мова праграмаваньня. Lua з'яўляецца кросплатформеннай, паколькі інтэрпрэтатар скампіляванага байт-кода напісаны на ANSI C, і Lua мае адносна простае C API для ўбудавання яго ў дадаткі.
Гісторыя
Lua быў створаны ў 1993 годзе Раберта Ерусалімскім, Луісам Гэнрыке дэ Фігуэйрэда і Вальдэмарам Сэлесам, членамі Computer Graphics Technology Group (Tecgraf) "групы тэхналогій камп'ютэрнай графікі" у Папскім каталіцкім універсітэце Рыа-дэ-Жанэйра ў Бразіліі .
З 1977 па 1992 год у Бразілія праводзіла палітыку жорсткіх гандлёвых бар'ераў (так званых рынкавых рэзерваў) у дачыненьні да камп'ютэрнага абсталявання і праграмнага забеспячэння, мяркуючы, што Бразілія можа і павінна вырабляць іх сама. З-за чаго кліенты Tecgraf не маглі дазволіць сабе, ні палітычна, ні фінансава, купляць індывідуальнае праграмнае забеспячэнне з-за мяжы; згодна з рынкавым рэзервам, кліенты павінны былі б прайсці праз складаны бюракратычны працэс, каб даказаць, што іх патрэбы не могуць быць задаволены бразільскімі кампаніямі. Гэта вымусіла Tecgraf да стварэння неабходных інструментаў з нуля.
Папярэднікамі Lua былі мовы SOL (Simple Object Language) "Простая Аб'ектная Мова" і DEL (Data-Entry Language) "Мова Увода Даных". Яны былі незалежна распрацаваны ў Tecgraf у 1992–1993 гадах, каб дадаць некаторую гнуткасць у два розныя праекты (абодва былі інтэрактыўнымі графічнымі праграмамі для кампаніі Petrobras ). У SOL і DEL не хапала структур кіравання патокам, і Petrobras адчувала ўсё большую патрэбу ў тым, каб дадаць да іх поўную магутнасць праграмавання.
У «Эвалюцыі Lua» аўтары мовы напісалі:
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 kB .
Як мова з дынамічнай тыпізацыяй, прызначаная для выкарыстання ў якасці мовы сцэнарыяў, Lua досыць кампактная, каб змясціцца на розных хост-платформах. Яна падтрымлівае толькі невялікую колькасць атамарных структур даных, такіх як лагічныя значэнні, лічбы (па змаўчанні з плаваючай кропкай падвойнай дакладнасці і 64-бітныя цэлыя ) і радкі. Тыповыя структуры даных, такія як масівы, наборы, спісы і запісы, могуць быць прадстаўлены з дапамогай адзінай уласнай структуры даных Lua, табліцы, якая па сутнасці з'яўляецца гетэрагенным асацыятыўным масівам .
Lua рэалізуе невялікі набор пашыраных функцый, такіх як першакласныя функцыі, зборка смецця, замыканні, правільныя хваставыя выклікі, прымус (аўтаматычнае пераўтварэнне паміж радковымі і лікавымі значэннямі падчас выканання), супраграмы (кааператыўная шматзадачнасць) і дынамічная загрузка модуляў .
Сінтаксіс
Класічны "Hello, World!" праграма можа быць запісана наступным чынам, з дужкамі або без:
Каментарый у Lua пачынаецца з падвойнага злучка і працягваецца да канца радка, падобна да Ada, Eiffel, Haskell, SQL і VHDL . Шматрадковыя радкі і каментарыі абмежаваныя падвойнымі квадратнымі дужкамі.
-- Single line comment
--[[
Multi-line comment
]]
У гэтым прыкладзе фактарыял рэалізаваны як функцыя:
function factorial(n)
local x = 1
for i = 2, n do
x = x * i
end
return x
end
Кіраванне патокам
Lua мае адзіную канструкцыю умоўнага тэсту: if then end з неабавязковым else і elseif then.
Стандартны аператар if then end патрабуе ўсіх трох ключавых слоў:
if condition then
--statement body
end
Ключавое слова else можа быць дададзена з суправаджальным блокам аператараў для кіравання выкананнем, калі ўмова if вылічваецца як false :
if condition then
--statement body
else
--statement body
end
Множны выбар рэалізуецца канструкцыяй elseif then :
if condition then
--statement body
elseif condition then
--statement body
else -- optional
--optional default statement body
end
Lua мае чатыры тыпы ўмоўных цыклаў: <code id="mw-w">while</code>, repeat (падобны на <code id="mw_g">do while</code> ), лікавы <code id="mwAQA">for</code> і агульны for .
--condition = true
while condition do
--statements
end
repeat
--statements
until condition
for i = first, last, delta do --delta may be negative, allowing the for loop to count down or up
--statements
--example: print(i)
end
Гэты for будзе перабіраць табліцу _G з выкарыстаннем стандартнай функцыі ітэратараў pairs пакуль не верне nil:
for key, value in pairs(_G) do
print(key, value)
end
Цыклы таксама могуць быць укладзенымі (змяшчацца ўнутры іншага цыкла).
local grid = {
{ 11, 12, 13 },
{ 21, 22, 23 },
{ 31, 32, 33 }
}
for y, row in pairs(grid) do
for x, value in pairs(row) do
print(x, y, value)
end
end
Функцыі
Абыходжанне з функцыяй як сутнасцю першага класа паказана ў наступным прыкладзе, дзе паводзіны функцыі <code id="mw_g">print</code> зменены:
do
local oldprint = print
-- Store current print function as oldprint
function print(s)
--[[ Redefine print function. The usual print function can still be used
through oldprint. The new one has only one argument.]]
oldprint(s == "foo" and "bar" or s)
end
end
Любыя будучыя выклікі <code id="mwAZI">print</code> цяпер будуць накіроўвацца праз новую функцыю, з-за лексічнага ахопу Lua старая функцыя <code id="mw_g">print</code> будзе даступная толькі цераз новаю змененую <code id="mw_g">print</code>. Lua таксама падтрымлівае замыканні, як паказана ніжэй:
function addto(x)
-- Return a new function that adds x to the argument
return function(y)
--[[ When we refer to the variable x, which is outside the current
scope and whose lifetime would be shorter than that of this anonymous
function, Lua creates a closure.]]
return x + y
end
end
fourplus = addto(4)
print(fourplus(3)) -- Prints 7
--This can also be achieved by calling the function in the following way:
print(addto(4)(3))
--[[ This is because we are calling the returned function from 'addto(4)' with the argument '3' directly.
This also helps to reduce data cost and up performance if being called iteratively.]]
Новае замыканне для зменнай x ствараецца кожны раз, калі выклікаецца addto, так што кожная новая вернутая ананімная функцыя будзе заўсёды мець доступ да ўласнага параметру x .
Табліцы
Табліца - адзіны убудаваны складаны тып даных у Lua, аснова усіх тыпаў, ствараемых карыстальнікамі. Яна ўяўляе сабой асацыятыўны масіў з наданнем аўтаматычнага лічбавага ключа і спецыяльнага сінтаксісу.
Табліцы ствараюцца з дапамогай сінтаксісу канструктара {} .
a_table = {} -- Creates a new, empty table
Табліцы заўсёды перадаюцца па спасылцы (гл. Выклік праз абмен ).
Ключ (індэкс) можа быць любым значэннем, акрамя nil і NaN, уключаючы функцыі.
a_table = {x = 10} -- Creates a new table, with one entry mapping "x" to the number 10.
print(a_table["x"]) -- Prints the value associated with the string key, in this case 10.
b_table = a_table
b_table["x"] = 20 -- The value in the table has been changed to 20.
print(b_table["x"]) -- Prints 20.
print(a_table["x"]) -- Also prints 20, because a_table and b_table both refer to the same table.
Табліца часта ўжываецца як структура (або запіс ), выкарыстоўваючы радкі ў якасці ключоў. Паколькі такое выкарыстанне вельмі распаўсюджана, Lua мае спецыяльны сінтаксіс для доступу да такіх палёў.
point = { x = 10, y = 20 } -- Create new table
print(point["x"]) -- Prints 10
print(point.x) -- Has exactly the same meaning as line above. The easier-to-read dot notation is just syntactic sugar.
Выкарыстоўваючы табліцу для захоўвання звязаных функцый, яна можа дзейнічаць як прастора імёнаў.
Point = {}
Point.new = function(x, y)
return {x = x, y = y} -- return {["x"] = x, ["y"] = y}
end
Point.set_x = function(point, x)
point.x = x -- point["x"] = x;
end
Элементам табліцы аўтаматычна надаюцца лічбавыя ключы, што дазваляе выкарыстоўваць табліцы як масівы. Першы аўтаматычны індэкс роўны 1, а не 0, як у многіх іншых мовах праграмавання (але яўны індэкс 0 магчымы).
Лічбавы ключ 1 не тое самае што радковы ключ "1".
array = { "a", "b", "c", "d" } -- Indices are assigned automatically.
print(array[2]) -- Prints "b". Automatic indexing in Lua starts at 1.
print(#array) -- Prints 4. # is the length operator for tables and strings.
array[0] = "z" -- Zero is a legal index.
print(#array) -- Still prints 4, as Lua arrays are 1-based.
Памер табліцы t вызначаецца як любы цэлы індэкс n такі што t[n] не nil і t[n+1] роўны nil; акрамя таго, калі t[1] nil, n можа быць роўным нулю. Для рэгулярнага масіву з ненулявымі значэннямі ад 1 да дадзенага n яго памер дакладна роўны n, індэксу яго апошняга значэння. Калі масіў мае "дзіркі" (нулявыя значэнні паміж іншымі значэннямі, выдатнымі ад нуля), то #t можа быць любым з індэксаў, які непасрэдна папярэднічае nil значэнню (гэта значыць, ён можа разглядаць любое такое нулявое значэнне як канец масіву).
ExampleTable =
{
{1, 2, 3, 4},
{5, 6, 7, 8}
}
print(ExampleTable[1][3]) -- Prints "3"
print(ExampleTable[2][4]) -- Prints "8"
Табліца можа быць масівам аб'ектаў.
function Point(x, y) -- "Point" object constructor
return { x = x, y = y } -- Creates and returns a new object (table)
end
array = { Point(10, 20), Point(30, 40), Point(50, 60) } -- Creates array of points
-- array = { { x = 10, y = 20 }, { x = 30, y = 40 }, { x = 50, y = 60 } };
print(array[2].y) -- Prints 40
Выкарыстанне хэш-табліцы для эмуляцыі масіву звычайна павольней, чым выкарыстанне фактычнага масіву; аднак табліцы Lua аптымізаваны для выкарыстання ў якасці масіваў, каб пазбегнуць гэтай праблемы.
Мэтатабліцы
Пашыраемая семантыка з'яўляецца ключавой асаблівасцю Lua, а канцэпцыя мэтатабліцы дазваляе гібкую наладу табліц. У наступным прыкладзе дэманструецца "бясконцая" табліца. Для любога n fibs[n] дасць n -ы лік Фібаначы з дапамогай дынамічнага праграмавання і мэмаізацыі .
fibs = { 1, 1 } -- Initial values for fibs[1] and fibs[2].
setmetatable(fibs, {
__index = function(values, n) --[[__index is a function predefined by Lua,
it is called if key "n" does not exist.]]
values[n] = values[n - 1] + values[n - 2] -- Calculate and memoize fibs[n].
return values[n]
end
})
Аб'ектна-арыентаванае праграмаванне
Нягледзячы на тое, што Lua не мае ўбудаванай канцэпцыі класаў, аб'ектна-арыентаванае праграмаванне можа эмулявацца з дапамогай функцый і табліц. Аб'ект фармуецца шляхам размяшчэння метадаў і палёў у табліцы. Спадкаванне (як адзінкавае, так і множнае) можа быць рэалізавана з дапамогай метатабліц, дэлегуючы неіснуючыя метады і палі бацькоўскаму аб'екту.
У гэтым выпадку такога паняцця як «клас» не існуе; хутчэй, гэта падобна да прататыпнага спадкавання, як у Self або JavaScript . Новыя аб'екты ствараюцца альбо фабрычным метадам (які стварае новыя аб'екты з нуля), альбо шляхам кланавання існуючага аб'екта.
Стварэнне простага вектарнага аб'екта:
local Vector = {}
local VectorMeta = { __index = Vector}
function Vector.new(x, y, z) -- The constructor
return setmetatable({x = x, y = y, z = z}, VectorMeta)
end
function Vector.magnitude(self) -- Another method
return math.sqrt(self.x^2 + self.y^2 + self.z^2)
end
local vec = Vector.new(0, 1, 0) -- Create a vector
print(vec.magnitude(vec)) -- Call a method (output: 1)
print(vec.x) -- Access a member variable (output: 0)
Тут setmetatable загадвае Lua шукаць элемент у табліцы Vector, калі ён адсутнічае ў табліцы vec. vec.magnitude, што эквівалентна vec [ "magnitude" ], спачатку шукае элемент magnitude у табліцы vec. Табліца vec не мае элемента magnitude, але яе метатабліца дэлегуе элемент magnitude ў табліцу Vector, калі ён не знойдзены ў табліцы vec.
Lua мае некаторы сінтаксічны цукар для палягчэння апісання класу. Каб аб'явіць функцыі-члены ўнутры табліцы-прататыпа, можна выкарыстоўваць function table : func ( args ), што эквівалентна function table . func ( self , args ) . Для выкліку метадаў класа таксама можа выкарыстоўвац двукроп'е: object : func ( args ) эквівалентна object . func ( object , args ) .
Улічваючы гэта, вось адпаведны клас з : сінтаксічным цукрам:
local Vector = {}
Vector.__index = Vector
function Vector:new(x, y, z) -- The constructor
-- Since the function definition uses a colon,
-- its first argument is "self" which refers
-- to "Vector"
return setmetatable({x = x, y = y, z = z}, self)
end
function Vector:magnitude() -- Another method
-- Reference the implicit object using self
return math.sqrt(self.x^2 + self.y^2 + self.z^2)
end
local vec = Vector:new(0, 1, 0) -- Create a vector
print(vec:magnitude()) -- Call a method (output: 1)
print(vec.x) -- Access a member variable (output: 0)
Спадкаванне
Спадкаванне у Lua таксама магчыма з дапамогай метатабліц. У наступным прыкладзе мы рэалізуем аперацыю памнажэння вектара на канстанту ў вытворным класе.
local Vector = {}
Vector.__index = Vector
function Vector:new(x, y, z) -- The constructor
-- Here, self refers to whatever class's "new"
-- method we call. In a derived class, self will
-- be the derived class; in the Vector class, self
-- will be Vector
return setmetatable({x = x, y = y, z = z}, self)
end
function Vector:magnitude() -- Another method
-- Reference the implicit object using self
return math.sqrt(self.x^2 + self.y^2 + self.z^2)
end
-- Example of class inheritance
local VectorMult = {}
VectorMult.__index = VectorMult
setmetatable(VectorMult, Vector) -- Make VectorMult a child of Vector
function VectorMult:multiply(value)
self.x = self.x * value
self.y = self.y * value
self.z = self.z * value
return self
end
local vec = VectorMult:new(0, 1, 0) -- Create a vector
print(vec:magnitude()) -- Call a method (output: 1)
print(vec.y) -- Access a member variable (output: 1)
vec:multiply(2) -- Multiply all components of vector by 2
print(vec.y) -- Access member again (output: 2)
Lua таксама падтрымлівае множнае спадкаванне ; __index можа быць функцыяй або табліцай. Перагрузка аператара таксама можа быць зроблена; Метатабліцы Lua могуць мець такія элементы, як __add, __sub і гэтак далей.
Рэалізацыя
Праграмы на Lua не інтэрпрэтуюцца непасрэдна з тэкставага файла, а кампілююцца ў байт-код, які потым запускаецца на віртуальнай машыне Lua. Працэс кампіляцыі звычайна нябачны для карыстальніка і выконваецца падчас выканання, асабліва калі выкарыстоўваецца JIT-кампілятар, але ён можа быць выкананы загадзя, каб паскорыць загрузку або, прыбраўшы кампілятар, паменшыць аб'ём памяці хост-асяроддзя. Кампіляцыя у байт-код магчыма таксама ўнутры праграмы на Lua, выкарыстоўваючы функцыю dump з бібліятэкі радкоў альбо функцыі load/loadstring/loadfile.
Lua версіі 5.3.4 рэалізавана прыкладна ў 24 000 радках кода C.
У адрозненне ад большасці віртуальных машын (якія звычайна стэкавыя), віртуальная машына Lua рэгістравая і таму больш нагадвае рэальную апаратную канструкцыю. Рэгістравая архітэктура пазбягае празмернага капіравання значэнняў і памяншае агульную колькасць інструкцый на функцыю. Віртуальная машына Lua 5 з'яўляецца адной з першых чыста рэгістравых віртуальных машын, якія атрымалі шырокае прымяненне.
Наступны прыклад - гэта байт-код функцыі фактарыялу, вызначанай вышэй (згодна з кампілятарам 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] FORPREP 2 1 ; да 7 6 [4] MUL 1 1 5 7 [3] FORLOOP 2 -2 ; да 6 8 [6] ВЯРТАННЕ 1 2 9 [7] ВЯРТАННЕ 0 1
C API
Lua была распрацавана з мэтай убудавання ў іншыя праграмы, дзеля гэтага яна распаўсюджваецца разам з C API. Які складаецца з дзвюх частак: ядро Lua і дапаможнай бібліятэкі Lua. Апошняя складаецца ў асноўным з макрасаў прэпрацэсара, якія дапамагаюць са складанымі таблічнымі аперацыямі.
Lua C API заснаваны на стэку . Lua забяспечвае функцыі для праштурхоўвання і выцягвання большасці простых тыпаў даных C (цэлыя лікі, плывучыя і г.д.) у стэк і са стэка, а таксама функцыі для маніпулявання табліцамі праз стэк. Стэк Lua некалькі адрозніваецца ад традыцыйнага стэка; напрыклад, яго можна непасрэдна праіндэксаваць. Адмоўныя індэксы паказваюць зрушэнні ад вяршыні стэка. Напрыклад, −1 з'яўляецца верхнім (апошняе значэнне), у той час як дадатныя індэксы паказваюць зрушэнні ад ніжняга (самае старое значэнне). Маршалінг даных паміж функцыямі C і Lua таксама выконваецца з дапамогай стэка. Каб выклікаць функцыю Lua, аргументы замяшчаюцца ў стэк, а затым lua_call выкарыстоўваецца для выкліку Lua функцыі. Пры напісанні функцыі C для непасрэднага выкліку з Lua аргументы счытваюцца са стэка.
Вось прыклад выкліку функцыі Lua з C:
#include <stdio.h>
#include <lua.h> // Lua main library (lua_*)
#include <lauxlib.h> // Lua auxiliary library (luaL_*)
int main(void)
{
// create a Lua state
lua_State *L = luaL_newstate();
// load and execute a string
if (luaL_dostring(L, "function foo (x,y) return x+y end")) {
lua_close(L);
return -1;
}
// push value of global "foo" (the function defined above)
// to the stack, followed by integers 5 and 3
lua_getglobal(L, "foo");
lua_pushinteger(L, 5);
lua_pushinteger(L, 3);
lua_call(L, 2, 1); // call a function with two arguments and one return value
printf("Result: %d\n", lua_tointeger(L, -1)); // print integer value of item at stack top
lua_pop(L, 1); // return stack to original state
lua_close(L); // close Lua state
return 0;
}
Запуск гэтага прыкладу дае:
$ cc -o example example.c -llua
$ ./example
Result: 8
C API таксама забяспечвае некаторыя спецыяльныя табліцы, размешчаныя ў розных "псеўдаіндэксах" у стэку Lua. У LUA_GLOBALSINDEX да Lua 5.2 знаходзілася глабальная табліца _G, якая з'яўляецца асноўнай прасторай імёнаў. Існуе таксама рэестр, размешчаны ў LUA_REGISTRYINDEX, дзе праграмы на C могуць захоўваць даныя Lua для пазнейшага выкарыстання.
Модулі
Акрамя стандартных бібліятэчных (асноўных) модуляў, можна пісаць пашырэнні з дапамогай Lua API. Скрыпты Lua могуць загружаць модулі пашырэння з дапамогай require, гэтак жа, як стандартныя модулі самой Lua, або з дапамогай package.loadlib . Калі бібліятэка C загружаецца праз require ( 'foo' ) Lua выклікае функцыю luaopen_foo, якая дзейнічае як любая функцыя C, якую можна выклікаць з Lua, і звычайна вяртае табліцу, запоўненую метадамі. Модулі Lua, вядомыя пад назвай rocks, даступная праз сістэму кіравання пакетамі LuaRocks .
Выкарыстанне
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, Redis, ScyllaDB, Neovim, Nginx і Wireshark.
Дзякуючы пашырэнню Scribunto, Lua даступны як мова сцэнарыяў на баку сервера ў праграмным забеспячэнні MediaWiki, якое працуе ў Вікіпедыі і іншых вікі.
Спасылкі
Дадатковае чытанне
[[Катэгорыя:Скрыптовыя мовы]] [[Катэгорыя:Мовы праграмаваньня]] [[Катэгорыя:Аб'ектна-арыентаваныя мовы праграммаваньня]] [[Катэгорыя:Дынамічна тыпізуемыя мовы праграмаваньня]] [[Катэгорыя:Старонкі з недагледжанымі перакладамі]]