源代码下载：lua-cn.lua
-- 单行正文以两个连字符结尾
--[[
多行正文
--]]
----------------------------------------------------
-- 1. 变量和流程管制
----------------------------------------------------
num = 42 -- 所有的数字都是双精度浮点型。-- 别胆怯，64 位的双精度浮点型数字中有 52 位用于
-- 保留准确的整型值; 对于 52 位以内的整型值，-- 不必放心精度问题。s = 'walternate' -- 和 Python 一样，字符串不可变。t = "也能够用双引号"
u = [[ 多行的字符串
以两个方括号
开始和结尾。]]
t = nil -- 撤销 t 的定义; Lua 反对垃圾回收。-- 块应用 do/end 之类的关键字标识：while num < 50 do
num = num + 1 -- 不反对 ++ 或 += 运算符。end
-- If 语句：if num > 40 then
print('over 40')
elseif s ~= 'walternate' then -- ~= 示意不等于。-- 像 Python 一样，用 == 查看是否相等；字符串同样实用。io.write('not over 40\n') -- 默认规范输入。else
-- 默认全局变量。thisIsGlobal = 5 -- 通常应用驼峰。-- 如何定义局部变量：local line = io.read() -- 读取规范输出的下一行。-- .. 操作符用于连贯字符串：print('Winter is coming,' .. line)
end
-- 未定义的变量返回 nil。-- 这不是谬误：foo = anUnknownVariable -- 当初 foo = nil.
aBoolValue = false
-- 只有 nil 和 false 为假; 0 和 '' 均为真！if not aBoolValue then print('false') end
-- 'or' 和 'and' 短路
-- 相似于 C /js 里的 a?b:c 操作符：ans = aBoolValue and 'yes' or 'no' --> 'no'
karlSum = 0
for i = 1, 100 do -- 范畴蕴含两端
karlSum = karlSum + i
end
-- 应用 "100, 1, -1" 示意递加的范畴：fredSum = 0
for j = 100, 1, -1 do fredSum = fredSum + j end
-- 通常，范畴表达式为 begin, end[, step].
-- 循环的另一种构造：repeat
print('the way of the future')
num = num - 1
until num == 0
----------------------------------------------------
-- 2. 函数。----------------------------------------------------
function fib(n)
if n < 2 then return n end
return fib(n - 2) + fib(n - 1)
end
-- 反对闭包及匿名函数：function adder(x)
-- 调用 adder 时，会创立返回的函数，-- 并且会记住 x 的值：return function (y) return x + y end
end
a1 = adder(9)
a2 = adder(36)
print(a1(16)) --> 25
print(a2(64)) --> 100
-- 返回值、函数调用和赋值都能够
-- 应用长度不匹配的 list。-- 不匹配的接管方会被赋值 nil；-- 不匹配的发送方会被抛弃。x, y, z = 1, 2, 3, 4
-- x = 1、y = 2、z = 3, 而 4 会被抛弃。function bar(a, b, c)
print(a, b, c)
return 4, 8, 15, 16, 23, 42
end
x, y = bar('zaphod') --> 打印 "zaphod nil nil"
-- 当初 x = 4, y = 8, 而值 15..42 被抛弃。-- 函数是一等公民，能够是部分的，也能够是全局的。-- 以下表达式等价：function f(x) return x * x end
f = function (x) return x * x end
-- 这些也是等价的：local function g(x) return math.sin(x) end
local g; g = function (x) return math.sin(x) end
-- 以上均因 'local g'，使得 g 能够自援用。local g = function(x) return math.sin(x) end
-- 等价于 local function g(x)..., 但函数体中 g 不可自援用
-- 顺便提下，三角函数以弧度为单位。-- 用一个字符串参数调用函数，能够省略括号：print 'hello' -- 能够工作。-- 调用函数时，如果只有一个 table 参数，-- 同样能够省略括号（table 详情见下）：print {} -- 一样能够工作。----------------------------------------------------
-- 3. Table。----------------------------------------------------
-- Table = Lua 惟一的组合数据结构;
-- 它们是关联数组。-- 相似于 PHP 的数组或者 js 的对象，-- 它们是哈希表或者字典，也能够当列表应用。-- 按字典 /map 的形式应用 Table：-- Dict 字面量默认应用字符串类型的 key：t = {key1 = 'value1', key2 = false}
-- 字符串 key 能够应用相似 js 的点标记：print(t.key1) -- 打印 'value1'.
t.newKey = {} -- 增加新的键值对。t.key2 = nil -- 从 table 删除 key2。-- 应用任何非 nil 的值作为 key：u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'}
print(u[6.28]) -- 打印 "tau"
-- 数字和字符串的 key 按值匹配的
-- table 按 id 匹配。a = u['@!#'] -- 当初 a = 'qbert'.
b = u[{}] -- 咱们或者期待的是 1729, 然而失去的是 nil:
-- b = nil，因为没有找到。-- 之所以没找到，是因为咱们用的 key 与保留数据时用的不是同
-- 一个对象。-- 所以字符串和数字是移植性更好的 key。-- 只须要一个 table 参数的函数调用不须要括号：function h(x) print(x.key1) end
h{key1 = 'Sonmi~451'} -- 打印 'Sonmi~451'.
for key, val in pairs(u) do -- 遍历 Table
print(key, val)
end
-- _G 是一个非凡的 table，用于保留所有的全局变量
print(_G['_G'] == _G) -- 打印 'true'.
-- 按列表 / 数组的形式应用：-- 列表字面量隐式增加整数键：v = {'value1', 'value2', 1.21, 'gigawatts'}
for i = 1, #v do -- #v 是列表的大小
print(v[i]) -- 索引从 1 开始!! 太疯狂了！end
-- 'list' 并非真正的类型，v 其实是一个 table，-- 只不过它用间断的整数作为 key，能够像 list 那样去应用。----------------------------------------------------
-- 3.1 元表（metatable）和元办法（metamethod）。----------------------------------------------------
-- table 的元表提供了一种机制，反对相似操作符重载的行为。-- 稍后咱们会看到元表如何反对相似 js prototype 的行为。f1 = {a = 1, b = 2} -- 示意一个分数 a/b.
f2 = {a = 2, b = 3}
-- 这会失败：-- s = f1 + f2
metafraction = {}
function metafraction.__add(f1, f2)
local sum = {}
sum.b = f1.b * f2.b
sum.a = f1.a * f2.b + f2.a * f1.b
return sum
end
setmetatable(f1, metafraction)
setmetatable(f2, metafraction)
s = f1 + f2 -- 调用在 f1 的元表上的__add(f1, f2) 办法
-- f1, f2 没有对于元表的 key，这点和 js 的 prototype 不一样。-- 因而你必须用 getmetatable(f1) 获取元表。-- 元表是一个一般的 table，-- 元表的 key 是一般的 Lua 中的 key，例如__add。-- 然而上面一行代码会失败，因为 s 没有元表：-- t = s + s
-- 上面提供的与类类似的模式能够解决这个问题：-- 元表的__index 能够重载用于查找的点操作符：defaultFavs = {animal = 'gru', food = 'donuts'}
myFavs = {food = 'pizza'}
setmetatable(myFavs, {__index = defaultFavs})
eatenBy = myFavs.animal -- 能够工作！感激元表
-- 如果在 table 中间接查找 key 失败，会应用
-- 元表的__index 递归地重试。-- __index 的值也能够是 function(tbl, key)
-- 这样能够反对自定义查找。-- __index、__add 等的值，被称为元办法。-- 这里是一个 table 元办法的清单：-- __add(a, b) for a + b
-- __sub(a, b) for a - b
-- __mul(a, b) for a * b
-- __div(a, b) for a / b
-- __mod(a, b) for a % b
-- __pow(a, b) for a ^ b
-- __unm(a) for -a
-- __concat(a, b) for a .. b
-- __len(a) for #a
-- __eq(a, b) for a == b
-- __lt(a, b) for a < b
-- __le(a, b) for a <= b
-- __index(a, b) <fn or a table> for a.b
-- __newindex(a, b, c) for a.b = c
-- __call(a, ...) for a(...)
----------------------------------------------------
-- 3.2 与类类似的 table 和继承。----------------------------------------------------
-- Lua 没有内建的类；能够通过不同的办法，利用表和元表
-- 来实现类。-- 上面是一个例子，解释在前面：Dog = {} -- 1.
function Dog:new() -- 2.
local newObj = {sound = 'woof'} -- 3.
self.__index = self -- 4.
return setmetatable(newObj, self) -- 5.
end
function Dog:makeSound() -- 6.
print('I say' .. self.sound)
end
mrDog = Dog:new() -- 7.
mrDog:makeSound() -- 'I say woof' -- 8.
-- 1. Dog 看上去像一个类；其实它是一个 table。-- 2. 函数 tablename:fn(...) 等价于
-- 函数 tablename.fn(self, ...)
-- 冒号（:）只是增加了 self 作为第一个参数。-- 浏览 7 & 8 条 理解 self 变量是如何失去其值的。-- 3. newObj 是类 Dog 的一个实例。-- 4. self = 被继承的类。通常 self = Dog，不过继承能够扭转它。-- 如果把 newObj 的元表和__index 都设置为 self，-- newObj 就能够失去 self 的函数。-- 5. 备忘：setmetatable 返回其第一个参数。-- 6. 冒号（：）的作用和第 2 条一样，不过这里
-- self 是一个实例，而不是类
-- 7. 等价于 Dog.new(Dog)，所以在 new() 中，self = Dog。-- 8. 等价于 mrDog.makeSound(mrDog); self = mrDog。----------------------------------------------------
-- 继承的例子：LoudDog = Dog:new() -- 1.
function LoudDog:makeSound()
local s = self.sound .. ' ' -- 2.
print(s .. s .. s)
end
seymour = LoudDog:new() -- 3.
seymour:makeSound() -- 'woof woof woof' -- 4.
-- 1. LoudDog 取得 Dog 的办法和变量列表。-- 2. 因为 new() 的缘故，self 领有了一个 'sound' key，参见第 3 条。-- 3. 等价于 LoudDog.new(LoudDog)，转换一下就是
-- Dog.new(LoudDog)，这是因为 LoudDog 没有 'new' key，-- 然而它的元表中有 __index = Dog。-- 后果: seymour 的元表是 LoudDog，并且
-- LoudDog.__index = Dog。所以有 seymour.key
-- = seymour.key, LoudDog.key, Dog.key
-- 从其中第一个有指定 key 的 table 获取。-- 4. 在 LoudDog 能够找到 'makeSound' 的 key；-- 等价于 LoudDog.makeSound(seymour)。-- 如果有必要，子类也能够有 new()，与基类类似：function LoudDog:new()
local newObj = {}
-- 初始化 newObj
self.__index = self
return setmetatable(newObj, self)
end
----------------------------------------------------
-- 4. 模块
----------------------------------------------------
--[[我把这部分给正文了，这样脚本剩下的局部能够运行 -- 假如文件 mod.lua 的内容相似这样：local M = {}
local function sayMyName()
print('Hrunkner')
end
function M.sayHello()
print('Why hello there')
sayMyName()
end
return M
-- 另一个文件能够应用 mod.lua 的性能：local mod = require('mod') -- 运行文件 mod.lua.
-- require 是蕴含模块的规范做法。-- require 等价于: (针对没有被缓存的状况；参见前面的内容)
local mod = (function ()
<contents of mod.lua>
end)()
-- mod.lua 被包在一个函数体中，因而 mod.lua 的局部变量
-- 对外不可见。-- 上面的代码能够工作，因为在这里 mod = mod.lua 中的 M：mod.sayHello() -- Says hello to Hrunkner.
-- 这是谬误的；sayMyName 只在 mod.lua 中存在：mod.sayMyName() -- 谬误
-- require 返回的值会被缓存，所以一个文件只会被运行一次，-- 即便它被 require 了屡次。-- 假如 mod2.lua 蕴含代码 "print('Hi!')"。local a = require('mod2') -- 打印 Hi!
local b = require('mod2') -- 不再打印; a=b.
-- dofile 与 require 相似，然而不缓存：dofile('mod2') --> Hi!
dofile('mod2') --> Hi! (再次运行，与 require 不同)
-- loadfile 加载一个 lua 文件，然而并不运行它。f = loadfile('mod2') -- Calling f() runs mod2.lua.
-- loadstring 是 loadfile 的字符串版本。g = loadstring('print(343)') -- 返回一个函数。g() -- 打印 343; 在此之前什么也不打印。--]] 参考
为什么？我十分兴奋地学习 lua，这样我就能够应用 Löve 2D 游戏引擎来编游戏。
怎么做？我从 BlackBulletIV 的面向程序员的 Lua 指南入门。接着我浏览了官网的 Lua 编程一书。
lua-users.org 上的 Lua 扼要参考应该值得一看。
本文没有波及规范库的内容：
- string library
- table library
- math library
- io library
- os library
顺便说一下，整个文件是可运行的 Lua; 保留为 learn-cn.lua 用命令 lua learn-cn.lua 启动吧！
本文首次撰写于 tylerneylon.com 同时也有 github gist 版。
应用 Lua，欢畅常在！
有倡议？或者发现什么谬误？在 Github 上开一个 issue，或者发动 pull request！
原著 Tyler Neylon，并由 3 个好心人批改。
© 2022 Tyler Neylon, Rob Hoelz, Jakukyo Friel, Craig Roddin, Amr Tamimi
Translated by: Jakukyo Friel
本作品采纳 CC BY-SA 3.0 协定进行许可。