精华内容
下载资源
问答
  • lua基础
    千次阅读
    2022-06-08 16:02:31

    lua 基础

            

                  

                                           

    标识符

            

    命名规则

    字母、数字、下划线组成
    标识符区分大小写,Test和test表示不同的变量
    尽量不要使用下划线加大写字母命名,lua内部变量一般这样命名(如_VERSION)
    

                

    lua 关键词为保留词,不能用来表示变量

                  

             

    局部变量、全局变量:如果没有显示声明为局部变量,默认为全局变量

    # a为局部变量、b为全局变量
    local a=0;
    b=1
    
    # 函数中的变量
    function fun()
        a = 5           -- 全局变量
        local b = 6     -- 局部变量
    end

             

                

                                           

    注释

       

    单行注释:--

    多行注释:--[[多行语句块]]

               

    示例

    # test.lua脚本
    huli@hudeMacBook-Pro ~ % cat test.lua
    print("hello 瓜田李下")
    --print("hello 海贼王")
    
    # 执行脚本
    huli@hudeMacBook-Pro ~ % lua test.lua
    hello 瓜田李下
    

            

    示例 2

    # test2.lua
    huli@hudeMacBook-Pro ~ % cat test2.lua
    print("hello 瓜田李下")
    
    --[[
    print("hello 海贼王")
    print(1+2)
    ]]
    
    
    # 执行脚本
    huli@hudeMacBook-Pro ~ % lua test2.lua
    hello 瓜田李下
    

             

                 

                                           

    数据类型

            

    lua共有8种基本数据类型

    nil:无效值,一个变量如果没有赋值,默认为nil;nil在条件语句中表示false
    boolean:true、false
    number:数字类型(双精度数据类型)
    string:字符串,单引号、双引号、两个中括号括起来的字符串
    table:key、value键值对,key可为字符串、数字(默认从1开始)、表(多维数组)
    function:函数
    userdata:用户自定义数据,c数据结构
    thread:用于执行协同程序

               

     查看数据类型:type(param)

    Lua 5.4.4  Copyright (C) 1994-2022 Lua.org, PUC-Rio
    
    # nil类型
    > type(nil)
    nil
    
    # number类型
    > type(2)
    number
    
    # string类型
    > type("gtlx")
    string
    
    > type("2")
    string
    
    # function类型
    > function fun() return 1 end
    > type(fun)
    function
    
    # table类型
    > t={}
    > type(t)
    table
    

                 

                  

    更多相关内容
  • Lua基础

    2022-05-13 13:15:34
    Lua声明的变量默认是全局变量,声明局部变量加local前缀,比如local a表示a是一个局部变量 没有被声明过变量都是nil,类似于其他语言的null 支持多重赋值:a,b=1,2 Lua中有number类型:双精度类型,c中int,float...

    Lua声明的变量默认是全局变量,声明局部变量加local前缀,比如local a表示a是一个局部变量

    没有被声明过变量都是nil,类似于其他语言的null

    支持多重赋值:a,b=1,2

    Lua中有number类型:双精度类型,c中int,float,double等都属于lua的number类型

    Lua还支持16机制表示方法,还支持科学计数法,支持左移右移操作

    字符串

    Lua字符串类型(string):用单引号或双引号表示字符串,支持转义字符

    字符串的连接操作不是加号而是两个点,比如字符串a,字符串b,将a和b连接就是a..b

    Number转换成字符型:c=tostring(10)

    字符型转换成number:n=tonumber(“10”),如果转换失败n就是nil

    获得字符串长度:在字符串前面加个#,比如#c可以获得c字符串的长度

    Lua函数

    也可以这样写

    Table:

    Table数字下标

    用下标提取里面的元素,但是lua下标从1开始

    Table里面什么都可以存

    插入元素:table.insert(a,”d”)在table a的末尾插入d

    也可以指定插入位置:table.insert(a,2,”d”)在table a的第二个位置插入d

    移除元素:table.insert(a,,2)移除第二个元素,通过也会把移除的这个元素返回出来

    Table 字符串下标:

    类似于哈希表

    打印元素

    添加元素

    全局表_G

    所有的全局变量都在全局表里面

    在lua里面只有false和nil代表假,其他的都代表真,比如0也是真

    分支判断语句

    用then和end表示一个代码块

    循环语句

    For循环:

    初值1,结束值10,也可以再加个参数:步长

     这里步长是2

    这里面对i是不能进行更改的

    当i等于5时退出循环

    While循环

    do end是一个代码块

    不能用n-=1

    展开全文
  • lua基础教程

    2018-09-29 11:30:31
    Lua 语言是基于 C 语言之上的开源编程语言。它的价值在于其跨平台的特性,从大型服务器系统到小型移动应用 都可以看到它的身影。 本教程不仅包括 Lua 编程语言的基本知识,还包括 Lua 语言在各类应用场景中的应用。
  • lua 基础教程

    2020-09-21 19:55:38
    Lua 的语法比较简单,学习起来也比较省力,但功能却并不弱。所以,我只简单的归纳一下Lua的一些语法规则,使用起来方便好查就可以了。估计看完了,就懂得怎么写Lua程序了。
  • lua基础

    2021-01-21 17:25:55
    tar zxf lua-5.3.0.tar.gz cd lua-5.3.0 make linux test make install 注意:make linux test 时报错 解决办法:缺少 libreadline-dev 依赖包,安装该依赖即可: sudo apt-get update sudo apt-get install ...

    1. 安装

    curl -R -O http://www.lua.org/ftp/lua-5.3.0.tar.gz
    tar zxf lua-5.3.0.tar.gz
    cd lua-5.3.0
    make linux test
    make install

    注意:make linux test 时报错
    在这里插入图片描述
    解决办法:缺少 libreadline-dev 依赖包,安装该依赖即可:

    sudo apt-get update
    sudo apt-get install libreadline-dev

    2. 参考文档

    lua教程

    3. 基本用法

    • 变量默认是全局(即使是在语句块或者函数里也是全局变量,除非声明为local, 局部变量作用域从声明位置开始到所在语句块结束,需要注意:函数里的全局变量只有在调用函数后生效),访问未初始化的变量,得到 nil
    • 以下划线开头连接一串大写字母 被保留用于lua内部全局变量,如 _VERSION
    • 数据类型:nil(表示无效值)、boolean只有 false 和 nil 为 false,其他包括0均表示true)、number (默认只有double类型)、stringfunction (由C或lua编写的函数)、userdata (存储在变量中的C数据结构)、threadtable
    • lua 里表的默认初始索引为1
    -- 这是单行注释
    --[[
    这是多行注释
    多行注释
    --]]
    
    -- 删除全局变量
    b = nil
    
    -- 判断变量是否存在(type 返回的是字符串)
    type(X)=="nil"
    
    -- 单引号或双引号表示 string,也可以用 [[]]表示一块字符串
    html = [[
    <html>
    <head><head>
    <body>
    </body>
    </html>
    ]]
    
    -- 数字字符串进行算术操作时,会尝试将数字字符串转换为数字
    print("2"+6) -- 输出8.0
    
    -- 字符串连接
    print("a" .. "b")
    
    -- 字符串长度
    #str
    
    -- table用法
    -- 创建空表
    a = {}
    -- 初始化
    b = {"a","b","c"}
    -- 添加数据
    a["key"] = "value"
    a[20] = 10
    for k, v in pairs(a) do
    	print(k .. ":" .. v)
    end
    -- 访问索引
    table1[1]
    table1.key -- 当索引为字符串时
    gettable_event(table1, 1)
    
    -- function
    -- 匿名函数
    function(key, val)
    	return key..":"..val;
    end
    
    -- 多变量同时赋值
    a, b = 10, 5
    -- 交换a,b的值
    a, b = b, a -- lua会先计算右边的值
    

    循环语句

    while(true)
    do 
    	print("循环")
    end
    
    -- var 从 exp1变化到exp2,步长为exp3
    for var=exp1,exp2,exp3 do -- 这三个表达式只计算一次, exp3默认为1
    	print(var)
    end
    
    -- 泛型for循环:通过迭代器函数遍历所有值
    t = {"a", "b", "c"}
    for i, v in ipairs(t) do
    	print(i,v)
    end
    
    repeat
    	print("循环")
    until(true)
    
    -- goto: 将控制流程无条件转向被标记的语句处
    local a = 1
    ::label:: print("--- goto label ---")
    
    a = a + 1
    if a < 3 then
    	goto label
    end
    
    

    函数

    • 默认为全局函数,用local声明局部函数
    -- 可变参数
    function add(...)
    	result = 0
    	local arg = {...}
    	for i, v in ipairs(arg) do
    		result = result + v
    	end
    	print("总共传入 ".. #arg .. " 个参数")
    	return result, #arg
    end
    

    运算符

    a==b
    a~=b
    a^3
    -- and or not
    
    展开全文
  • 今天小编就为大家分享一篇关于Lua基础之运算符的使用示例,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • lua基础库封装

    2019-04-15 10:58:27
    自己编写的一些lua基础库,包含了常用的字符串处理;文件夹处理;文件处理等
  • Lua基础教程与实践

    千次阅读 2021-11-24 16:14:12
    目录Lua配置、安装、与运行Lua编译与调试环境搭建Lua基本语法1.交互式编程2.脚本式编程Lua中的数据类型1.数据类型展示2.注意事项Lua中的变量全局变量局部变量非局部变量(先看闭包)(upvalue)(实际代指变量而非值)...

    Lua配置、安装、与运行

    1.进入Lua官网:http://www.lua.org——下载Lua
    2.下载文件【 lua-5.3.4_Win64bin.zip 】
    3.创建一个空文件夹“Lua”并在其中解压【 lua-5.3.4_Win64bin.zip 】压缩文件
    4.复制“Lua”文件夹到一个不会被删除的地方,
    5.路径最好不要是中文。( 推荐选择C盘 )
    6.将此路径加入到环境变量中
    7.cmd 中输入lua 查看安装是否成功

    Lua编译与调试环境搭建

    1.下载sublime
    2.点击 菜单栏→→ 工具 →→ 编译系统 →→ 新编译系统
    menu bar →→ Tools →→ Build System →→ new Build System
    在这里插入图片描述
    3.复制代码到配置中
    在这里插入图片描述

        "cmd": ["lua","$file"],  
        "file_regex":"^(...*?):([0-9]*):?([0-9]*)",  
        "selector":"source.lua"  
    

    3.保存到默认目录:命名为MyLua.sublime-build
    注意:后缀一定要是 .sublime-build 。
    保存,关闭Sbulime Text
    4.重新打开Sbulime Text
    点击 菜单栏→→ 工具 →→ MyLua(我们刚创建好的编译系统文件)
    menu bar →→ Tools →→ MyLua
    选中MyLua编译环境就可以运行了
    5.保存完成→→点击“F7”或者“Ctrl+B”调试
    在这里插入图片描述

    Lua基本语法

    1.交互式编程

    Lua 提供了交互式编程模式。我们可以在命令行中输入程序并立即查看效果。

    Lua 交互式编程模式可以通过命令 lua -i 或 lua 来启用:
    在这里插入图片描述

    2.脚本式编程

    我们可以将 Lua 程序代码保存到一个以 lua 结尾的文件,并执行,该模式称为脚本式编程,如我们将如下代码存储在名为 hello.lua 的脚本文件中:

    在这里插入图片描述

    Lua中的数据类型

    1.数据类型展示

    print(type(“Hello world”)) --> string
    print(type(10.4*3)) --> number
    print(type(print)) --> function
    print(type(type)) --> function
    print(type(true)) --> boolean
    print(type(nil)) --> nil
    print(type(type(X))) --> string

    2.注意事项

    在这里插入图片描述
    在这里插入图片描述

    Lua中的变量与函数

    全局变量

    局部变量

    非局部变量(先看闭包)

    在这里插入图片描述

    变量值的交换

    在这里插入图片描述

    Lua中的函数

    函数原型

    每个Lua函数都有一个原型,这是一个由GC管理的对象,它挂靠在函数上,为函数提供必要的信息,比如这个函数的操作码(opcodes),常量信息,本地变量信息,upvalue信息,和调试信息等等。

    因为Lua函数中可以内嵌函数,所以原型对象里面也有一个内嵌原型的列表,由此形成一个函数原型的树。

    原型结构是这样的:

    typedef struct Proto {
      CommonHeader;
      // 固定参数的数量
      lu_byte numparams;  /* number of fixed parameters */
      // 是否有可变参数
      lu_byte is_vararg;
      // 该函数需要的栈大小
      lu_byte maxstacksize;  /* number of registers needed by this function */
      // upvalues数量
      int sizeupvalues;  /* size of 'upvalues' */
      // 常量数量
      int sizek;  /* size of 'k' */
      // 指令数量
      int sizecode;
      // 行信息数量
      int sizelineinfo;
      // 内嵌原型数量
      int sizep;  /* size of 'p' */
      // 本地变量的数量
      int sizelocvars;
      // 函数进入的行
      int linedefined;  /* debug information  */
      // 函数返回的行
      int lastlinedefined;  /* debug information  */
      // 常量数量
      TValue *k;  /* constants used by the function */
      // 指令数组
      Instruction *code;  /* opcodes */
      // 内嵌函数原型
      struct Proto **p;  /* functions defined inside the function */
      // 行信息
      int *lineinfo;  /* map from opcodes to source lines (debug information) */
      // 本地变量信息
      LocVar *locvars;  /* information about local variables (debug information) */
      // Upvalue信息
      Upvaldesc *upvalues;  /* upvalue information */
      // 使用该原型创建的最后闭包(缓存)
      struct LClosure *cache;  /* last-created closure with this prototype */
      // 源代码文件
      TString  *source;  /* used for debug information */
      // 灰对象列表,最后由g->gray串连起来
      GCObject *gclist;
    } Proto;
    

    函数中的常量与局部变量

    函数中的常量就是那些字面量,比如下面代码:

    local function fun()
    	--ok true这些就是常量,Lua把所有的值都统一为TValue,常量也不例外,由TValue *k;保存。
        local x = 1
        local s = "ok"
        local b = true
        --而且常量只能是数字,布尔值,字符串,和nil这些基本类型,其他GC对象不可以是常量。由于常量不可变,所以直接保存在原型对象上就可以了。
    end
    

    函数中的固定参数,可变参数,和本地变量,都是局部变量,这些变量都存在函数关联的栈中,而栈中的元素就称为“寄存器”,maxstacksize指定该函数需要多少个寄存器,在创建Lua函数时就会在栈上预留这么多空间。因为可变参数的实际数量只有调用者才知道,所以maxstacksize不包含可变参数的数量。

    locvars是一个局部变量的信息结构,主要用于调试的:

    //  本地变量的信息
    typedef struct LocVar {
      // 本地变量名
      TString *varname;   
      int startpc;  /* first point where variable is active */
      int endpc;    /* first point where variable is dead */
    } LocVar;
    

    子函数原型

    struct Proto **p保存着内嵌函数的原型列表,比如下面的代码:

    function func()
        local function sf1()
        end
        local function sf2()
        end
    end
    

    sf1和sf2就是内嵌函数,所以func的函数原型就有两个子原型。

    upvalue (实际代指变量而非值)

    upvalue其实就是外部函数的局部变量,upvalues是这些upvalue的信息列表,Upvaldesc结构如下:

    typedef struct Upvaldesc {
      // 名字
      TString *name;  /* upvalue name (for debug information) */
      lu_byte instack;  /* whether it is in stack (register) */
      lu_byte idx;  /* index of upvalue (in stack or in outer function's list) */
    } Upvaldesc;
    

    instack指明这个upvalue会存在哪里,有两种情况要考虑:

    uv如果是上一层函数的局部变量,且这个上层函数还在活动中,那么该局部变量一定还在上层函数的栈中。此时,instack为1,表明它在栈中,idx指定在栈中的索引,相对于上层函数的栈基址。
    uv如果是上一层函数之外的局部变量,就像下面代码这样:

    local x = 1
    local function func()
        local function innerfunc()
            return x + 1
        end
    end
    

    x在上两层函数之外声明,Lua是这样解决这个问题的:首先func会把x当成upvalue记录下来,然后innerfunc再从func的upvalue数组寻找。所以这种情况下,instack为0,则idx表示上层函数uv列表的索引。

    实际的upvalue引用是在函数对象中的,这里只是一个描述信息,函数对象要根据这个信息才能引用到upvalue。

    C闭包

    Lua在执行到fucntion … end表达式时,会创建一个函数对象,其结构如下:

    typedef union Closure {
      CClosure c;
      LClosure l;
    } Closure;
    

    正好对应了C闭包和Lua闭包,C闭包结构如下:

    // nupvalues upvalue数量
    // gclist为灰对象列表,最后由g->gray串连起来
    #define ClosureHeader \
        CommonHeader; lu_byte nupvalues; GCObject *gclist
    // C闭包
    typedef struct CClosure {
      ClosureHeader;
      lua_CFunction f;    // C函数指针
      TValue upvalue[1];  /* list of upvalues */    // update数组
    } CClosure;
    因为C函数相应简单,没有外层函数,所以upvalue其实就是保存在CClosure中的一个TValue数组。一个CClosure的实际大小通过sizeLclosure计算出,其内存布局如下:
    
    | CClosure | TValue[0] | .. | TValue[nupvalues-1] |
    因为CClosure的upvalue数组包含了一个元素,所以后面跟着的长度为nupvalues-1。通过luaF_newCclosure生成一个新的C闭包,实际应用中一般用lua_pushcclosure向栈顶压入一个新的C闭包,同时栈顶要装备好upvalue。函数实现如下:
    
    // 生成一个C闭包并压入栈顶, n表示当前栈顶有多少个upvalue要与闭包关联
    LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
      lua_lock(L);
      if (n == 0) {
        // 没有upvalue,它是轻量级C函数
        setfvalue(L->top, fn);
        api_incr_top(L);
      }
      else {
        // 有upvalue,它是一个C闭包
        CClosure *cl;
        api_checknelems(L, n);
        api_check(L, n <= MAXUPVAL, "upvalue index too large");
        // 新建C闭包
        cl = luaF_newCclosure(L, n);
        cl->f = fn;
        L->top -= n;
        // 保存upvalue
        while (n--) {
          setobj2n(L, &cl->upvalue[n], L->top + n);
          /* does not need barrier because closure is white */
        }
        setclCvalue(L, L->top, cl);
        api_incr_top(L);
        luaC_checkGC(L);
      }
      lua_unlock(L);
    }
    

    Lua闭包

    Lua闭包结构如下:

    // Lua闭包
    typedef struct LClosure {
      ClosureHeader;
      struct Proto *p;    // 函数原型
      UpVal *upvals[1];  /* list of upvalues */   // upvalue列表
    } LClosure;
    通过sizeLclosure宏可获得Lua闭包的大小,其内存布局如下:
    
    | LClosure | UpVal* | .. | UpVal* |
    UpVal是对upvalue的间接引用,它的结构这样:
    
    struct UpVal {
      // 引用的值,该值可能在栈上(open),也可能是下面的TValue(close)
      TValue *v;  /* points to stack or to its own value */
      // 引用计数
      lu_mem refcount;  /* reference counter */
      union {
        // 当v指向栈上时,open有用,next指向下一个,挂在L->openupval上
        struct {  /* (when open) */
          UpVal *next;  /* linked list */
          int touched;  /* mark to avoid cycles with dead threads */
        } open;
        // 当v指向自己时,这个值就在这里
        TValue value;  /* the value (when closed) */
      } u;
    };
    

    LClosure中记录的是UpVal指针,这说明一个UpVal可能会被多个Lua闭包引用,refcount就是这个引用计数。UpVal长成这个样子,完全是因为它要解决作用域的问题。比如下面代码:

    function add (x)
        return function (y)
            return x+y
        end
    end
    
    local add2 = add(2)
    print(add2(5))
    

    add函数调用完之后,参数x就超出作用域了,它本来在栈上,函数返回后它也会从栈中删除掉,但是add返回的函数对象还引用着这个x,这该怎么办呢?Lua是这样处理的。

    UpVal有两种状态:

    open状态 在这种情况下,其字段v指向的是栈中的值,换句话说它的外层函数还在活动中,因此那些外部的局部变量仍然活在栈上。
    close状态 当外层函数返回时,就像上面代码那样,add2函数中的UpVal会变成关闭状态,即v字段指向自己的TValue,这样v就不依赖于外层局部变量了。
    lua_State的openupval字段维护着一个open的链表,当创建一个Lua闭包时,调用luaF_findupval尝试从openupval链表中找到一个UpVal(根据函数原型的Upvaldesc信息),如果找得到就记录它并增加引用计数,如果找不到就创建一个新的UpVal,并加入openupval链表,原码如下:

    // 查找栈上的uv。
    UpVal *luaF_findupval (lua_State *L, StkId level) {
      UpVal **pp = &L->openupval;
      UpVal *p;
      UpVal *uv;
      lua_assert(isintwups(L) || L->openupval == NULL);
      // 查找open的uv, open的uv由L->openupval串起来一个链表
      while (*pp != NULL && (p = *pp)->v >= level) {
        lua_assert(upisopen(p));
        if (p->v == level)  /* found a corresponding upvalue? */
          return p;  /* return it */
        pp = &p->u.open.next;
      }
      /* not found: create a new upvalue */
      // 如果未找到,创建一个新的加入链表
      uv = luaM_new(L, UpVal);
      uv->refcount = 0;
      uv->u.open.next = *pp;  /* link it to list of open upvalues */
      uv->u.open.touched = 1;
      *pp = uv;
      uv->v = level;  /* current value lives in the stack */
      if (!isintwups(L)) {  /* thread not in list of threads with upvalues? */
        L->twups = G(L)->twups;  /* link it to the list */
        G(L)->twups = L;
      }
      return uv;
    }
    

    比如下面这段Lua代码:

    local x = 1
    local y = 2
    local z = 3
    
    local function f1()
        return x + 1
    end
    
    local function f2()
        return x + 2
    end
    

    执行到f1声明时,创建一个Lua闭包,并创建一个UpVal挂到openupval链表上,接着执行到f2声明,此时从openupval可以到过UpVal,就直接引用它。

    外层函数执行完毕的时候,会调用luaF_close将openupval中的一些UpVal关闭,代码如下:

    vmcase(OP_RETURN) {
        int b = GETARG_B(i);
        if (cl->p->sizep > 0) luaF_close(L, base);
    ...
    
    // 关闭栈中的upvalues,从level往后的upvalue,如果引用计数为0释放之,否则拷贝到UpVal自己身上
    void luaF_close (lua_State *L, StkId level) {
      UpVal *uv;
      while (L->openupval != NULL && (uv = L->openupval)->v >= level) {
        lua_assert(upisopen(uv));
        L->openupval = uv->u.open.next;  /* remove from 'open' list */
        if (uv->refcount == 0)  /* no references? */
          luaM_free(L, uv);  /* free upvalue */
        else {
          setobj(L, &uv->u.value, uv->v);  /* move value to upvalue slot */
          uv->v = &uv->u.value;  /* now current value lives here */
          luaC_upvalbarrier(L, uv);
        }
      }
    }
    

    luaF_close还会在其他地方执行,只要任何情况下留在栈中的局部变量被删除出栈,就会调这个函数。调完之后,UpVal本身就把局变量的值保存在自己身上了,这个过程对于函数是透明的,因为它总是间接的引用upvalue。

    下图表示open和close的UpVal状态:
    在这里插入图片描述

    关于闭包的理解(词法定界)

    function fn()
        local i = 0
        return function()     -- 注意这里是返回函数的地址,不是执行
           i = i + 1
            return i
        end
    end
    
    c1 = fn()                      -- 接收函数返回的地址
    print(c1())                    --> 1          --c1()才表示执行
    --local i = 0的意思是重新创建一个新的变量,这里没有创建新的?
    print(c1())                    --> 2
    
    --再次调用fn,将创建一个新的局部变量i
    c2 = fn()
    print(c2())  -->1
    print(c1())  -->3
    print(c2())  -->2
    
    
    

    闭包在Lua中是一个非常重要的概念,闭包是由函数和与其相关的引用环境组合而成的实体。闭包=函数+引用环境。子函数可以使用父函数中的局部变量,这种行为叫做闭包。lua中函数是一种类型,可以被存放在变量或者数据结构中,可以当做参数传递给另一个函数,也可以是一个函数的返回值,也可以在运行期间被创建。Lua中还有一个非局部变量的概念,可以理解为不是在局部作用范围内定义的一个变量,同时,它又不是一个全局变量,也就是大家说的upvalue。这种变量主要应用在嵌套函数和匿名函数中(这个变量的环境就是前面说的引用环境)。在Lua函数中再定义函数,称为内嵌函数,内嵌函数可以访问外部函数已经创建的所有局部变量,而这些变量就被称为该内嵌函数的upvalue(upvalue实际指的是变量而不是值),这些变量可以在内部函数之间共享。于是成全了Lua中闭包。

    function Closure()
    	local ival = 10           	--upvalue
    	function InnerFun1()     	--内嵌函数
    		print(ival)
    	end
    
    	function InnerFun2()
    		print("Before",ival)
    		ival = ival + 10
    		print("After", ival)
    	end
    
    	return InnerFun1, InnerFun2
    end
    
    --将函数赋值给变量,此时变量a绑定了函数InnerFun1,b绑定了函数InnerFun2
    local a, b = Closure()
    
    --调用a
    a()
    
    --调用b
    b()
    
    
    

    Lua处理从C#获得的数组、字典、结构体等

    方式1迭代器遍历以及转化为table后循环

    local testData = CS.LuaCallCSUtils.GetTestData()  --为一个字典
    
    local iter = testData:GetEnumerator()
    
    local list = {}
    
    while iter:MoveNext() do
    	--数组或list直接获取Current
    	--local v = iter.Current
        local k = iter.Current.Key
        local v = iter.Current.Value
        list[k] = v  --转为table
        print(k, v)
    
    end
    
    local t = obj.array:ToTable()
    for i = 1, #t do
        print("table:"..t[i])
    end
    
    

    方式2类似C#的调用以及相关注意事项

    在这里插入图片描述

    print("*****************Lua调用C#数组******************");
    local Lesson3=CS.Lesson3();
    
    --Lua使用C#数组相关知识
    
    --长度 userdata
    
    --C#怎么用 lua就怎么用
    print(Lesson3.testArray.Length);
    
    --访问元素
    
    print(Lesson3.testArray[0]);
    
    
    --遍历要注意 虽然lua中索引从1开始
    --但是数组是C#那不得规则 所以 还是要按照C#来
    --注意最大值 一定要减1 lua中是可以取到最后一个值得 nil
    
    for i=0,Lesson3.testArray.Length-1 do
    	print(Lesson3.testArray[i]);
    end
    
    --Lua创建一个C#得数组 lua中表示数组和List可以用表
    --但是创建C#中的数组,使用Array类中的静态方法即可
    
    local Array2 = CS.System.Array.CreateInstance(typeof(CS.System.Int32),10);
    print(Array2.Length);
    print("修改前"..Array2[0]);
    Array2[0]=100;
    print("修改后"..Array2[0]);
    print("*****************Lua调用C# List******************");
    
    Lesson3.testList:Add(1);
    Lesson3.testList:Add(2);
    
    --长度
    print(Lesson3.testList.Count);
    
    --遍历
    
    for i=1,Lesson3.testList.Count-1 do
    	print(Lesson3.testList[i])
    end
    
    print(Lesson3.testList);
    
    --Lua创建一个List对象
    --老版本
    local list2 = CS.System.Collections.Generic["List`1[System.String]"]();
    print(list2);
    list2:Add("老版本创建List");
    print(list2[0]);
    
    --新版本>V2.1.12
    local List_StringTemp = CS.System.Collections.Generic.List(CS.System.String);
    local list3 = List_StringTemp();
    list3:Add("新版本创建List");
    print(list3[0]);
    
    
    print("*****************Lua调用C#数组、List、字典相关知识点******************");
    Lesson3.testDic:Add(1,"123");
    print(Lesson3.testDic[1]);
    --遍历
    for k,v in pairs(Lesson3.testDic) do
    	print(k,v)
    end
    --Lua中创建一个字典对象(新版本)
    
    local Dic_String_Vectory3 = CS.System.Collections.Generic.Dictionary(CS.System.String,CS.UnityEngine.Vector3);
    local dic2 = Dic_String_Vectory3();
    dic2:Add("123",CS.UnityEngine.Vector3.right);
    --lua中创建的字典,key是string时,通过中括号是获取不到值的
    print(dic2["123"]);--nil
    --使用TryGetValue 两个返回值 第一个返回值为是否获取到 第二个为获取到的值
    print(dic2:TryGetValue("123"));
    --如果要通过健来获取值 通过固定方法
    print(dic2:get_Item("123"));
    --修改也是固定
    dic2:set_Item("123",nil);
    
    print(dic2:get_Item("123"));
    
    
    

    …待续(持续更新中)

    参考与引用

    https://www.runoob.com/lua/lua-tutorial.html
    https://blog.csdn.net/ChinarCSDN/article/details/78667262
    https://blog.csdn.net/Yeyushenfan/article/details/83039573
    https://zhuanlan.zhihu.com/p/98917625

    展开全文
  • lua基础笔记

    2019-03-14 13:50:55
    学习笔记,lua学习基础笔记,小知识点,下载嘘谨慎,没有想象中完美
  • 今天小编就为大家分享一篇关于Lua基础迭代器的使用实例,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • lua基础学习笔记

    2019-03-05 09:10:33
    有其他语言基础学习lua入门是比较快的,主要是学习lua跟其他语言的一些区别,一些特性
  • Lua基础(一)

    万次阅读 多人点赞 2019-01-25 22:35:55
    目录Lua是什么Lua应用场景Lua和C#的区别print方法、单行/多行注释Lua命名规则(标识符)全局变量的使用和销毁Lua中的数据类型nil 空类型boolean 布尔类型number数字类型string字符串类型table表类型function函数...
  • 脚本策划LUA基础(张哲).doc
  • lua基础知识点总结

    千次阅读 多人点赞 2018-11-17 00:32:50
    1.Lua安装 2. 注释 3.Lua中的数据类型 3.1 nil(空) 3.2 boolean(布尔) 3.3 number(数字) 3.4 string(字符串) 3.5 table(表) 3.6 function(函数) 4.全局变量 多变量同时赋值 5.Lua 循环 5.1...
  • lua基础知识

    2017-12-03 11:45:23
    有关lua基础知识,内容包括函数库,捕获,文件处理等。
  • Lua基础应用笔记

    2018-03-12 17:23:09
    Lua 教程 Lua是一种轻量小巧的脚本语言,用标准C语言编写并以源代码形式开放,其设计目的是为了嵌入应用程序中,从而为应用程序提供灵活的扩展和定制功能 本资源属于Lua笔记主要介绍了Lua基础应用。
  • $ lua hello.lua
  • Lua基础之数据类型

    千次阅读 2019-01-20 17:42:25
    Lua是动态类型(运行时)的语言,变量不需要类型定义,只需要为变量赋值! 在Lua中有8个基本类型分别为:nil、boolean、number、string、userdata、function、thread和table。 nil 一个未被赋值的变量默认为nil,...
  • lua基础学习文档

    2015-07-31 16:48:19
    lua基本文档,适合初学时,包含lua函数库 lua模式匹配 lua文件处理 lua表和元方法
  • unity中需要的lua基础

    2014-12-04 19:15:48
    unity中热更必备的lua基础,和 下载ulua插件以及tolua#工程,供入门使用
  • lua 基础使用

    2022-02-11 14:17:14
    开发环境搭建 基于Linux进行lua安装 cd lua-5.3.0 make linux test make install helloworld.lua #!/usr/local/bin/lua print("Hello World!...Lua基础语法 lua使用require实现so库加载。 package
  • Lua基础语法

    2013-09-04 15:38:53
    Lua语法的简单介绍,想学Lua的同学可以参考下
  • lua基础语法

    千次阅读 2022-05-02 10:56:48
    lua:每个if就没 i=10 if i<10 then print("i<10 ") elseif i>10 then print("i>10 ") elseif i==10 then print("i=10 ") end c语言: #include <stdio.h> int main() { int i=16; if(i>...
  • 1.什么是lua数据结构原理 2.为什么要有lua数据结构原理 3.如何使用lua数据结构原理,使用lua数据结构原理的不同方案比较 4.lua数据结构源码实现 5.lua数据结构关键点,重要节点,疑难杂症场景 引用 如何...
  • LUA基础语法

    2013-08-26 15:20:04
    介绍LUA的基本语法和操作,还有基本的例子。
  • Lua基础系列】协程

    千次阅读 2021-01-14 21:53:08
    Lua基础系列】协程 大家好,我是Lampard~~ 欢迎来到Lua进阶系列的博客 前文再续,书接上一回。今天和大家讲解一下lua中的协程 (一) 什么是协程 Lua 协同程序(coroutine)与线程(这里的线程指的是操作系统...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,302
精华内容 18,120
关键字:

lua基础