Lua 笔记

2019独角兽企业重金招聘Python工程师标准>>>

##Lua 笔记

####下载

官网下载：
lua官网地址 下载源码。
解压安装：

tar zxvf lua-5.2.1.tar.gz

然后修改下Makefile文件, 修改其中的安装地址：

# 安装的地址，以下的bin ,include lib 等都基于这个
INATALL_TOP=/usr/local/lua

然后进行 make
但是会发现有提示错误，提示没加平台的参数，这时根据提示的平台名称加在 make之后就可以了

make linux
make install  

####执行脚本

这样就安装好了，开始第一个hello world 吧

cd /usr/local/lua/bin
./lua
print 'hello world'

看见输出结果了吧。其实有三种方法来执行lua脚本。

第一种就是 上面的例子，在终端里的lua bin目录里输入./lua，进入控制台来执行lua 语句。
进入控制台的标志是前面有个>

第二种 是执行单独的脚本文件,后缀名是.lua

touch my.lua
-- lua 的注释就是两个- 
print 'hello world'  

然后也是在bin目录里 执行这个文件

./lua my.lua  

也看到结果了吧

第三种方法 lua 是支持编译的，当你不想让别人看到你的程序的源码的话 ，你可以编译先，然后再执行。应该注意到bin目录下有两个可执行文件了吧 分别是 lua 和 luac

./luac my.lua  

这样就编译好了，会在当前目录创建一个luac.out 文件，这个就是编译文件了

./lua luac.out  

这样就可以了。
但是这个luac.out是默认的文件名，所以如果多个编译文件产生会覆盖之前的一个 ，-h 后发现有个参数-o 可以自定义编译文件的名称

语法结构是 /usr/local/lua/bin/luac [options] [filenames]
所以

./luac -o my.myout my.lua  

这样就OK了

####开发工具
这里补充一下我用的开发工具：sublime text 3 很不错，具体配置如下：
菜单》TOOLS>Build System> 如果没有lua 则选择New Build System..
然后就弹出一个配置文件，修改如下：

{  
"cmd": ["/usr/local/bin/lua", "$file"],  
"file_regex": "^(...*?):([0-9]*):?([0-9]*)",  
"selector": "source.lua"  
}

cmd 后面的数组第一个参数就是你的lua执行程序的路径，其他不变就OK
配置完，还是 菜单》TOOLS>Build System>lua 就好了

这样就可以来执行结果了 方法是 cmd+b

然后设置vim 模式：
Preferences=>Settings User=> 然后复制粘贴下面代码，保存，然后按esc 就可以进入vim 模式了。

{
"ignored_packages": []
}  

####LUA的注释方法

lua的注释很特别，是用两个-组成的--:

--this is a description

多行注释是 --[[...]] ,起于--,止于]], 是可以多层嵌套的，并且在5.1版本以上，可以在两个中括号加若干个=,但必须收尾数量一致，例如：

--[[
	this is a description
]]
and...
--[==[
	one 
	one
	[===[
		two
		two
	]===]
	[[three]]
]==]  

随意写拉。。

####LUA的简单语法

定义全局变量

variable = 100

局部变量

local variable = 'aaa'  

定义函数

function aaa()
....
end
-- 调用
aaa()

函数传参

function max(a,b)
	if a>b then
		return a
	else
		return b
	end
end

for 循环

for 起始值,终止值[,步长] do
....
end 
 
for i=1,100,2 do
	print(1)
end

表

config = {}  --定义一个空表
或者给表初始值，多个之间用逗号分割  
config = {name='user1',sex='man'}  

给表的属性赋值有两种方式：
config.age = 30
config["age"] = 30

遍历表

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

数组

定义方法和表类似

arr = {}  --定义一个空数组
arr = {1,2,3,4,5,6,7}
arr = {1,2,3,['key']='hello',4,5}

注意lua的数组是下标从1开始的，并且当计算其长度的时候,返回的长度只是 下标为连续默认下标的数量

local arr = {[6]='hello',[7]='hello',[8]='hello',[9]='hello',[10]='hello',[11]='hello',1,4}
print(#arr)    --返回的是2  

具体如何返回正确长度，还在研究，欢迎指点

#####LUA 面向对象方式编程

之所以说面向对象方式编程，是因为lua本身并不支持对象类型。在lua里一切都是变量。就和javascript里一切都是对象一样。
但是我们可以通过一些编程技巧把lua写成类似面向对象的方式，让“看起来”是面向对象的。
######实例化 有两种方式，第一种就是表复制的方法：

People = {}  --先定义一个空表，当作“类“

--然后定义一个类方法：

People.sayHi = function() 
	print('hello')

end
--也可以这么写：
--[[
function People.syaHi()
	print('hello')
end
]]

--新建一个方法用来复制表，可以看做“实例化“
function clone(tab)
	--定义一个空表用来复制表
	local ins = {}
	for k,v in pairs(tab) do
		ins[k] = v
	end
end

--调用的时候
local person = clone(People)
person.sayHi()

这样就简单的模拟了类的实例化和调用，但是如果初始化要传参怎么办呢？我们在来改进下：

People = {}
People.sayHi = function(ins)
	print('hello '..ins.name)  -- ..是字符串和变量的连接符
end

function clone(tab)
	local ins = {}
	for k,v in pairs(tab) do
		ins[k] = v
	end
end

People.new = function(name) {
	local self = clone(People)
	self.name = name
	return self
}

local person = People.new('xiaoming')  
person.sayHi(person)

但是这种写法也别扭有木有，lua有个方便的写法，上面person.sayHi(pserson)等价于：

person:sayHi()  

######继承

lua的继承的方式和实例化差不多

--首先我们写一个供继承的基类
People = {}  
--然后定义一个简单的成员方法和，供“实例化”的方法  
People.say = function(ins)
	print('hello'..ins.name)
end
People.new = function(name) --因为会有传参
	local ins = clone(People)
	ins.name = name
	return ins
end
function clone(tab)
	local ins = {}
	for k,v in pairs(tab) do
		ins[k] = v
	end
	return ins
end

--下面我们来声明一个新的子类Man来继承People
Man = {}
Man.new = function(name)
	local ins = {}
	--复制父类People
	ins = People.new(name)
	--我们再来定义一个方法，目的是把Man所有属性附加到People里
	copy(ins,Man)
	
	return ins
end

function copy(des, tab)
	for k,v in pairs(tab) do
		des[k] = v
	end
end

我们来调用下父类的say方法看看效果

local p = Man.new('myname')
p:say()   --hello myname

我们来重写下父类的say方法

Man.say = function(self)
	print('my name is:'..self.name)
end

再来调用下:

p:say() --my name is:myname

好啦 以上就是用复制表的方法来伪实现类的实例和继承

第二种方式：用函数闭包的方式来实现

--首先来写一个函数，来当作类
function People(name)
	local ins = {}
	--初始化操作
	local function init()
		ins.name = name
	end
	
	--定义成员方法
	ins.say = function()
		print('hello:'..ins.name)
	end
	
	init() --返回前调用下初始化
	return ins
end

我们来调用下:

local p = People('zhang san')
p:say()  --hello: zhang san

这种写法看到没，是不是就比较像正常类的结构了？没错，这个结构明了不像复制表那样杂乱，但是复制表的方式更快。不过，私有化的东西，比如例子中的init，复制表是做不到的

下面写下继承：

function Man(name)
	local ins = People(name)
	local function init()
		--木有初始化的东西
	end
	
	--成员方法
	ins.saygoodbye = function()
		print('goodbye:'.. ins.name)
	end
	
	--重写方法
	ins.say = function()
		print('hello again:'.. ins.name)
	end

	init()
	return ins
end

调用

local m = Man('xiaoming')
m:say() --hello again:xiaoming
m:saygoodbye() --goodbye:xiaoming

转载于:https://my.oschina.net/guanyue/blog/353296