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