Lua

print("Hello World!")

print 'Hello World!'

function factorial(n)  local x = 1  for i = 2, n do    x = x * i  end  return xend

--condition = truewhile condition do  --statementsendrepeat  --statementsuntil conditionfor i = first, last, delta do  --delta可以是负数，允许计数增加或减少的循环  --statements  --example: print(i)end

通用for循环：

for key, value in pairs(_G) do  print(key, value)end

将在表格_G上使用标准迭代器函数pairs进行迭代，直到它返回nil。

可以有嵌套的循环，就是在其他循环中的循环。

local grid = {  { 11, 12, 13 },  { 21, 22, 23 },  { 31, 32, 33 }}for y, row in ipairs(grid) do  for x, value in ipairs(row) do    print(x, y, grid)  endend

函数

Lua将函数处理为头等值，在下例子中用print函数的表现可以修改来展示：

do  local oldprint = print  -- 存储当前的print函数为oldprint  function print(s)    --]    oldprint(s == "foo" and "bar" or s)  endend

任何对print的进一步调用都要经由新函数，并且由于Lua的词法作用域，这个旧的print函数将只能被这个新的修改了的print访问到。

Lua还支持闭包，展示如下：

function addto(x)  -- 返回一个把实际参数加到x上  return function(y)    --=]    return x + y  endendfourplus = addto(4)print(fourplus(3))  -- 打印7--这也可以通过如下方式调用这个函数来完成：print(addto(4)(3))--]

每次调用的时候为变量x创建新的闭包，所以返回的每个新匿名函数都访问它自己的x参数。闭包由Lua的垃圾收集器来管理，如同任何其他对象一样。

function create_a_counter()    local count = 0    return function()        count = count + 1        return count    endend

create_a_counter()会返回一个匿名函数，这个匿名函数会把count加1后再回传。在匿名函数中的变量count的值会一直被保存在匿名函数中。因此调用create_a_counter()时产生一个记数器函数，每次调用记数器函数，都会得到一个比上次大1的值。

Lua是一种动态类型语言，因此语言中没有类型的定义，不需要声明变量类型，每个变量自己保存了类型。

有8种基本类型：nil、布尔值（boolean）、数字体（number）、字符串型（string）、用户自定义类型（userdata）、函数（function）、线程（thread）和表（table）。

    print(type(nil))                    -- 输出 nil    print(type(99.7+12*9))              -- 输出 number    print(type(true))                   -- 输出 boolean    print(type("Hello Wikipedia"))      -- 输出 string    print(type(print))                  -- 输出 function    print(type{1, 2, test = "test"})    -- 输出 table

表格

表格（table）是Lua中最重要的数据结构（并且是设计中唯一内建的复合数据类型），并且是所有用户创建类型的基础。它们是增加了自动数值键和特殊语法的关联数组。

表格是键和数据的有序对的搜集，其中的数据用键来引用；换句话说，它是散列异构关联数组。

表格使用{}构造器语法来创建。

a_table = {} -- 建立一个新的空表格

表格总是用引用来传递的（参见传共享调用）。

键（索引）可以是除了nil和NaN的任何值，包括函数。

a_table = {x = 10}  -- 建立一个新表格，具有映射"x"到数10的一个表项。print(a_table) -- 打印于这个字符串关联的值，这里是10。b_table = a_tableb_table = 20   -- 在表格中的值变更为20。print(b_table) -- 打印20。print(a_table) -- 还是打印20，因为a_table和b_table都引用相同的表格。

通过使用字符串作为键，表格经常用作结构（英语：object composition）（或记录）。由于这种用法太常见，Lua为访问这种字段提供了特殊语法。

point = { x = 10, y = 20 }   -- 建立一个新表格print(point)            -- 打印10print(point.x)               -- 同上一行完全相同含义。易读的点只是语法糖。

通过使用表格来存储有关函数，它可以充当名字空间。

Point = {}Point.new = function(x, y)  return {x = x, y = y}  --  return { = x,  = y}endPoint.set_x = function(point, x)  point.x = x  --  point = x;end

表格被自动的赋予了数值键，使得它们可以被用作数组数据类型（英语：array data type）。第一个自动索引是1而非0，因为很多其他编程语言都这样（尽管显式的索引0是允许的）。

数值键1不同于字符串键"1"。

array = { "a", "b", "c", "d" }   -- 索引被自动赋予。print(array)                  -- 打印"b"。在Lua中自动索引开始于1。print(#array)                    -- 打印4。#是表格和字符串的长度算符。array = "z"                   -- 0是合法索引。print(#array)                    -- 仍打印4，因为Lua数组是基于1的。

表格的长度t被定义为任何整数索引n，使得t不是nil而t是nil；而且如果t是nil， n可以是0。对于一个正规表格，具有非nil值从1到给定n，它的长度就精确的是n，它的最后的值的索引。如果这个数组有“洞”（就是说在其他非nil值之间的nil值），则#t可以是直接前导于nil值的任何一个索引（就是说可以把任何这种nil值当作数组的结束）。

ExampleTable ={  {1, 2, 3, 4},  {5, 6, 7, 8}}print(ExampleTable) -- 打印"3"print(ExampleTable) -- 打印"8"

表格可以是对象的数组。

function Point(x, y)        -- "Point"对象构造器  return { x = x, y = y }   -- 建立并返回新对象（表格）endarray = { Point(10, 20), Point(30, 40), Point(50, 60) }   -- 建立point的数组                        -- array = { { x = 10, y = 20 }, { x = 30, y = 40 }, { x = 50, y = 60 } };print(array.y)                                         -- 打印40

使用散列映射来模拟数组通常比使用真正数组要慢；但Lua表格为用作数组而做了优化来避免这个问题。

可扩展的语义是Lua的关键特征，而“元表格”概念允许Lua的表格以强力方式来定制。下列例子展示了一个“无限”表格。对于任何n，fibs会给出第n个斐波那契数，使用了动态规划和记忆化。

fibs = { 1, 1 }                                -- 给fibs和fibs初始值。setmetatable(fibs, {  __index = function(values, n)                --]    values = values + values  -- 计算并记忆化fibs。    return values  end})

面向对象编程

尽管Lua没有内建的类的概念，可以用过两个语言特征实现面向对象编程：头等函数和表格。通过放置函数和有关数据入表格，形成一个对象。继承（单继承和多重继承二者）可以通过使用元表格机制来实现，告诉这个对象在那些父对象中查找不存在的方法。

对于这些技术不采用“类”的概念，而是采用原型，类似于Self或JavaScript。创建新对象要么通过工厂方法（从头构造一个新对象）要么通过复制现存的对象。

Lua为便利对象定向提供了一些语法糖。要声明在原型表格内的成员函数，可以使用function table:func(args)，它等价于function table.func(self, args)。调用类方法也使用冒号，object:func(args)等价于object.func(object, args)。

创建一个基本的向量对象：

local Vector = {}Vector.__index = Vectorfunction Vector:new(x, y, z)    -- 构造器  return setmetatable({x = x, y = y, z = z}, Vector)endfunction Vector:magnitude()     -- 另一个方法  -- 使用self引用隐蔽的对象  return math.sqrt(self.x^2 + self.y^2 + self.z^2)endlocal vec = Vector:new(0, 1, 0) -- 建立一个向量print(vec:magnitude())          -- 调用一个法方法 (输出: 1)print(vec.x)                    -- 访问一个成员变量 (输出: 0)

实现

Lua程序不是从文本式的Lua文件直接解释的，而是编译成字节码，接着把它运行在Lua虚拟机上。编译过程典型的对于用户是不可见并且是在运行时间进行的，但是它可以离线完成用来增加装载性能或通过排除编译器来减少对宿主环境的内存占用。Lua字节码还可以在Lua之内产生和执行，使用来自字符串库的dump函数和load/loadstring/loadfile函数。Lua版本5.3.4是用大约24,000行C代码实现的。

像大多数CPU，而不像多数虚拟机（它们是基于堆栈的），Lua VM是基于寄存器的，因此更加类似真实的硬件设计。寄存器架构既避免了过多的值复制又减少了每函数的指令的总数。Lua 5的虚拟机是第一个广泛使用的基于堆栈的纯VM。Parrot和Android的Dalvik是另外两个周知的基于寄存器的VM。PCScheme的VM也是基于寄存器的。

下面的例子列出上面定义的阶乘函数的字节码（通过luac 5.1编译器来展示）：

function <factorial.lua:1,7> (9 instructions, 36 bytes at 0x8063c60)1 param, 6 slots, 0 upvalues, 6 locals, 2 constants, 0 functions	1		LOADK    	1 -1	; 1	2		LOADK    	2 -2	; 2	3		MOVE     	3 0	4		LOADK    	4 -1	; 1	5		FORPREP  	2 1	; to 7	6		MUL      	1 1 5	7		FORLOOP  	2 -2	; to 6	8		RETURN   	1 2	9		RETURN   	0 1

C API

Lua意图被嵌入到其他应用之中，为了这个目的而提供了C API。API被分成两部分：Lua核心库和辅助库。Lua API的设计消除了对用C代码的手动引用管理的需要，不同于Python的API。API就像语言本身一样是极简主义的。高级功能通过辅助库来提供，它们很大程度上构成自预处理器宏，用以帮助做复杂的表格操作。

Lua C API是基于堆栈的。Lua提供压入和弹出最简单C数据类型（整数、浮点数等）进入和离开堆栈的函数，还有通过堆栈操作表格的函数。Lua堆栈稍微不同于传统堆栈，例如堆栈可以直接的被索引。负数索引指示从栈顶开始往下的偏移量。例如−1是在顶部的（最新进压入的值），而整数索引指示从底部（最旧的值）往上的偏移量。在C和Lua函数之间Marshalling数据也使用堆栈完成。要调用一个Lua函数，把实际参数压入堆栈，并接着使用lua_call来调用实际的函数。在写从Lua直接调用的C函数的时候，实际参数读取自堆栈。

下面是从C调用Lua函数的例子:

#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);        return -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 example.c -llua$ ./exampleResult: 8

C API还提供一些特殊表格，位于各种Lua堆栈中的“伪索引”之上。Lua 5.2之前，在LUA_GLOBALSINDEX之上是全局表格；_G来自Lua内部，它是主名字空间。还有一个注册表位于LUA_REGISTRYINDEX，在这里C程序可以存储Lua值用于以后检索。

还可以使用Lua API写扩展模块。扩展模块是通过向Lua脚本提供本地设施，用来扩展解释器的功能的共享对象。从Lua方面看来，这种模块出现为一个名字空间表格，它持有自己的函数和变量。Lua脚本可以使用require装载扩展模块，就像用Lua自身写的模块一样。一组仍在增长中的叫做“rock”的模块可以通过叫做LuaRocks的软件包管理器获取到，类似于CPAN、RubyGems和Python eggs。对大多数流行的编程语言包括其他脚本语言，都存在预先写好的Lua绑定。对于C++，有许多基于模板的方式和一些自动绑定生成器。

在视频游戏开发中，Lua被程序员广泛的用作脚本语言，主要由于它的可感知到的易于嵌入、快速执行，和短学习曲线。

在2003年，GameDev.net组织的一次投票，说明了Lua是游戏编程的最流行脚本语言。在2012年1月12日，Lua被《游戏开发者（英语：Game Developer (magazine)）》宣布为编程工具范畴的Front Line奖2011年度获奖者。

大量非游戏应用也出于可扩展性而使用Lua，比如TeX排版设置语言实现LuaTeX、键-值数据库Redis、文本编辑器Neovim和web服务器Nginx。

通过Scribunto扩展，Lua可获得为MediaWiki软件中的服务器端脚本语言，Wikipedia和其他wiki都基于了它。它的应用包括允许从Wikidata集成数据到文章中，和助力于自动生物分类框系统。

Lua可以用于嵌入式硬件，不仅可以嵌入其他编程语言，而且可以嵌入微处理器中，例如NodeMCU开源硬件项目将Lua嵌入到Wi-Fi SoC中。