Lua简易入门教程

时间  2019-11-19
标签 lua 简易 入门 教程 栏目 Lua 繁體版
原文   原文链接

环境：lua for windows (lfW)
主页：http://luaforwindows.luaforge.net/
https://code.google.com/p/luaforwindows/

lua for windows实际上是一整套Lua的开发环境，它包括：
Lua Interpreter（Lua解释器）
Lua Reference Manual（Lua参考手册） 
Quick Lua Tour （Lua快速入门）
Examples （Lua范例）
Libraries with documentation （一些Lua库和文档）
SciTE （一个很棒的多用途编辑器，已经对Lua作了特殊设置）html

 

Lua脚本语法说明（修订） 
Lua脚本语法说明（增长lua5.1部份特性）
Lua 的语法比较简单，学习起来也比较省力，但功能却并不弱。
因此，我只简单的概括一下Lua的一些语法规则，使用起来方便好查就能够了。估计看完了，就懂得怎么写Lua程序了。
在Lua中，一切都是变量，除了关键字。
I.  首先是注释
写一个程序，老是少不了注释的。
在Lua中，你可使用单行注释和多行注释。
单行注释中，连续两个减号"--"表示注释的开始，一直延续到行末为止。至关于C++语言中的"//"。
多行注释中，由"--[["表示注释开始，而且一直延续到"]]"为止。这种注释至关于C语言中的"/*...*/"。在注释当中，"[["和"]]"是能够嵌套的（在lua5.1中，中括号中间是能够加若干个"="号的，如 [==[ ... ]==]），见下面的字符串表示说明。

II.  Lua编程
经典的"Hello world"的程序老是被用来开始介绍一种语言。在Lua中，写一个这样的程序很简单：
print("Hello world")
在Lua中，语句之间能够用分号"；"隔开，也能够用空白隔开。通常来讲，若是多个语句写在同一行的话，建议老是用分号隔开。
Lua 有好几种程序控制语句，如：
控制语句        格式        示例
If        if 条件 then ... elseif 条件 then ... else ... end        if 1+1=2 then print("true")
elseif 1+2~=3 then print("true")
else print("false") end

While        while 条件 do ... end        while 1+1~=2 do print("true") end

Repeat        repeat ... until 条件        repeat print("Hello") until 1+1~=2

For        for 变量=初值, 终点值, 步进 do ... end        for i = 1, 10, 2 do print(i) end

For        for 变量1, 变量2, ... 变量n in 表或枚举函数 do ... end        for a,b in mylist do print(a, b) end


注意一下，for的循环变量老是只做用于for的局部变量；当省略步进值时，for循环会使用1做为步进值。
使用break能够用来停止一个循环。
相对C语言来讲，Lua有几个地方是明显不一样的，因此面要特别注意一下：

．语句块
语句块在C中是用"{"和"}"括起来的，在Lua中，它是用do 和 end 括起来的。好比：
do print("Hello") end
能够在 函数 中和 语句块 中定局部变量。

．赋值语句
赋值语句在Lua被强化了。它能够同时给多个变量赋值。
例如：
a,b,c,d=1,2,3,4
甚至是：
a,b=b,a  -- 多么方便的交换变量功能啊。
在默认状况下，变量老是认为是全局的。假如须要定义局部变量，则在第一次赋值的时候，须要用local说明。好比：
local a,b,c = 1,2,3  -- a,b,c都是局部变量

．数值运算
和C语言同样，支持 +, -, *, /。但Lua还多了一个"^"。这表示指数乘方运算。好比2^3 结果为8, 2^4结果为16。
链接两个字符串，能够用".."运处符。如：
"This a " .. "string." -- 等于 "this a string"

．比较运算
比较符号        <        >        <=        >=        ==        ~=
含义        小于        大于        小于或等于        大于或等于        相等        不相等

全部这些操做符老是返回true或false。
对于Table，Function和Userdata类型的数据，只有 == 和 ~=能够用。相等表示两个变量引用的是同一个数据。好比：
a={1,2}
b=a
print(a==b, a~=b)  --输出 true, false
a={1,2}
b={1,2}
print(a==b, a~=b)  --输出 false, true
．逻辑运算
and, or, not
其中，and 和 or 与C语言区别特别大。
在这里，请先记住，在Lua中，只有false和nil才计算为false，其它任何数据都计算为true，0也是true！
and 和 or的运算结果不是true和false，而是和它的两个操做数相关。
a and b：若是a为false，则返回a；不然返回b
a or b：若是 a 为true，则返回a；不然返回b

举几个例子：
print(4 and 5) --输出 5
print(nil and 13) --输出 nil
print(false and 13) --输出 false
print(4 or 5) --输出 4
print(false or 5) --输出 5


在Lua中这是颇有用的特性，也是比较使人混洧的特性。
咱们能够模拟C语言中的语句：x = a? b : c，在Lua中，能够写成：x = a and b or c。
最有用的语句是： x = x or v，它至关于：if not x then x = v end 。

．运算符优先级，从低到高顺序以下：
     or
     and
     <     >     <=    >=    ~=    ==
     .. (字符串链接)
     +     -
     *     /     %
     not   #(lua5.1 取长度运算)     - (一元运算)
     ^
和C语言同样，括号能够改变优先级。

III.  关键字
关键字是不能作为变量的。Lua的关键字很少，就如下几个：
     
and        break        do        else        elseif        
end        false        for        function        if        
in        local        nil        not        or        
repeat        return        then        true        until        while

IV.  变量类型
　　怎么肯定一个变量是什么类型的呢？你们能够用type()函数来检查。Lua支持的类型有如下几种：
Nil        空值，全部没有使用过的变量，都是nil。nil既是值，又是类型。
Boolean        布尔值，只有两个有效值：true和false
Number        数值，在Lua里，数值至关于C语言的double
String        字符串，若是你愿意的话，字符串是能够包含"\0"字符的（这和C语言老是以"\0"结尾是不同的）
Table        关系表类型，这个类型功能比较强大，请参考后面的内容。
Function        函数类型，不要怀疑，函数也是一种类型，也就是说，全部的函数，它自己就是一个变量。
Userdata        嗯，这个类型专门用来和Lua的宿主打交道的。宿主一般是用C和C++来编写的，在这种状况下，Userdata能够是宿主的任意数据类型，经常使用的有Struct和指针。
Thread        线程类型，在Lua中没有真正的线程。Lua中能够将一个函数分红几部份运行。若是感兴趣的话，能够去看看Lua的文档。
如今回过头来看看，倒以为不是线程类型。反而象是用来作遍历的，象是Iterator函数。
如：
function range(n)
  local i = 0
  while(i < n) do 
    coroutine.yield( i )
    i = i + 1
  end
end
惋惜的是要继续运行，须要coroutine.resume函数，有点鸡肋。请指教。

V.  变量的定义
　　全部的语言，都要用到变量。在Lua中，无论在什么地方使用变量，都不须要声明，而且全部的这些变量老是全局变量，除非咱们在前面加上"local"。这一点要特别注意，由于咱们可能想在函数里使用局部变量，却忘了用local来讲明。
至于变量名字，它是大小写相关的。也就是说，A和a是两个不一样的变量。
定义一个变量的方法就是赋值。"＝"操做就是用来赋值的
咱们一块儿来定义几种经常使用类型的变量吧。
A.  Nil
　　　　正如前面所说的，没有使用过的变量的值，都是Nil。有时候咱们也须要将一个变量清除，这时候，咱们能够直接给变量赋以nil值。如：
var1=nil  -- 请注意 nil 必定要小写

B.  Boolean
　　　　布尔值一般是用在进行条件判断的时候。布尔值有两种：true 和 false。在Lua中，只有false和nil才被计算为false，而全部任何其它类型的值，都是true。好比0，空串等等，都是true。不要被 C语言的习惯所误导，0在Lua中的的确确是true。你也能够直接给一个变量赋以Boolean类型的值，如：
theBoolean = true

C.  Number
　　　　在Lua中，是没有整数类型的，也不须要。通常状况下，只要数值不是很大（好比不超过100,000,000,000,000），是不会产生舍入偏差的。在WindowsXP能跑的当今主流PC上，实数的运算并不比整数慢。
实数的表示方法，同C语言相似，如：
4 0.4 4.57e-3 0.3e12 5e+20

D.  String
字符串，老是一种很是经常使用的高级类型。在Lua中，咱们能够很是方便的定义很长很长的字符串。
字符串在Lua中有几种方法来表示，最通用的方法，是用双引号或单引号来括起一个字符串的，如：
"That's go!"
或
'Hello world!'

和C语言相同的，它支持一些转义字符，列表以下：
\a  bell
\b  back space
\f  form feed
\n  newline
\r  carriage return
\t  horizontal tab
\v  vertical tab
\\  backslash
\"  double quote
\"  single quote
\[  left square bracket
\]  right square bracket

因为这种字符串只能写在一行中，所以，不可避免的要用到转义字符。加入了转义字符的串，看起来实在是不敢恭维，好比：
"one line\nnext line\n\"in quotes\", "in quotes""
一大堆的"\"符号让人看起来很倒胃口。若是你与我有同感，那么，咱们在Lua中，能够用另外一种表示方法：用"[["和"]]"将多行的字符串括起来。（lua5.1: 中括号中间能够加入若干个"="号，如 [==[ ... ]==]，详见下面示例）
示例：下面的语句所表示的是彻底相同的字符串：
a = 'alo\n123"'
a = "alo\n123\""
a = '\97lo\10\04923"'
a = [[alo
123"]]
a = [==[
alo
123"]==]

值得注意的是，在这种字符串中，若是含有单独使用的"[["或"]]"就仍然得用"\["或"\]"来避免歧义。固然，这种状况是极少会发生的。

　E.  Table
　　　　关系表类型，这是一个很强大的类型。咱们能够把这个类型看 做是一个数组。只是C语言的数组，只能用正整数来做索引；在Lua中，你能够用任意类型来做数组的索引，除了nil。一样，在C语言中，数组的内容只容许 一种类型；在Lua中，你也能够用任意类型的值来做数组的内容，除了nil。
Table的定义很简单，它的主要特征是用"{"和"}"来括起一系列数据元素的。好比：
T1 = {}  -- 定义一个空表
T1[1]=10  -- 而后咱们就能够象C语言同样来使用它了。 

T1["John"]={Age=27, Gender="Male"}
这一句至关于：
T1["John"]={}  -- 必须先定义成一个表，还记得未定义的变量是nil类型吗
T1["John"]["Age"]=27
T1["John"]["Gender"]="Male"
当表的索引是字符串的时候，咱们能够简写成：
T1.John={}
T1.John.Age=27
T1.John.Gender="Male"
或
T1.John{Age=27, Gender="Male"}
这是一个很强的特性。

在定义表的时候，咱们能够把全部的数据内容一块儿写在"{"和"}"之间，这样子是很是方便，并且很好看。好比，前面的T1的定义，咱们能够这么写：
T1=
{
10,  -- 至关于 [1] = 10
[100] = 40,
John=  -- 若是你原意，你还能够写成：["John"] =
{
Age=27,   -- 若是你原意，你还能够写成：["Age"] =27
Gender=Male   -- 若是你原意，你还能够写成：["Gender"] =Male
},
20  -- 至关于 [2] = 20
}


看起来很漂亮，不是吗？咱们在写的时候，须要注意三点：
第一，全部元素之间，老是用逗号"，"隔开；
第二，全部索引值都须要用"["和"]"括起来；若是是字符串，还能够去掉引号和中括号；
第三，若是不写索引，则索引就会被认为是数字，并按顺序自动从1日后编；

表类型的构造是如此的方便，以至于经常被人用来代替配置文件。是的，不用怀疑，它比ini文件要漂亮，而且强大的多。

　　F.  Function
函数，在Lua中，函数的定义也很简单。典型的定义以下：
function add(a,b)  -- add 是函数名字，a和b是参数名字
return a+b  -- return 用来返回函数的运行结果
end 

请注意，return语言必定要写在end以前。假如咱们非要在中间放上一句return，那么就应该要写成：do return end。
还记得前面说过，函数也是变量类型吗？上面的函数定义，其实至关于：
add = function (a,b) return a+b end
当从新给add赋值时，它就再也不表示这个函数了。咱们甚至能够赋给add任意数据，包括nil （这样，赋值为nil，将会把该变量清除）。Function是否是很象C语言的函数指针呢？

和C语言同样，Lua的函数能够接受可变参数个数，它一样是用"..."来定义的，好比：
function sum (a,b, )
若是想取得...所表明的参数，能够在函数中访问arg局部变量（表类型）获得 (lua5.1: 取消arg，并直接用"..."来表明可变参数了，本质仍是arg)。
如 sum(1,2,3,4)
则，在函数中，a = 1, b = 2, arg = {3, 4}  (lua5.1:  a = 1, b = 2, ... = {3, 4})
更难得的是，它能够同时返回多个结果，好比：
function s()
return 1,2,3,4
end
a,b,c,d = s()  -- 此时，a = 1, b = 2, c = 3, d = 4 

前面说过，表类型能够拥有任意类型的值，包括函数！所以，有一个很强大的特性是，拥有函数的表，哦，我想更恰当的应该说是对象吧。Lua可使用面向对象编程了。不信？举例以下：
t =
{
Age = 27
add = function(self, n) self.Age = self.Age+n end
}
print(t.Age)  -- 27
t.add(t, 10)
print(t.Age)  -- 37

不过，t.add(t,10) 这一句实在是有点土对吧？不要紧，在Lua中，咱们能够简写成：
t:add(10)    -- 至关于 t.add(t,10)

G.  Userdata 和 Thread
这两个类型的话题，超出了本文的内容，就不打算细说了。编程

 

VI.语法windows

A.闭包
示例一数组

复制代码 
function newCounter()
    local i = 0
    return function()     -- anonymous function
       i = i + 1
        return i
    end
end
 
c1 = newCounter()
print(c1())  --> 1
print(c1())  --> 2
复制代码

 

示例二：网络

复制代码 
function myPower(x)
    return function(y) return y^x end
end
 
power2 = myPower(2)
power3 = myPower(3)
 
print(power2(4)) --4的2次方
print(power3(5)) --5的3次方
复制代码

B.载入闭包

咱们能够直接使用require(“model_name”)来载入别的lua文件，文件的后缀是.lua。载入的时候就直接执行那个文件了。好比：
咱们有一个hello.lua的文件：编辑器

print("Hello, World!")

若是咱们：require(“hello”)，那么就直接输出Hello, World！了。
注意：
1）require函数，载入一样的lua文件时，只有第一次的时候会去执行，后面的相同的都不执行了。
2）若是你要让每一次文件都会执行的话，你可使用dofile(“hello”)函数
3）若是你要玩载入后不执行，等你须要的时候执行时，你可使用 loadfile()函数，以下所示：函数

local hello = loadfile("hello")
... ...
... ...
hello()

loadfile(“hello”)后，文件并不执行，咱们把文件赋给一个变量hello，当hello()时，才真的执行。（咱们多但愿JavaScript也有这样的功能
固然，更为标准的玩法以下所示。
假设咱们有一个文件叫mymod.lua，内容以下：
文件名：mymod.lua学习

复制代码 
local HaosModel = {}
 
local function getname()
    return "Hao Chen"
end
 
function HaosModel.Greeting()
    print("Hello, My name is "..getname())
end
 
return HaosModel
复制代码

因而咱们能够这样使用：网站

local hao_model = require("mymod")
hao_model.Greeting()

其实，require干的事就以下：（因此你知道为何咱们的模块文件要写成那样了）

local hao_model = (function ()
  --mymod.lua文件的内容--
end)()

 

 


VI.  结束语
　　就这么结束了吗？固然不是，接下来，咱们须要用Lua解释器，来帮助理解和实践了。相信这样会更快的对Lua上手了。
就象C语言同样，Lua提供了至关多的标准函数来加强语言的功能。使用这些标准函数，能够很方便的操做各类数据类型，并处理输入输出。有关这方面的信息，咱们能够参考《Programming in Lua 》一书，也能够在网络上直接观看电子版，网址为：http://www.lua.org/pil/index.html
　　
备注：本文的部分内容摘、译自lua随机文档。
相关连接：
1. Lua 官方网站： http://www.lua.org 
2. Lua Wiki网站，你能够在这里找到不少相关的资料，如文档、教程、扩展，以及C/C++的包装等： http://lua-users.org/wiki/

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程