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

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

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

**************************************************************
二、类型与值
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中，能够在字符串前放置操做符“#”来获取改字符串的长度

五、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)获取

六、function
在lua中，函数是做为"第一类值"来看待的。
这表示函数能够存储在变量中，能够经过参数传递给其余函数
还能够做为其余函数的返回值。

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

二、关系操做符
<、 >、 <=、 >=、 ==、 ~=

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

三、逻辑操做符
and or not

对于and，若是第一个操做数为假，就返回第一个操做数
不然返回第二个操做数。[即哪一个假返回哪一个除非都是真则返回第二个]

对于or，若是第一个操做数为真，就返回第一个操做数，不然返回
第二个操做数[即哪一个真返回哪一个除非都是假则返回第二个]

and的优先级高于or

4
字符串的链接 ..

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

六、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"}
*********************************************************
四、语句

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

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

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

五、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章 函数***********************
一、
全部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开始返回该数组的全部元素，重要用途用于"泛型调用"机制中。

二、变长参数

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个形参

三、具名实参

*******************第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 排序 ??

一、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

二、非全局的函数

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

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

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

尾调用消除能够防止栈溢出。

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

一、

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

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

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

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

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

三、无状态的迭代器
就是自身不保存任何状态的迭代器。
所以能够在多个循环中使用同一个无状态的迭代器，
避免建立新的closure开销。

典型例子就是 ipairs

八、具备复杂形态的迭代器
一般，迭代器须要保存许多状态，
可是泛型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之间交换数据时有两个问题：
一、动态类型与静态类型区别
二、自动内存管理与手动内存管理区别

-----------------------------------------------------------------
联合数据类型（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不支持共享内存的抢先式多线程。

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

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

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