Lua 基本语法

1>. lua:

诞生于1993年，其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能，lua由标准
C编写而成，几乎在所以操作系统和平台上都可以编译运行，lua并没有提供强大的库，这是由它的定位决定的，
lua脚本可以很容易的被C/C++代码调用。也可以反过来调用C/C++函数，不仅仅作为扩展脚本，也可以作为普通
的配置文件，代替XML ini等文件。lua在所以脚本语言中是最快的，在游戏开发中，C/C++实现功能，lua实现逻辑。

2>. windows下开发环境搭建:

1. lua for windows 
2. 编译官方源码
3. 第三方IDE

3>. 标识符:

可以是由非数字打头的任意字母下划线和数字构成的字符串，标识符可用于对变量，表的域以及标签命名。

4>. 关键字:

对大小写敏感，作为一个约定程序中应避免创建以下划线加一个或多个大写字母构成的名字，eg:_VERSION

5>. 变量:

全局变量，局部变量， 表的域

6>. 值与类型:

lua是一门动态类型语言，这意味着变量没有类型，只有值才有类型，语言中不设类型定义，，每个值都"携带"了他
自身的类型信息。

一共有八种基本类型: nil boolean number string function thread table userdata(自定义类型)

变量没有预定义的类型，一个变量可以包含任何类型的值

        eg:

          a = "I'm a"

	print("a is ==>" ..a)    -> a is I'm a 
	a = 12
	print("a is ==>" ..a)    -> a is 12
		
	a = function(var)   -> 函数赋给a
		print("user input is" ..var)
	end
		
	a("I'm A")  -> user input is I'm A

table,

	myTable = {12, 13}
	b = 13 //默认全局
	local c = 12 //局部 不能被其他代码访问到

类型判断:

       type(o) == "number"
       type(o) == "string"

* 如果在一个function函数中创建的变量也是global(没有使用local 关键字)，那么意味着它也是全局的global变量。

7>. 函数:

1. 普通函数:

	local function myfunc()
		print("I'm myfunc")
	end

2. 多参函数:

	function myfunc(...)
	local mtable = {...}
		for k, v in pairs(mtable) do 
			print(k,v)
		end
	end	
	myfunc("12", 123, "ok")

3.多返回值

	local function myfunc()
		return 1,2
	end	


	----------------------
	local a,b = myfunc()
	print(a)   //1
	print(b)   //2

8>. 条件判断语句:

	//lua中条件判断的特殊符号 ( == > < >= <= ~=(不等于))
	local a = 12
	if a == 12 then 
		print("a's value is 12")
	end
	
	if a == 11 then 
		print("value is 12")
	elseif a ~= 11 then 
		print("value is not 12")
	end
	
	-------------------------------------------------
	
	if a == 2 then 
		print("value is 2")
	elseif a == 11 then 
		print("value is 11")
	else 
		print("value is " ..a)
	end

9>.逻辑运算符:

//lua中false nil 为假，其它都为真
--> 对于and
如果第一个操作数是假的话，那么就返回第一个操作数，反之返回第二个操作数

         print(1 and 5) // 5

--> 对于or
如果第一个操作数是真的话，那么就返回第一个操作数，反之返回第二个操作数

         print(1 or 5)  // 1

--> 对于not
永远返回的只是true 和false

10>. 循环语句:

while语句:

	m_table = {1, 2, 3} //创建数组
	local index = 1
	while m_table[index] do    // 遍历数组并输出
		print(m_table[index])
		index index + 1
	end

for语句:

	for i = 1, #m_table do    //#m_table取表长度
		print(m_table[i])
	end
	
	---------------------------
	for i = 1, 10, 2 do   //起始为1，2为递增步进
		print(i)
	end

repeat语句: 相当于do_while

	repeat 
		line = io.read()
	until line ~= ""
	print(line)
	
	----------------------------
	local sum = 1
	repeat
		print("sum value is" ..sum)
		sum = sum + 1
	until sum == 3	

11>. table(表)

//建立一个空的table

	mytable = {}

//建立一个有数据的table

	mytable2 = {2, 3, 4, 5}
	for i = 1, #mytable2 do 
		print(mytable2[i])
	end

//table 的遍历方法有三种，(多种遍历方法是因为有链表 key-value 数据存储方式)

	s = "ok"
	mytable = { k = 12 }
	mytable[s] = 10
	print(mytable["k"])  //12
	print(mytable[s])    //10
	print(mytable.k)     //12

--------------------------
mytable.k 等价于 mytable["k"] 
注意table中索引并不完全按照书写顺序来的

1. 第一种遍历方式

	for i = 1, #mytable do 
		print("value is ==>" ..mytable[i])
	end

2. 第二种遍历方式 for ipairs 按索引去迭代显示值

	for  i, v in ipairs(mytable) do
	      print(i,v)
	end

3.  第三种 for pairs  pairs迭代器是完全将索引的值显示出来的

	for k, v in pairs(mytable) do
		print(k, v)
	end

12>. 读写数据文件

读:

	local f = assert(io.open("nameList.txt", "r")) //io.open 相当于获取流的指针或句柄
	local string = f:read("*all")    //*表示读取所有内容
	f:close()                        //*line表示读取一行
	print(string)                    //*number读取一个字符   

写:

	local f = assert(io.open("ok.txt", "w"))
	f:write("welcom to lua")
	f:close()

封装的函数: 写入文本到指定文件中

	local function write_context(filename, context)
	        local f = assert(io.open(filename, ‘w’))
		f.write(context)
		f.close()
	end

闭包: 能够取其他函数内部变量的函数, lua通过函数闭包的方式实现面向对象

13>. require module 模块

require 导入(文件， 模块)类似java中包引入 C++中using namespace 

-->aa.lua文件

	function showname(v)
		print("zhang3"..v)
	end

-->main.lua文件中

	require("aa") //把aa.lua文件拷贝到当前文件中
	showname("ok") //"zhang3 ok"

---------------------------------

	local m = require("IO") //引入 IO库
	m.write("Ok string \n") //调用write函数输出

14>. Lua中面向对象编程 (类 继承 多态) 

	setmetatable(a, b) //b对象是 a对象的原形，b对象是a对象的父类， a继承b
	Account = {num = 10}
	function Account:new(o)
		o = o or {} //o 是否为空，不为空则返回 否则新建一个空table
		self.__index = self //设置索引
		return o
	end                 //self相当于this

15>. 数学库

1. 获取系统时间的函数 
2. 三角函数
3. 取整函数
4. max和min
5. 生成伪随机数

os.time()   math.sin(x)

	table库//增删改查 排序 连接
	table.insert() //插入
	table.sort() //排序
	table.remove()//删除
	table.concat()

string 库

	local testStr = "Hello lua, HelloWorld"	
	i, j = string.find(testStr， "Hello")
	print("first place is:" .. i)  // i
	print("second place is:" .. j) // j	
	k = string.find(testStr, "ok")
	print(k)   //nil

16>. 理解lua 与C/C++交互的中间件  -----栈(方便 C/C++ 与lua通信)

lua 由 C/C++编译， lua有一个隐形的数据结构栈

lua : 有内存回收(自动) 动态类型(每个变量类型不固定)
c : 手动释放 静态类型

上面两种原因 便有了栈

创建一个lua状态的指针

	lua_state* luastate = lual_newstate();//状态类
	lual_openlibs(luastate);//打开所有类库
	lual_dostring(L, s); //输入一个字符串，这个字符串可以是lua脚本
	lual_dofile(luastate, L, fn);// 读取外部文件
	lual_pcall(luastate, o,o,o);//正式执行 第一个O:代表参数 第二个o:代表返回值 第三个o:代表报错返回

17>. 从C/C++访问lua中的变量与函数

	string path = getfile("my.lua");
	lual_dofile(luastate, path.c_str());
	int err_rlt = lua_pcall(luastate, o, o, o);
	CCAssert(err_rlt, "读取lua文件错误");
	lua_getglobal(luastate, "username");//从lua中获取一个全局变量 username
	lua_toString(luastate, -1);//操作当前栈  ,-1 表示 当前栈的位置
	lua_pop(luastate, -1);//把当前栈顶弹出去
	
	C/C++访问lua中函数
	lua_getglobal(luastate, "getrlt");//从lua中获取函数 getrlt
	lua_pcall(luastate , 1 , 1, 0) //第一个1: 表示一个参数 第二个1: 表示一个返回值  第三个0: 表示报错返回

18>. 从lua中访问C/C++函数

1.在lua与C/C++语言通信过程中，实际上更多时候是对栈顶的元素进行操作。
2.从栈顶往下看索引应该是 -1 -2 -3.....
3.从栈低往上看，栈低是 1 2 3 ...
4.无论从lua调用C/C++还是C/C++调用lua, 参数值都是最先被压入栈顶的,最后结果值才被压入栈顶。

19>. 编写供lua调用的C函数

理解供lua调用函数的原型，lua并不能调用任意c函数
遵循一个模型

	static int fun(lua_state* )
	typedef int (*lua_cfunction)(lua_state*)

编写一个函数供lua使用

	static int L_getName(lua_state* L)
	{
		Lua_pushString(L, "name");
		return 1;	
	}
	
	lua_pushcfunction(luastate, L_getName);//注册函数
	lua_setglobal(luastate, "getMyName");

--------

在lua中调用getMyName即可

20>. “：”是lua面向对的语法糖

: 是lua面向对象的语法糖。 Account:new(conf) 等同于 Account.new(self, conf) ,相当于将调用者自身当做第一个参数，使用冒号调用就相当于隐式地传递 self 参数

参考:

• lua官网
• lua系列文章