Lua脚本入gate
2007-07-02 14:40　来源: 　网友评论 0 条 浏览次数 128
使用流程
1. 函数的使用
以下程序演示了如何在Lua中使用函数， 及局部变量
例e02.lua
-- functions
function pythagorean(a， b) 
local c2 = a^2 + b^2 
return sqrt(c2)
end
print(pythagorean(3，4))

运行结果
5

程序说明
在Lua中函数的定义格式为:
function 函数名(参数)
...
end
与Pascal语言不同， end不需要与begin配对， 只需要在函数结束后打个end就可以了.
本例函数的作用是已知直角三角形直角边， 求斜边长度. 参数a，b分别表示直角边长，
在函数内定义了local形变量用于存储斜边的平方. 与C语言相同， 定义在函数内的代
码不会被直接执行， 只有主程序调用时才会被执行.
local表示定义一个局部变量， 如果不加local刚表示c2为一个全局变量， local的作用域
是在最里层的end和其配对的关键字之间， 如if ... end， while ... end等。全局变量的
作用域是整个程序。

2. 循环语句
例e03.lua
-- Loops
for i=1，5 do 
print("i is now " .. i)
end

运行结果
i is now 1
i is now 2
i is now 3
i is now 4
i is now 5

程序说明
这里偶们用到了for语句
for 变量 = 参数1， 参数2， 参数3 do
循环体
end
变量将以参数3为步长， 由参数1变化到参数2
例如: 
for i=1，f(x) do print(i) end
for i=10，1，-1 do print(i) end

这里print("i is now " .. i)中，偶们用到了..，这是用来连接两个字符串的，
偶在(1)的试试看中提到的，不知道你们答对了没有。
虽然这里i是一个整型量，Lua在处理的时候会自动转成字符串型，不需偶们费心。

3. 条件分支语句
例e04.lua
-- Loops and conditionals
for i=1，5 do
print(“i is now “ .. i)
      if i ＜ 2 then     
      print(“small”) 
      elseif i ＜ 4 then     
      print(“medium”) 
      else     
      print(“big”) 
      end
end

运行结果
i is now 1
small
i is now 2
medium
i is now 3
medium
i is now 4
big
i is now 5
big

程序说明
if else用法比较简单， 类似于C语言， 不过此处需要注意的是整个if只需要一个end，
哪怕用了多个elseif， 也是一个end.
例如
    if op == "+" then
      r = a + b
    elseif op == "-" then
      r = a - b
    elseif op == "*" then
      r = a*b
    elseif op == "/" then
      r = a/b
    else
      error("invalid operation")
    end


4.试试看
Lua中除了for循环以外， 还支持多种循环， 请用while...do和repeat...until改写本文中的for程序 <script type=text/javascript> bbscode(＇postcontent1＇);

数组的使用

1.简介
Lua语言只有一种基本数据结构， 那就是table， 所有其他数据结构如数组啦，
类啦， 都可以由table实现.

2.table的下标
例e05.lua
-- Arrays
myData = {}
myData[0] = “foo”
myData[1] = 42

-- Hash tables
myData[“bar”] = “baz”

-- Iterate through the
-- structure
for key， value in myData do 
print(key .. “=“ .. value)
end

输出结果
0=foo
1=42
bar=baz

程序说明
首先定义了一个table myData={}， 然后用数字作为下标赋了两个值给它. 这种
定义方法类似于C中的数组， 但与数组不同的是， 每个数组元素不需要为相同类型，
就像本例中一个为整型， 一个为字符串.

程序第二部分， 以字符串做为下标， 又向table内增加了一个元素. 这种table非常
像STL里面的map. table下标可以为Lua所支持的任意基本类型， 除了nil值以外.

Lua对Table占用内存的处理是自动的， 如下面这段代码
    a = {}
    a["x"] = 10
    b = a      -- `b＇ refers to the same table as `a＇
    print(b["x"]) --＞ 10
    b["x"] = 20
    print(a["x"]) --＞ 20
    a = nil    -- now only `b＇ still refers to the table
    b = nil    -- now there are no references left to the table
b和a都指向相同的table， 只占用一块内存， 当执行到a = nil时， b仍然指向table，
而当执行到b=nil时， 因为没有指向table的变量了， 所以Lua会自动释放table所占内存

3.Table的嵌套
Table的使用还可以嵌套，如下例
例e06.lua
-- Table ‘constructor’
myPolygon = { 
color=“blue”， 
thickness=2， 
npoints=4; 
{x=0，    y=0}， 
{x=-10， y=0}， 
{x=-5， y=4}， 
{x=0，    y=4}
}

-- Print the color
print(myPolygon[“color”])

-- Print it again using dot
-- notation
print(myPolygon.color)

-- The points are accessible
-- in myPolygon[1] to myPolygon[4]

-- Print the second point’s x
-- coordinate
print(myPolygon[2].x)

LUA学习笔记2-Iterators and the Generic for
2007-07-02 14:04　来源: 　网友评论 0 条 浏览次数 77
Iterator是一种允许你遍历一个集合中元素的结构. 在Lua中, 我们可以用function实现iterator, 每次调用这个函数, 它都返回集合中的下一个元素. 一个iterator需要保留一些用来遍历的信息, 例如当前元素的位置以及什么时候结束. Closure的机制非常适合这个工作. 遍历所需的环境变量可以保存在upvalue中, 这样每一次调用这个closure, 他都返回遍历某一个list的iterator. 由于这样的Closure是用来产生iterator的, 我们称这样的closure为iterator factory.
每一次
以下是一个简单的iterator factory, 用来遍历一个table.
    function list_iter (t)
      local i = 0
      local n = table.getn(t)
      return function ()
        i = i + 1
        if i <= n then return t end
      end
    end
在这里, 每一次我们调用list_iter, 返回一个iterator, 这个iterator使用i, n来保存遍历时所需要的环境信息. 每一次我们调用这个iterator返回被遍历list的下一个值. 如果在我们遍历的list已经达到最后一个元素, 那么返回nil.
我们可以这样使用这个iterator:
    t = {10, 20, 30}
    iter = list_iter(t)    -- creates the iterator
    while true do
      local element = iter()  -- calls the iterator
      if element == nil then break end
      print(element)
    end
我们也可以使用generic for循环, 这样功能相同, 但是代码更少:
    t = {10, 20, 30}
    for element in list_iter(t) do
      print(element)
    end
相比一般循环, generic for多做了一些事情, 它内部调用iterator factory产生iterator, 然后将iterator保存起来依次调用, 当iterator返回nil的时候退出循环.
以下是另一个iterator factory的例子:
function allwords ()
      local line = io.read()  -- current line
      local pos = 1          -- current position in the line
      return function ()      -- iterator function
        while line do        -- repeat while there are lines
          local s, e = string.find(line, "%w+", pos)
          if s then          -- found a word?
            pos = e + 1      -- next position is after this word
            return string.sub(line, s, e)    -- return the word
          else
            line = io.read()  -- word not found; try next line
            pos = 1          -- restart from first position
          end
        end
        return nil            -- no more lines: end of traversal
      end
    end
虽然iterator factory有些复杂, 但是使用很简单直观:
    for word in allwords() do
      print(word)
    end
一般说来, iterator是使用简单但是实现困难. 幸运的是多数情况下开发人员都不需要自己实现iterator而使用库中间已经定义好的iterator即可.

The Semantics of the Generic for
在上面我们使用upvalue用来保存iterator时所需要的环境信息, 其实Generic for就有保存iterator时所需要的环境信息的功能, 这样可以使代码更简洁高效.
Generic for的一般形式如下:
    for <var-list> in <exp-list> do
      <body>
    end
<var-list>是一些变量的list, 以逗号分隔, <exp-list>是一些表达式的list, 以逗号分隔. 大多数情况<exp-list>只包含一个调用iterator factory的表达式:
    for k, v in pairs(t) do
      print(k, v)
    end
<var-list>中的变量多数情况下也只有一个:
    for line in io.lines() do
      io.write(line, '\n')
    end
在<var-list>中的第一个变量称为控制变量, 如果它的值为nil, 那么循环退出. 在执行时首先会计算<exp-list>中的表达式, <exp-list>应该返回3个元素, 第一个是iterator function, 第二个是一个常量用来记录一些环境信息, 最后一个是控制变量的初值.
    function iter (a, i)
      i = i + 1
      local v = a
      if v then
        return i, v
      end
    end
   
    function ipairs (a)
      return iter, a, 0
    end
    a = {"one", "two", "three"}
    for i, v in ipairs(a) do
      print(i, v)
    end
可以看出, 以下表达式
    for var_1, ..., var_n in explist do block end
与以下的循环是等价的.
    do
      local _f, _s, _var = explist
      while true do
        local var_1, ... , var_n = _f(_s, _var)
        _var = var_1
        if _var == nil then break end
        block
      end
    end
Stateless Iterators
Stateless Iterator就是不含状态和环境信息的iterator. 如同上面所说的,Stateless Iterator的遵从Generic For的约定, 主要靠Generic For来保存状态和环境信息.
a = {"one", "two", "three"}
    for i, v in ipairs(a) do
      print(i, v)
    end
    function iter (a, i)
      i = i + 1
      local v = a
      if v then
        return i, v
      end
    end
   
    function ipairs (a)
      return iter, a, 0
    end
当Generic For调用ipairs时, 他返回三个值, 分别为iterator function, invariant state和control value. 以后每次进入循环调用iter函数时使用两个参数, invariant state和control value.

Lua学习笔记之 Type and Values
2007-07-02 14:16　来源: 　网友评论 0 条 浏览次数 69
lua是一种动态类型语言, 不用特别声明变量以及指定类型, 首次赋值即为声明. 说到此点, 我觉得动态语言的这种特点与汇编倒是蛮象的: 不管你是什么类型, 对于底层而言, 它代表的就是一内存地址, 而操作符代表的就是对这些地址及存在于这些地址里的量进行操作而已.  闲话少说,  继续看pil, 今天的内容是: types and  values.

笔记内容:

1. lua提供了八种数据类型: nil, boolean, string, number, userdata, function, thread, table. 如果想看某个表达式是何种类型的, 可以使用type()函数, 它的返回值是string类型:
> print(type(10.4*3))
number
> print(type(type(10.4*3)))
string

2. 一个变量, 可以被多次赋以任何类型的值. 相比之下, lua中使用函数指针时的简单, 到了令人咋舌的程度: 再也不需要象c里那样弄个指针传来传去的了, 比如: a = print , 而后就可以用a(3)来打印表达式的值了. 让我觉得最爽的一点就是: 使用table+函数赋值的方式, 可以非常容易的实现函数表, 从而避免出现大量的if else语句. 形如下:
function func_1( para )
    para = para + 1
    return para
end

function func_2( para )
    para = para+2
    return para
end

func_table = {
    ["func1"] = func_1,
    ["func2"] = func_2,
}

print ( func_table["func1"](1) )

打印的结果是:
2

选择string作为 key, 是为了让你了解在lua里, 作函数表是如何的方便.

3. 全局变量在第一次赋值前, 默认是nil; 删除全局变量, 也是将此变量赋值为nil.  nil值, 也常作为函数的无效返回值来使用.

4. boolean类型有两个值: false 和 true( 全为小写 ). 在条件表达式中,  只有false和nil才表示假, 其余任何值均表示真(0也表示真).  比如这些值:
if false then print( "ok" ) end
if nil then print("ok") end
if "" then print("ok") end
if '' then print( "ok" ) end
if "haha" then print( "ok") end
if 0 then print("ok") end
在上面的这些语句中, 只有前两条语句打印不出ok, 其它皆可以.

5. 对于number类型, lua只提供real实型数. 没有整数类型, 按pil的说法: as it does not need it.... Moreover, most modern CPUs do floating-point arithmetic as fast as (or even faster than) integer arithmetic. 我想, lua自身的这些"狡辩"已经有足够的说服力, 不用再罗索了. 什么叫自由? 看这里:
>print( string.sub( "hello", 1.1, 2.2 ) )
he
其效果等同于: print( string.sub( "hello", 1, 2 ) )

6. 都说lua的string类型功能很强大, 可就目前我的使用而言, 并没有感受到这种强大给我带来的更多的便利性, 我想, 可能还是码lua码得少了. lua里的string类型, 可以存放任意长的字符串, 一个字符串, 一旦创建便不可更改. 有人说, 这样操作起来岂不是效率很低? 其实, 也不尽然, 你想嘛, 那些对串进行操作的函数: sub, find, copy, replace, cat等等. 其中, 很多确实本身并没有要求一定要修改串本身, 很多函数都是不修改串的, 而同时, 修改串的那些操作, 还不如直接创建一个新串来得方便. lua对字符串的内存管理, 还是比较棒的, 编程者不用去管它的分配与回收, lua会根据自己的一套引用计数机制来自行决定何时释放掉这个串, 同时, 正是由于不可修改串本身, 也使得lua的字符串操作变成了单纯的引用操作, 这样效率应该是更高了.

字符串常量, 可以使用单引号, 也可以使用双引号括起来.  但是, 要培养一种良好的编程习惯: 固定使用一种风格的声明形式. 转义字符, 一样在前面加 "\" . 以\ 后引出的数字, 可以表示一个asc字符, 但\的数字最多不会超过3位.

定义含有多行的字符串时, 可以使用 [[ ]] 标识, 这样就不用在每行之间加\n作转义了.

lua 提供字符串与number类型之间的自动转换功能. 所谓的自动转换, 就是视调用时的函数行为, 决定当前的操作是按字符串处理, 还是按数值型处理,  比如:  "10"+1,  这种情况会按数字处理, 因为字符 串没有加法操作, 如果想连接两个字符串, 要用 .. 运算符. 而 "10"..1, 其结果为: 101 .  当然,  "a"+1这样的操作, 是非法的,  因为lua的转换, 并不是按asi来作, 而是等于执行了一个 atoi( "10"), 然后再加1.
在其它场合, 如果要将字符串转为数字, 使用tonumber, 转换失败时, 返回nil. 比如: tonumber("a")返回值就为nil. 如果要将数字转换成字符串, 有两种方法: 一种是使用tostring函数, 一种是使用连接符将数字和一个空串连接起来: 10.."", 其结果为:"10"

Lua 语言和C集成调研小结
2007-06-22 10:23　来源: 　网友评论 0 条 浏览次数 102
1. Lua的特点
Lua 是一个小巧的脚本语言。作者是巴西人。该语言的设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。它的主页是 http://www.lua.org/。

Lua最著名的应用是在暴雪公司的网络游戏WOW中。

Lua脚本可以很容易的被C/C++代码调用，也可以反过来调用C/C++的函数，这使得Lua在应用程序中可以被广泛应用。不仅仅作为扩展脚本，也可以作为普通的配置文件，代替XML,Ini等文件格式，并且更容易理解和维护。

Lua由标准C编写而成，代码简洁优美，几乎在所有操作系统和平台上都可以编译，运行。一个完整的Lua解释器不过200k，在目前所有脚本引擎中，Lua的速度是最快的。这一切都决定了Lua是作为嵌入式脚本的最佳选择。

Lua 有一个同时进行的JIT项目，提供在特定平台上的即时编译功能，这将给Lua带来更加优秀的性能。请访问 http://luajit.luaforge.net/ 来了解这个项目。

和Python等脚本不同，Lua并没有提供强大的库，这是由它的定位决定的。所以Lua不适合作为开发[屏蔽]应用程序的语言。不过Lua还是具备了比如数[屏蔽]算和字符串处理等基本的功能。

Lua 目前的最新版本是 5.1.



Lua只有一种数据类型，table. 实际上就是hash表。它用这个来模拟数组，链表等等。 在语法上，Lua支持如下形式：

data = {} --定义一个table
  data.i = 1
  data.name = "jason"
  data.package = {1,2,2,3,56,7}
  data.others = {}
  data.others.a = 1
  data.others.b = 1.1这使得Lua具有了跟C的struct类似的形式，非常便于设计C函数的参数，用一个table就可以传入很复杂的参数。

2. 数据交换介绍
Lua和C程序通过一个堆栈交换数据: struct lua_State

堆栈的序号可以从栈顶和栈底计数，从栈底计数，则栈底是1,向栈顶方向递增。从栈顶计数，则栈顶是-1,向栈底方向递减。一般都用从栈顶计数的方式。堆栈的默认大小是20，可以用lua_checkstack修改.用lua_gettop则可以获得栈里的元素数目。并不是说在栈顶有一个整形元素。而是计算了一下栈顶元素在栈里的正index,相当于元素数目。

Lua 调用C函数用的堆栈是临时的，调用结束之后就被销毁了。

如何从堆栈中获取从Lua脚本中的参数

如果知道Lua脚本中某个全局变量的名字，可以用void lua_getglobal (lua_State *L, const char *name) 。这个函数会将name所指Lua变量的值放在栈顶.

如果是在C 函数中要获取Lua调用函数使用的参数：

首先用lua_gettop检查参数数量

用lua_is...类函数检测参数的类型，做好错误处理

用lua_to...类函数将参数转换为number或者string.(对Lua来说，只有这两种简单类型)

lua_tonumber返回的是double

lua_tostring返回的是char*

用lua_remove从栈中删除掉元素

继续获取下一个元素. 因为每次都调用lua_remove,所以每次调用lua_tonumber,使用的index都将固定是-1，即栈顶。

如果lua_istable成立，那么说明栈顶是一个table.注意table是不能取出来的，只能把table里的元素一个个取出来。

首先把元素的名字压入栈顶： lua_pushstring(L,"i"); 然后就可以用lua_gettable调用，值会放在栈顶。同时刚才压入的元素名字被弹出。 用上面的办法，可以把这个值取出来。记得也应该lua_remove。 如果table的某一个元素也是table，重复即可。 当table的所有元素都取完了，记住这个table本身还在堆栈里，要用lua_remove把它删除。

如果要获取的是一个数组(所谓数组，其实就是key是从1开始的数字序列的table,并且值类型相同),用lua_next可以遍历这个数组：

首先lua_pushnil，压入一个空值，然后

while (lua_next(L, -2) != 0)
{
    if(lua_isnumber(L,-1)) //判断元素类型，也可能是string
    {
        arrf.add((float)lua_tonumber(L, -1));//获取元素的值
        lua_remove(L,-1);
    }
}
lua_remove(L,-1);//删除NIL如何从C返回数据给Lua脚本

用lua_push...类函数压入数据到堆栈中，并用return n;来告诉Lua返回了几个返回值。 Lua是天生支持多个返回值的，如 x,y = Test()。 Lua会根据n从栈里取相应的数据。

如果要返回一个table:

lua_newtable(L);//创建一个表格，放在栈顶
    lua_pushstring(L, "mydata");//压入key
    lua_pushnumber(L,66);//压入value
    lua_settable(L,-3);//弹出key,value，并设置到table里面去

    lua_pushstring(L, "subdata");//压入key
    lua_newtable(L);//压入value,也是一个table
    lua_pushstring(L, "mydata");//压入subtable的key
    lua_pushnumber(L,53);//value
    lua_settable(L,-3);//弹出key,value,并设置到subtable
    lua_settable(L,-3);//这时候父table的位置还是-3,弹出key,value(subtable),并设置到table里去
   
    lua_pushstring(L, "mydata2");//同上
    lua_pushnumber(L,77);
    lua_settable(L,-3);

    return 1;//堆栈里现在就一个table.其他都被弹掉了。如果要返回一个数组，用如下代码：(注意那个关于trick的注释，我在等官方的解释。经过验证，这个问题只在windows版本调用dll中方法的时候出现。WinCE正常)

lua_pushstring(L,"arri");
    lua_newtable(L);
    {
        //a trick:otherwise the lua engine will crash. This element is invisible in Lua script
        lua_pushnumber(L,-1);
        lua_rawseti(L,-2,0);
        for(int i = 0; i < arri.size();i++)
        {
            lua_pushnumber(L,arri);
            lua_rawseti(L,-2,i+1);
        }
    }
    lua_settable(L,-3);这样产生的数组可以在Lua中如下遍历：

for i,v in ipairs(data.arri) do
        print(v)
    end或者是

for i=1,table.getn(data.arri) do
        print(data.arri)
    end只有数组才能这样，name,value构成的Record不行，table.getn也只对数组有效。

由于上述代码的高度相似性，所以很容易实现自动生成这些代码。比如，根据C的一个struct定义：

typedef enum
{
    BR_9600,
    BR_4800,
} BaudRate;

typedef struct flag
{
    int onoff;
    int j;
    long l;
    double d;
    char* name;
    BaudRate rate;
}flag;可以自动产生如下代码：

bool DataToLua(flag data,lua_State *L)
{
    lua_newtable(L);
    lua_pushstring(L,"onoff");
    lua_pushnumber(L,(double)data.onoff);
    lua_settable(L,-3);
    lua_pushstring(L,"j");
    lua_pushnumber(L,(double)data.j);
    lua_settable(L,-3);
    lua_pushstring(L,"l");
    lua_pushnumber(L,(double)data.l);
    lua_settable(L,-3);
    lua_pushstring(L,"d");
    lua_pushnumber(L,(double)data.d);
    lua_settable(L,-3);
    lua_pushstring(L,"name");
    lua_pushstring(L,data.name.c_str());
    lua_settable(L,-3);
    lua_pushstring(L,"rate");
    lua_pushnumber(L,(double)(int)data.rate);
    lua_settable(L,-3);
    return true;
}LuaToData也是类似的。

如果使用面向对象的方式封装起flag来，把DataToLua变成flag类的一个方法，就更加方便了。

3. C和Lua脚本互相调用举例
首先是C的主程序初始化Lua脚本引擎，并注册一些函数供脚本中调用：

//function for Lua to call
//return a integer array to the script
static int l_getarr (lua_State *L)
{
    lua_newtable(L);//create table
    lua_pushnumber(L,1);//push the value
    lua_rawseti(L,-2,1);//set t[1]=v
    lua_pushnumber(L,2);   
    lua_rawseti(L,-2,2);
    lua_pushnumber(L,3);   
    lua_rawseti(L,-2,3);
    lua_pushnumber(L,4);   
    lua_rawseti(L,-2,4); 
    return 1;
}

int main()
{
    lua_State *L = lua_open();  /* opens Lua */
    luaopen_base(L);            /* opens the basic library */
    luaopen_table(L);            /* opens the table library */
   
    luaopen_string(L);          /* opens the string lib. */
    luaopen_math(L);            /* opens the math lib. */
   
    lua_pushcfunction(L, l_getarr); // Register a function
    lua_setglobal(L, "getarr");

    if (lua_dofile(L, "testlua.lua"))//Load the script file and Run it
    {
        printf("run script failed\n");
    }
    else
    {
        lua_getglobal(L, "result"); //Get the global variant in Lua script
        if(lua_isnumber(L,-1))
        {
            printf("The result of the Lua script is %d\n",lua_tonumber(L,-1));
        }
    }
     
    lua_close(L);
   
    return 0;

}脚本的代码如下：

array = getarr()
if array ~= nil then
    result = 1
    for i=1,table.getn(array),1 do
        print(array)
    end
else
    result = 0
end

LUA学习笔记3 - Compilation, Execution, and Errors
2007-07-02 14:07　来源: 　网友评论 0 条 浏览次数 75
Compilation, Execution, and Errors
前面我们介绍过dofile函数, 其实dofile的实现如下:
    function dofile (filename)
      local f = assert(loadfile(filename))
      return f()
    end
loadfile函数很灵活, 我们可以多次调用loadfile的返回结果来反复执行一段代码. 但是如果出错loadfile将返回nil和一个错误提示信息.
loadstring功能和loadfile类似, 参数为要直接处理的script内容.
    f = loadstring("i = i + 1")
    i = 0
    f(); print(i)  --> 1
    f(); print(i)  --> 2

loadstring载入后相当于多了一个匿名函数定义,
-- file `foo.lua'
    function foo (x)
      print(x)
    end

    f = loadfile("foo.lua")
    f()          -- defines `foo'
    foo("ok")    --> ok

你也可以使用loadstring(s)()达到同样的效果.
使用loadstring时所用的变量都位于全局空间:
    local i = 0
    f = loadstring("i = i + 1")      -- global i
    g = function () i = i + 1 end    --local i

The require Function
Lua提供了一个函数require用来载入库. require作的工作有些像dofile但有两点重要不同:require会在path指定的路径搜索文件, 而且require可以知道一个文件是否已被执行, 如果已被执行过, 那么不会再次被执行.

Lua使用的path和许多平台使用的标准path有些不同, 许多平台使用的path是一系列含有目标文件的文件夹,但是Lua不一样. Lua使用的ANSI C语言并没有path这样的概念, 因此Lua使用的是字符串匹配的方式. '?'代表文件名, 以';'隔开.
?;?.lua;c:\windows\?;/usr/local/lua/?/?.lua
如果调用 require 'lili', 那么会尝试打开下列文件:
lili
lili.lua
c:\windows\lili
/usr/local/lua/lili/lili.lua
require会首先检查全局变量LUA_PATH, 如果LUA_PATH是一个字符串类型, 那么使用它的值. 否则检查环境变量LUA_PATH, 如果以上值都不存在, 那么使用一个定值, 这个值可以在编译LUA的时候方便的加以改变.

另一个require的主要功能是避免一个文件被执行多次. 为了实现这个目的, 它保存了一个table用来记录所有已经载入的文件. 注意, 这里的key值并不是真实的文件名而是一个虚拟文件名. 所以
require "foo"
require "foo.lua"
path是"?;?.lua", 那么foo.lua会被载入两次. 可以通过全局变量 _LOADED 访问到这个表的值.
path中可以含有固定文件的值, 例如:
?;?.lua;/usr/local/default.lua
在这种情况下, 如果 reqire 不能找到其他的匹配, 那么就使用/usr/local/default.lua.

有点乱，呵呵

不如发个文档上来吧。。。。。。

其实我想说的是python比这个简单...不过Lua还是有不少优势
python转60~70行简单的.py生成2M多的exe文件,还有很多的dll之类的东西..

文档我也没找到多少，主要是看它的源代码
其实lua我觉得并不强，不过在它的程序很小，可以移到嵌入式系统上
还有可以自已扩展也不错

LZ的帖子不错哦

谁知道The Elder Scroll4: Oblivion里内嵌的脚本是什么语言呢？

还有Quake3引擎有没有内嵌脚本语言？

Quote:

引用第7楼lxlcn于2007-07-31 21:46发表的  :
其实我想说的是python比这个简单...不过Lua还是有不少优势
python转60~70行简单的.py生成2M多的exe文件,还有很多的dll之类的东西..

python这个不是编译，而是打包。把python.exe等运行库打包成一个exe。

能编译成Native Code的貌似只有C/C++和Dephi。其他的都要运行库。

Quote:

引用第9楼est于2007-07-31 23:05发表的  :
LZ的帖子不错哦

谁知道The Elder Scroll4: Oblivion里内嵌的脚本是什么语言呢？

还有Quake3引擎有没有内嵌脚本语言？

Quake3引擎里是有脚本语言的，不过具体哪一个不太清楚了
如果不是编游戏的工作量也太大了