关于Lua程序设计{读书笔记}

1、lua中的标识符可以是由任意字母、数字和下划线构成的字符串，但不能以数字开头。
2、lua将通常类似"_VALUE"的标识符作为保留标识符
3、lua的保留字
and break do else elseif
end false for function if
in loacl nil not or
repear return then true until
while
有大小写之分

4、行注释--
块注释--[[ …… ]]
==============================================================
全局变量
lua中访问一个未初始化的变量不会引发错误，结果是一个nil。
如果要删除某个全局变量的话置其为nil
==============================================================

**************************************************************
2、类型与值
lua是动态类型的语言
lua中有8中数据类型
nil、boolean、number、string、userdata、
function、thread、table
eg:print(type(5)) -->number

false和nil规定为假，其余为真
但有一点不同，在条件测试中，将数字零
还有有空字符串也都视为真。

lua中的字符串是不可变值
eg:
a="hello world"
b=string.gsub(a, "world", "lua");
lua字符串和其他lua对象（table或函数等）一样
都是自动内存管理机制所管理的对象。

可以用[[ …… ]]来界定一个字母字符串
eg:page=[[
i like lua
i like c++
i like java
]]
如果第一个字符是换行字符，那么lua会忽略它。

数字与字符串自动转换，lua会尝试将该字符串转换成数字
但是最好不要依赖
----------------

..是字符串连接操作符

如果需要显示地将一个字符串转换成数字，可用tonumber，当不能正确
表示时返回nil

若要转换成字符串，可以调用tostring或者与空字符串连接。

在lua5.1中，可以在字符串前放置操作符“#”来获取改字符串的长度

5、table
table类型实现了"关联数组"。
可以以一种简单、统一和高效的方式来表示普通数组、符号表、
集合、记录、队列、和其他数据结构。
lua也是通过table来表示模块、包和对象的。
eg:io.read
表示"io模块中的read函数"
对于lua，这表示"使用字符串read"作为key来索引table.io
把table理解为对象
eg:
a = {}
k = "x"
a[k] = 10;
a[20] = "great";

当程序再也没有一个table的引用时，lua的垃圾收集器最终会删除该table
并复用其内存

a["name"] -->a.name
a.x -->表示a["x"]，表示以字符串"x"来索引table
a[x] -->表示以变量x的值来索引table

//若要表示一个传统的数组或线性表
a={}
for i=1,10 do
a[i]=io.read()
end

lua通常以1作为索引的起始值。

打印a中所有元素
for i=1,#a do
print(a[i])
end

5.1中，长度操作法"#"用于返回一个数组或线性表的最后一个索引值
table.maxn() 返回一个table的最大正索引数，这是lua 5.1的新函数
5.0中可以用talbe.getn(a)获取

6、function
在lua中，函数是作为"第一类值"来看待的。
这表示函数可以存储在变量中，可以通过参数传递给其他函数
还可以作为其他函数的返回值。

7、uerdata(自定义类型)和thread(线程)
userdata用于表示一种由应用程序或C语言库所创建的新类型。
*************************************************************
3、表达式
1、算术操作符
+、-、*、/、^、%、-(负号)

2、关系操作符
<、 >、 <=、 >=、 ==、 ~=

对于table、userdata以及函数，lua是作引用比较的。

3、逻辑操作符
and or not

对于and，如果第一个操作数为假，就返回第一个操作数
否则返回第二个操作数。[即哪个假返回哪个除非都是真则返回第二个]

对于or，如果第一个操作数为真，就返回第一个操作数，否则返回
第二个操作数[即哪个真返回哪个除非都是假则返回第二个]

and的优先级高于or

4
字符串的连接 ..

5、优先级
^
not # -
* / %
+ -
..
< > <= >= -= ==
and
or

6、table构造器
其他方式
a = {"1","2","3"}
a = {x=10, y=20} --> a = {} a.x=10 a.y=20;

lua很少会用到链表，列表数据一般是通过数组实现。

op={["+"]="add", ["-"]="sub"}
i=20;
s="-"
op2={[i+0]=s,s[i+1]=s..s}
[]这种格式允许在方括号之间，
显shi地用一个表达式来初始化索引值

事实上 {x=0,y=0} --> {["x"]=0,["y"]=0}
{"r","g","b"} --> {[1]="r",[2]="g",[3]="b"}
*********************************************************
4、语句

1、
lua允许多重赋值，即对对多个值赋予多个变量
即 a,b = 10, 2*x
2、
j=10 --全局变量
loacl i=1 --局部变量

在交互模式中，每行输入内容自身就形成了一个程序块。
如果一条声明语句没有初始化赋值，那么它声明的所有bianliang都会被初始化为nil

3、
1、if then else \ elseif
2、while value do ... end
3、repeat .... until ... 为真的时候结束
4、在lua中，一个声明在循环体中的局部变量的作用域包括了条件测试
这是5.1的新功能。

5、for语句有两种形式 数字型for和泛型for
--数字型for
for var=exp1,exp2,exp3 do .... end exp3默认为1可以不指定
如果不想给循环设置上限，那么可以使用常量math.huge
--泛型for
通过一个迭代器函数来遍历所有值
for i, v in ipairs(a) do print(v) end
ipairs是一个用于遍历数组的迭代器函数
io.lines 用于迭代文件中每行
pairs 用于迭代table元素
string.gmatch 用于迭代字符串中单词

*******************第5章 函数***********************
1、
所有kua标准程序库中的函数都是用C语言编写的。
lua具有一项非常与众不同的特征，允许函数返回多个结果。
eg:
s,e=string.find("hello lua world", "lua")
--> 7,9 返回起始与结尾索引

function foo0() end 无返回值
function foo1() return "a" end
function foo2() return "a","b" end

当foo2出现在一个表达式中时，luia会将其返回值数量调整为1
eg:print(foo2() .. "lua") -- alua

类似return f() 这样的语句将返回f的所有返回值
print((foo2())) --将迫使它返回一个值

unpack函数，它接收一个数组作为参数，并从下表1开始返回该数组的所有元素，重要用途用于"泛型调用"机制中。

2、变长参数

function add(...)
local s=0
for i, v in ipairs{...} do --注意括号为{}
s=s+v
end
return s
end

function foo(a,b,c) <--> function foo(...)
第二种形式更简洁

function args(...)
local a,b,c=...
print(a,b,c);
end

lua提供了专门用于格式化文本string.format
以及输出文本io.write的函数

用函数select()访问可变形参

select("#",...) 返回形参总数
select("n",...) 返回第n个形参

3、具名实参

*******************第6章 深入函数****************************

第一类值 表示在lua中函数与其他传统类型的值具有相同的权利。
可以存储到变量中或table中，可以作为实参传递给其他函数
还可以作为其他函数的返回值。

词法域 指一个函数可以嵌套在另一个函数中，内部函数可以
访问外部函数中的变量。

a={p=print}
a.p("hello world");

一个函数定义实际上是一条赋值语句

function foo(x) return 2*x end -> foo function(x) return 2*x end

table.sort 排序 ??

1、closure是指一个函数及一系列这个函数会访问到"非局部变量"。
function sortByGrade(name,grades)
table.sort(name,function(n1,n2) return grades[n1] > grades[n2] end) end

比如grades

function newCounter()
local i = 0;
print("enter")
return function() i = i + 1 return i end end
非局部变量--i
回调函数

创建一个安全的运行环境-所谓的沙盒sandbox--closure

2、非全局的函数

Lib={}
Lib.foo=fucntion(x,y) return x+y end
Lib.goo=fucntion(x,y) return x-y end

Lib={
foo=fucntion(x,y) return x+y end,
goo=fucntion(x,y) return x-y end
}

Lib={}
fucntion Lib.foo(x,y) return x+y end
fucntion Lib.goo(x,y) return x-y end

--------
local f = fucntion(...) body end
local g = function(...) body .. f() .. end -- f是可见的
-------
local function f(...) body end

当lua展开局部函数定义的“语法糖”时，并不是使用基本函数定义语法。
而是对于局部函数定义
local function foo(...) body end
lua将其展开为
local foo
foo = function foo(...) body end

向前声明
local f,g
function g() ... end
function f() g() end

3、尾调用
当一个函数调用时另外一个函数的最后一个动作时，该调用才算是一条尾调用。
eg:fucntion f(x) return g(x) end
g(x)执行完能够返回到调用f的点上,即抛弃f

一条“尾调用”就好比是一条goto语句。
在lua中的应用就是编写状态机

尾调用消除可以防止栈溢出。

******************第7章 迭代器与泛型for**************************

1、

每一个迭代器都需要在每次成功调用之间保持一些状态，这样才能知道它所在的位置以及如何进到下一个位置。
closure对于这类任务提供了极佳的支持。

2、泛型for
泛型for在循环过程内部保存了迭代器函数
实际上它保存着3个值
一个迭代器函数、一个恒定状态和一个控制变量
for <var-list> in <exp-list> do
<body>
end

<exp-list>通常只有一个元素，即一个对迭代器工厂的调用

for所做的第一件事情就是对in后面的表达式求值。这些表达式应该
返回3个值供for保存：迭代器函数、恒定状态和控制变量的初值

类似多重赋值...之后 for会以恒定状态和控制变量来调用迭代器函数

3、无状态的迭代器
就是自身不保存任何状态的迭代器。
因此可以在多个循环中使用同一个无状态的迭代器，
避免创建新的closure开销。

典型例子就是 ipairs

8、具有复杂形态的迭代器
通常，迭代器需要保存许多状态，
但是泛型for只提供了一个恒定状态和一个控制变量用于状态的保存。
一个解决方法是closure。或者使用table保存多个字段

----------尽可能编写无状态迭代器
----------基于closure实现会比table更为高效。因为开销廉价
而且访问“非局部变量”比table字段更快。

******************第8章 编译执行与错误**************************

dofile用于运行lua代码块
loadfile不会运行代码，只是编译代码。然后将编译结果作为一个函数返回

如果需要多次运行一个文件，那么只需调用一次loadfile后
多次调用它的返回结果就好了。对于dofile来说，开销更小。

loadstring有点类似loadfile，不同之处在于它是从一个字符串中读取代码，而不是文件读取。

f=loadstring("i=i+1") --> f = function() i = i+1 end

但是第二种代码快得多，

只在编译对应程序块时被编译一次
而调用loadstring时都被重新编译

loadstring在编译时不涉及词法域，这是因为总是在全局环境中编译它的字符串
loadstring最典型的用处是执行外部代码，也就是那些位于程序之外的代码。
loadstring的期望输入是一个程序块，也就是一系列语句
如果需要对一个表达式求值，则必须在其之前添加return才能
构成语句。

string.rep("*",f())根据指定次数复制一个字符串

loadstring("a=1") --> function(...) a=1 end

----error-----
对于lua，通常嵌入在应用程序中，因此发生错误时
不能简单地崩溃或退出。
相反，应该结束当前程序块并返回应用程序。

print "enter a number"
n = io.read("*number")
if not n then error("invalid input") end

--> print "enter a number" n = assert(io.read("*number"), "invalid input")
--因为类似if not<condition> then error end 通用所以被build-in在assert中

lua提供的所有关于动态链接库的功能都聚集在一个函数中 package.loadlib(path, "function name")
将一个C函数作为一个Lua函数返回，如果错误返回nil

loadlib是一个非常底层的函数
通常使用requir来加载C程序库，它会搜索指定的库，然后用loadlib来加载库，并返回初始化函数

----------handle and catch-------------
大多应用程序会处理lua的异常。
如果需要lua自己处理异常，需要使用pcall函数来包装

function trackback()
local status, err = pcall(function() a = "a" + 1 return a end)
print(status, err)
end

function trackback()
local status, err = pcall(function() error("what the fuck") end)
print(status, err)
end

返回bool值以及包含错误行数的错误信息

******************第9章 协同程序 coroutine**************************

协同程序与线程差不多
一条执行序列，拥有自己独立的栈，局部变量和指令指针
同时又与其他协同程序共享全局变量和其他大部分东西

lua将所有有关协同程序的函数放置在一个名为 "coroutine"的 table中
create用于创建新的协同程序，参数为函数，返回值为thread类型

function testCreate()
co = coroutine.create(function() print "hi" end)
print(co)
end

4种不同状态
挂起suspended
运行running
死亡dead
正常normal

当create后，不会自动运行，处于suspended状态

resume是在保护模式中进行的，如果一个协同程序在执行中发生任何错误
lua是不会显示错误消息的，而是返回给resume调用。

可以通过一对resume-yield来交换数据
第一次调用resume时
并没有对应的yield在等待它
因此所有传递个resume的额外参数都将视为协同程序主函数的参数。

yield返回的额外值就是对应resume传入的参数。

function pass_data()
co = coroutine.create(
function(a,b,c)
print("co", a, b, c);
end
)
return co
end

function pass_to_yield()
co = coroutine.create(
function(a, b)
coroutine.yield(a+b, a-b)
end
)
return co
end

协同程序的经典实例 生产者与消费者

过滤器filter 过滤器是一种位于生产者和消费者之间的处理功能
可用于对数据的一些变换。它既是生产者又是消费者。

类似Unix的pipe
协同程序也是一种多线程。但协同程序是非抢占式的
--socket.lua--以后再仔细看。

******************第10章 完整实例 以后查看*************************

*******************************************************************
* *
* 第二部分 *
* *
*******************************************************************

********************** 第11章 数据结构 ****************************

在lua中，table是所有数据结构的基础

使用整数来索引table即可在lua中实现数组。a = {} #a用来获取数组长度
在lua中的约定是一般以1作为数组的起始索引。

在lua中，有两种方式用来表示矩阵

一种是 table的每一个元素是另一个table

function multi_array()
N = 3;
M = 3;
mt = {}
for i = 1, N do
mt[i] = {}
for j = 1, M do
mt[i][j] = 0
end
end

print(mt[2][2]);
end

比起C等创建多维数组
例如三角矩阵可以只占用原来的一半空间

第二种方式是将两个索引合并为一个索引 -- 稀疏矩阵

--链表
function link_array()
list = nil
while true do
x = io.read()
if x == "r" then
break
end
list = { next = list, value = x}
end

print("----------------")
while list do
print(list.value)
list = list.next
end
end

--队列与双向队列

在lua中实现队列的一种简单方法是使用table库的函数insert和remove
但是对于比较大的结构，移动开销很大，一种高效方法是使用两个索引，用于首尾元素

==作为以后参考例子

--集合与无序组 --有些不懂 以后再看

--字符串缓冲

io.read("*all") 可一次性读取文件
使用table作为缓冲区，使用table.concat将给定列表的所有字符串连接起来，并返回结果

table.concat与 io.read("*all")的算法类似 -- 以后再看吧

--图 以后再看吧...

********************** 第12章 数据文件以及持久性 ****************************

Entry({
"JAY",
"Fantasy",
"21",
"1991"
})

local path = "../data/persistent.txt"
local count = 0;
function Entry()count = count + 1 end
dofile(path)
print(count);

采用了事件驱动的做法，Entry函数作为一个回调函数

--串行化 [有环无环 ... ]
将数据转换为一个字节流或字符流
然后将其存储到一个文件或者通过网络连接发送出去

********************** 第13章 元表与元方法 ****************************

lua中每个值都有一套预定义的操作集合，如数字相加等。但无法将两个table相加，此时可通过元表修改一个值的行为，使其在面对一个非预定义的操作时执行一个指定操作。

访问机制
一般的元方法都只针对Lua的核心，也就是一个虚拟机。它会检测一个操作中的值是否有元表，这些元表是否定义了关于次操作的元方法。例如两个table相加，先检查两者之一是否有元表，之后检查是否有一个叫“__add”的字段，若找到，则调用对应的值。“__add”等即时字段，其对应的值（往往是一个函数或是table）就是“元方法”。

setmetatable（只能用于table）和getmetatable（用于任何对象）

setmetatable (table, metatable)，对指定table设置metatable
【如果元表(metatable)中存在__metatable键值，setmetatable会失败】

tmeta = getmetatable (tab)，返回对象的元表(metatable)
【如果元表(metatable)中存在__metatable键值，当返回__metatable的值】

********************** 第14章 环境 ****************************

lua的所有全局变量保存在一个常规的table
中，这个table称为环境..environment
将table自身保存在一个_G中

---具有动态名字的全局变量
what is meta-programming? --例子有些难懂 以后看

--全局变量声明
lua中的全局变量不需要声明就可以使用 --例子有点奇怪

--非全局的环境
lua允许每个函数拥有一个自己的环境来查找全局变量

可通过setfenv(1, {})改变一个函数的环境，一旦设置会失去之前所有全局变量
第一个参数是一个函数和一个新的环境table

另一种组装新环境的方法是使用继承。

每个函数以及某些closure都有一个继承的环境。

a= 5
function factory()
return function() return a end
end

f1 = factory();
f2 = factory();

print(f1());
print(f2());

setfenv(f1, {a = 10})
print(f1());
print(f2());

print---------------------------------------------------------
5
5
10
5
--------------------------------------------------------------

每一个新创建的函数都继承了创建它的函数环境

********************** 第15章 模块与包 ****************************

模块系统的一个主要目标是允许以不同的形式来共享代码

一个包就是一系列模块

require 用于使用模块
module 用于创建模块

如果require为指定模块找到了一个lua文件
则通过loadfile来加载该文件
如果找到的是一个C程序库，则通过loadlib来加载。

loadfile和loadlib都只是加载了代码，并没有运行它们

假设路径为
?;?.lua;c:\windows\?;/user/local/lua/?/?.lua
require会用模块名来替换每个?
根据替换结果检查是否存在这样的文件。
如果不存在就下一项。

LUA_PATH
LUA_CPATH

一般通过模块来使用他们
有时一个模块有不同版本

---编写模块的基本方法
最简单的：创建一个table
并将所有需要到处的函数放入其中
最后返回这个table

一个模块无返回值的话
require就会返回package.loaded[modname]的当前值

---使用环境
让模块的主程序块有一个独占的环境

--module函数
module()

--子模块与包

看的好晕-------------------------------

********************** 第16章 面向对象编程 ****************************

lua中的table就是一种对象。

table与对象一样可以拥有状态。
table也与对象一样拥有一个独立于其值的标识self
table与对象一样具有独立于创建者和创建地的生命周期

Account = {balance = 0}
function Account.withdraw(v)
print(Account.balance)
Account.balance = Account.balance - v
print(Account.balance)
end

a = Account
Account = nil
Account.withdraw(100.00); --error
------------------------------------------

Account = {balance = 0}

function Account.withdraw(self, v)
print(self.balance)
self.balance = self.balance - v
print(self.balance)
end

a1 = Account
Account = nil

a1.withdraw(a1, 100.00)

lua使用冒号，隐藏self参数。

Account = {balance = 0}

function Account:withdraw(v)
print(self.balance)
self.balance = self.balance - v
print(self.balance)
end

a1 = Account
Account = nil

a1:withdraw(100.00)

lua没有类的概念
对象是没有类型的。而是每个对象都有一个原型。

如果有对象a和b，要让b作为a的原型
a = {};
b = { value = 100};
setmetatable( a, {__index = b})

-----------继承

Account = {balance = 0}

function Account:new(o)
o = o or {}
self.__index = self
setmetatable(o, self)
return o
end

function Account:deposit(v)
self.balance = self.balance + v
end

function Account:withdraw(v)
if v > self.balance then error "insufficient funds" end
self.balance = self.balance - v
end

SpecialAccount = Account:new()

s = SpecialAccount:new({limit = 1000.00})

function SpecialAccount:getLimit()
return self.limit or 0;
end

function s:getLimit()
return 200
end

--重写
function SpecialAccount:withdraw(v)
if v > self.balance then error "超过余额~" end
if v > self:getLimit() then error "not get more than" end
self.balance = self.balance - v
end

s:deposit(1000.00)
s:withdraw(100.00)
print(s.balance)

--多重继承【以后再看】

--私密性

Smalltalk规定所有变量都是私有的，但所有的方法都是公有的。
第一个面向对象语言Simula则不提供任何形式的私密性保护。

Lua也没有私密性保护。
定位于 开发中小型的程序。

通过两个table来表示一个对象
一个table用来保存对象的状态
另外一个用于对象的操作

function newAccount(initialBalance)
--用于保存对象的内部状态
local self = {balance = initialBalance}

local withdraw = function(v) self.balance = self.balance - v end
local getBalance = function() return self.balance end
--返回了一个供外部使用的函数
return {
withdraw = withdraw,
getBalance = getBalance
}
end

acc1 = newAccount(100.00)
acc1.withdraw(40.00)
print(acc1.getBalance());

--单一方法做法 【以后看看】

********************** 第17章 弱引用table ****************************

Lua采用了自动内存管理
垃圾回收器只能回收它认为是垃圾的东西
不能回收用户认为是垃圾的东西

当一个对象处于数组中时，它就无法被回收。

weak table 用来告诉lua一个引用不应该阻碍一个对象的回收

不管是哪一种类型的弱引用table
只要有一个key或value被回收了
那么它们所在的整个条目都会从table中删除。

一项通用的编程技术是“用空间换时间”
例如记录下函数的计算结果，然后当调用同一个函数时
便可复用之前的运行结果

-- memoize method
local results = {}
function mem_loadstring(s)
local res = results[s]
if res == nil then
res = assert(loadstring(s))
results[s] = results
end
return res
end

虽然有些命令会重复出现，但还有许多命令只发生一次。
会消耗内存..因此得用弱引用table

local results = {}
setmetatable(results, {__mode = "v"})
function createRGB(r, g, b)
local key = r.."-"..g.."-"..b
local color = results[key]
collectgarbage()
if color == nil then
color = {red = r, green = g, blue = b}
results[key] = color
end

return color
end

对象属性 与 回顾table的默认值 以后看看--

**************************************************

第18章 到 第20章 先跳过

**************************************************

********************** 第23章 调试库 ****************************

调试库并没有提供一个Lua的调试器
而是提供了一个便写调试器所必须具有的原语。
其性能不高，而且用户也不希望使用。

debug=nil --删除库

调试库由两类函数构成
自省函数：允许检查一个正在运行中程序的各个方面
钩子：允许跟踪一个程序的执行

栈层。

t = debug.getinfo(foo) 得到一个table 里面包含了字段

当用一个数字<n>调用debug.getinfo(n)
就可以得到相应栈层上函数的数据

1--可以得到调用debug.getinfo的那个函数的数据
如果n大于栈中函数总数时，返回nil。

可以让getinfo获取指定信息

---访问局部变量[不知道怎么用]

debug.getlocal来检查任意活动函数的局部变量
参数：函数栈层，变量的索引。
返回：变量的名字，当前值。

Lua按局部变量在一个函数中的出现顺序为他们编号
但编号只限于在函数的当前作用域中活跃的变量。

debug.setlocal改变局部变量的值
参数：函数栈层，变量的索引，新值
返回：变量名

局部变量只有执行过它们的初始化代码后才可见。

---访问非局部变量[不知道怎么用]

getupvalue可以访问一个lua函数所使用的非局部变量。

[被一个函数所引用的“非局部的变量”会一直存在着，
即使这个引用它的函数已经执行完毕了--closure]

参数：函数closure，变量索引
返回

setupvalue

---------------------------------------
--访问其他协同程序 --- 看不懂 唉 以后看

----钩子
钩子机制
可注册一个钩子函数，这个函数会在程序运行中某个特定事件发生时被调用。

debug.sethook
钩子函数
字符串 描述了需要监控的事件
可选的数字 用于说明多久获得一次count事件

--性能剖析 profile

---------------------第4部分--------------------------------

------------------------第24章 C API概述-----------------------------

lua是一种嵌入式语言
即lua不是一个单独运行的程序而是一个可以连接到其他程序的库。
通过链接就可以将lua的功能合并入这些程序。

事实上，Lua解释器是一个简单的应用程序。
Lua的解释器程序（lua.c）就是“应用程序代码”的一个实例

lua解释器依靠lua库来实现主要功能。
这个程序会处理与用户的交互，会将用户的文件或字符串
输入lua库，由lua库来完成主要工作。

C API是一组能使C代码与lua交互的函数。
其中包括读写lua全局变量
调用lua函数
运行一段lua代码
以及注册C函数以供lua代码调用 等

lua与C语言通信的主要方法是一个虚拟栈。
几乎所有API的调用都会操作这个栈上的值。

“lua.h”定义了Lua提供的基础函数 -- 保持原子性和正交性，所有定义以lua_前缀
“lauxlib.h”定义了一个辅助库（使用lua.h中API编写的一个较高的抽象层）
--侧重于解决具体的任务。所有定义都是以luaL_开头
Lua的所有标准库编写都用到了辅助库。

lua库中没有定义任何全局变量
所有状态保存在动态结构lua_State中

所有C API都要求传入一个指向该结构的指针

luaL_newstate函数用于创建一个新环境（或状态）--不包含预定义函数。
“lualib.h”定义了打开这些库的函数--辅助库函数luaL_openlibs则可以打开所有的标准库

luaL_loadbuffer
用来编译用户输入的每行内容。
没有错误则返回0并压入栈

lua_pcall将程序块从栈中弹出
并在保护模式中运行，返回0表示没有错误

lua_tostring可获取消息

lua_pop可弹出删除

lua的核心是不会直接将任何内容写到任何输出流中
当发生错误时，它只会返回错误代码或错误消息来通知调用者。

lua与C之间交换数据时有两个问题：
1、动态类型与静态类型区别
2、自动内存管理与手动内存管理区别

-----------------------------------------------------------------
联合数据类型（Union）是一种特殊的数据类型。
它可以实现：以一种数据类型存储数据，以另一种数据类型来读取数据。
-----------------------------------------------------------------

Lua的设计目标不仅仅是为了便于C/C++访问，还可以被比如Java、Fortran、C#
等语言访问。
Lua使用了垃圾回收机制，如果将一个lua table保存在一个C变量上
lua引擎无法搜索出，有可能会被回收。

对于每种lua中的C类型，API都有一个对应的压入函数。

lua_checkstack 用于检查栈是否有足够的空间

Lua API使用索引（从1[栈底]开始或从-1[栈顶]开始）
lua_is* -- 不会检查值是否为数字类型，而是检查值能否转换为数字类型
lua_type -- 返回栈中元素的类型
lua_to* -- 用于从栈中获取一个值

当lua调用一个C函数返回时，lua就会清空它的栈。
这形成了一条规则，不要在C函数之外使用在C函数内获得的指向lua字符串的指针。

lua_gettop -- 返回栈中元素个数，也可以说栈顶元素的索引！ 【切记】

---------------------------------------------------------
lua_open是5.0时代的产物，5.1是luaL_newstate的宏，5.2里面已经没有了..

luaL_newstate用C运行库的内存分配函数。
lua_newstate可自定义内存分配函数。
--------------------------------------------------------------------

C没有提供异常处理机制
lua使用C语言中setjmp机制，类似于异常处理的机制。

在lua中有许多地方可能会发生内存分配错误。
用抛出错误 longjmup , 而不是返回错误..
longjmp

当编写库代码（被lua调用的C函数）
当编写应用程序代码（调用lua的C代码）

大多数应用程序包括lua解释器程序都采用让代码在保护模式下运行
它们调用lua_pcall来运行lua代码。

如果要保护那些与lua交互的C代码
可以使用lua_cpcall

当一个C函数检测到一个错误时
就应该调用lua_error
lua_error函数会清理lua中所有需要清理的东西
然后跳转会发起执行的那个lua_pcall
并附上一条错误消息

------------------------第25章 扩展应用程序-----------------------------

Lua的一项重要用途--作为一种配置语言（configuration language）

------------------------第26章 从Lua调用C-----------------------------
扩展Lua的一项基本含义就是，应用程序将新的C函数注册到Lua中。

Lua能调用部分C函数，并非任意。
有些扩展支持Lua调用任意C函数，但是不可移植且不安全。

C和Lua之间遵循着一个简单的协议才能够进行通信

每一个函数都有自己的局部私有栈。
栈不是一个全局性的结构。

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

所有注册到Lua中的函数都具有相同的原型

typedef int (*lua_CFunction) (lua_State *L);
在lua中是以函数指针的形式调用函数,
并且所有的函数指针都必须满足这种类型。

只有一个Lua状态的参数和一个表示压入栈中的返回值数量。
返回后lua会自动删除栈中结果之下的内容

C模块----------------------------------------------

Lua模块是一个程序块chunk，其中定义了一些Lua函数
这些函数通常存储为table的条目。

一个为Lua编写的C模块可以模仿这种行为。

除了C函数的定义外
还必须定义一个特殊函数（相当于lua模块的主程序块）
它应该注册模块中所有的C函数

Lua通过这个注册过程记录下C函数
使用这些函数地址直接调用它

通常C模块中有一个公共外部函数
用于创建C模块
而其他所有函数都是私有的声明为private

如何将C代码编译成动态链接库
lua便可以使用require 去加载。

LuaL_register(L,"","")

------------------------第27章 编写C函数的技术 [先跳过]-----------------------------
这一章介绍了如何通过C语言编写新函数来扩展Lua

数组操作

------------------------第28章 用户自定义类型 [先跳过]-----------------------------

如何用C编写新类型来扩展Lua

------------------------第29章 管理资源 [先跳过]-----------------------------

------------------------第30章 线程和状态 -----------------------------

Lua不支持共享内存的抢先式多线程。

1、ANSI C没有提供这样的功能。
2、不是一个好的选择

....
抢先式的线程和共享的内存 会有些无法预料的问题..比如..

Lua的协同程序是协作式的 collaborative
可避免不可预知的线程切换所带来的问题
另外
Lua的多个状态之间不共享内存。

--------------------------------
多个线程
----------------------------------------------------------------
在Lua中，一个线程本质上就是一个协同程序。
从C API的角度上看 将线程想象成一个栈可能更形象些。

当调用Lua C API的大多数函数时
这些函数都作用与某一个特定的栈。

只要创建了一个Lua状态
Lua就会自动在这个状态中创建了一个新线程。
称之为主线程。
主线程永远不会被回收
当使用lua_close关闭状态时
它会随状态一起释放。

lua_newthread可以在一个状态中创建其他的线程。

不要使用未被正确系缚
[指一个Lua对象既不在栈中，
又不为其他任何Lua对象所引用的情况]
的线程。有可能已经被垃圾回收。

切记必须确保改线程的引用被持有，才能正常使用。

当创建了一个新的线程后，就可以像主线程那样来使用它。

lua_xmove(F, T, n)可以在两个栈之间移动lua值。
它会从F中弹出n个元素并压入T中

使用多线程的主要目的是实现协同程序。......

lua_resume(Lua_State *L, int narg);

narg指定参数的个数

lua_resume可以启动以一个协同程序
类似lua_call
--压入函数--压入参数--压入参数数量

如果正在运行的函数交出[yield]了控制权
lua_resume就会返回一个特殊的代码LUA_YIELD
并将线程置于一个可以被再次恢复执行的状态

通常以一个Lua函数作为一个协同程序来启动
这个Lua函数可以调用其他Lua函数。

一个C函数只有在返回时才会交出控制权。
因此C函数实际上是不会停止自身执行的。
但如果调用者是一个lua函数
那么如果C函数调用lua_yield就可以挂起lua的调用者。

---------------------------------------
Lua状态
---------------------------------------------------

每次调用luaL_newstate都会创建一个新的lua状态。
不同的lua状态时各自完全独立的，他们之间不共享任何数据。
不能之间沟通需要辅助代码完成---

----------------------------------------该节有些复杂---以后看吧

------------------------第31章 内存管理 -----------------------------

Lua对其内存使用具有严格控制
当关闭一个Lua状态时
Lua会显示地释放它的所有内存。

luaL_newstate会一个默认的分配函数来创建lua状态malloc-realloc-free

若要控制lua的内存分配
则使用原始lua_newstate

---------

==========================================================================================

From example...

Lua中一般以_开头的变量作为特殊变量

而_却经常作为 dummy variable

a="single 'quoted' string and double \"quoted\" string inside"
b='single \'quoted\' string and double "quoted" string inside'

swap two variables
------------------------
print(a,b)
a,b=b,a
print(a,b)
------------------------

print(address.StreetNumber, address["AptNumber"])

-- Conditional assignment.
-- value = test and x or y

a=1
b=(a==1) and "one" or "not one"
print(b)

-- is equivalent to
a=1
if a==1 then
b = "one"
else
b = "not one"
end

=====================================================

for a=1,6,3 do
io.write(a.." ")
end

步长为3