LUA 学习笔记

1.C# 与 LUA
C#调用LUA比较简单，但LUA调用C#，有两种方法，一种是直接反射调用，但这种方法有局限性，
比如性能低，在IOS平台无法使用反射，因此一般使用WARP方法，即把C#代码注册到LUA虚拟机，然后调用的时候，LUA -> C# WARP -> C# CODE
参考：http://blog.csdn.net/pengdongwei/article/details/50420612

2.LUA变量
Lua是动态类型语言，变量不要类型定义,只需要为变量赋值就会创建这个变量
Lua 变量有三种类型：全局变量、局部变量、表中的域。
在默认情况下，变量总是认为是全局的，即使该变量在语句块里或者函数里，
除非用local声明为局部变量，局部变量的作用域为从声明位置开始到所在语句块结束。
全局变量不需要声明，给一个变量赋值后即创建了这个全局变量，访问一个没有初始化的全局变量也不会出错，只不过得到的结果是：nil。
如果你想删除一个全局变量或者一个table，只需要将变量赋值为nil。

3.字符串表示

string1 = "this is string1"
string2 = 'this is string2'
或者用‘[[]]’来表示字符串块，可换行
string3 = [[
Line1
Line2
]]

4.字符串操作
用'..'来连接字符串而不是'+'，例如 'error' + 1 是错的，但 'error' .. 1 是对的。
用'+'号连接字符串，LUA会默认为将字符串转为数字，例如 '2' + 6，结果是 8 而不是 '26'

5.使用 # 来计算字符串或表的长度

> len = "www.w3cschool.cc"
> print(#len)
16

6.1.LUA中的table
Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字或者是字符串。

eg. t = {}
t["key1"] = "value1"
key2 = 10
t[key2] = 20
for k, v in pairs(t) do
print(k..":"..v)
end
输出：    key1:value1
10:20

对 table 的索引使用方括号 []。Lua 也提供了 . 操作。

6.2.Lua中的数组

在 Lua 中，数组（array）其实就是 table 的一种特殊形式。Lua 没有专门的数组类型，所有的数组都是使用 table 实现的。具体来说，Lua 中的数组是下标为整数且序列化的 table，也就是从 1（Lua 的下标从 1 开始，而不是从 0 开始）开始连续递增的 table。

Lua 标准库提供了专门用于操作数组的函数，如 table.insert(数组中插入元素)、table.remove(数组中移除元素)、table.concat

注：因为数组只是 table，所以可以在同一个 table 中同时包含数组部分和哈希表（键值对）部分

混合使用数组和哈希表
local t = {10, 20, 30}  -- 定义一个数组部分
t["name"] = "Lua"  -- 定义一个哈希表部分

-- 访问数组部分
for i = 1, #t do
    print(t[i])
end

-- 访问哈希表部分
print(t["name"])

7.不同于其他语言的数组把 0 作为数组的初始索引，在 Lua 里表的默认初始索引一般以 1 开始。
但你也可以指定 0 开始。
除此外我们还可以以负数为数组索引值：

array = {}

for i= -2, 2 do
array[i] = i * 2
end

for i = -2,2 do
print(array[i])
end

8.Lua可以对多个变量同时赋值，变量列表和值列表的各个元素用逗号分开，赋值语句右边的值会依次赋给左边的变量。

a, b = 10, 2*x <--> a=10; b=2*x
x, y = y, x -- swap 'x' for 'y'

当变量个数和值的个数不一致时，Lua会一直以变量个数为基础采取以下策略：
a. 变量个数 > 值的个数按变量个数补足nil
b. 变量个数 < 值的个数多余的值会被忽略

9.循环
与其他编程语言主要区别是for循环：
用法1：

for var=exp1,exp2,exp3 do 
<执行体> 
end

var从exp1变化到exp2，每次变化以exp3为步长递增var，并执行一次"执行体"。exp3是可选的，如果不指定，默认为1，
exp可以为函数（毕竟在LUA中函数也是变量的一种），而且只在开头执行一次
用法2：

--打印数组a的所有值 
for key,value in ipairs(table) 
do print(key..value) 
end

类似C#的foreach

10.条件控制语句

if( 布尔表达式 1)
then
--[ 在布尔表达式 1 为 true 时执行该语句块 --]

elseif( 布尔表达式 2)
then
--[ 在布尔表达式 2 为 true 时执行该语句块 --]

else 
--[ 如果以上布尔表达式都不为 true 则执行该语句块 --]
end

要注意的是，在LUA中0表示true

11.函数的可变参数
Lua函数可以接受可变数目的参数，和C语言类似在函数参数列表中使用三点（...) 表示函数有可变的参数。
Lua将函数的参数放在一个叫arg的表中，#arg 表示传入参数的个数。
例如，我们计算几个数的平均值：

function average(...)
result = 0
local arg={...}
for i,v in ipairs(arg) do
result = result + v
end
print("总共传入 " .. #arg .. " 个数")
return result/#arg
end

print("平均值为",average(10,5,3,4,5,6))

12.LUA的逻辑运算符
与其他编程语言不同，LUA不使用 &&， ||， ! ，而使用'and', 'or', 'not' 代替

13.LUA模块
模块类似于一个封装库，Lua 的模块是由变量、函数等已知元素组成的 table，因此创建一个模块很简单，就是创建一个 table，然后把需要导出的常量、函数放入其中，最后返回这个 table 就行。

-- 文件名为 module.lua
-- 定义一个名为 module 的模块
module = {}

-- 定义一个常量
module.constant = "这是一个常量"

-- 定义一个函数
function module.func1()
io.write("这是一个公有函数！\n")
end

local function func2()
print("这是一个私有函数！")
end

function module.func3()
-- 私有函数，因此是不能从外部访问模块里的这个私有函数，必须通过模块里的公有函数来调用.
func2()
end

return module

14.加载模块：require("<模块名>") 或者 require "<模块名>"

-- test_module.lua 文件
-- module 模块为上文提到到 module.lua
-- 也可以给模块定义一个别名变量：local m = require("module")
require("module")

print(module.constant)

module.func3()

15.加载C/C++模块

path = "C:\\windows\\luasocket.dll"    --这是 Window 平台下
local f = assert(loadlib(path, "luaopen_socket"))    --assert断言是否加载成功
f() -- 真正打开库

16.元表跟表的区别以及实现原理:

参考:由浅入深的理解Lua的数据结构——table - 简书 (jianshu.com)

在 Lua 中，表（table）和元表（metatable）的底层实现原理涉及到 Lua 的内部数据结构和元表机制。下面简要介绍一下它们的底层实现原理：

表的底层实现原理

Lua 中的表实际上是一种关联数组，使用哈希表（hash table）实现。哈希表是一种数据结构，它通过将键（key）转换为索引（index）来快速查找和访问值（value）。Lua 中的表可以包含任意类型的键和值，因此可以用来表示数组、字典、对象等。

在 Lua 的内部实现中，表由两部分组成：

哈希部分（Hash Part）: 存储键值对的哈希表。
数组部分（Array Part）: 存储连续整数索引的数组。

当表中的键是整数时，Lua 会优化存储方式，使用数组部分来存储。当键不是整数或是整数但不连续时，Lua 使用哈希部分来存储。

typedef struct Table {
  CommonHeader;　　// 为所有可回收资源提供标记头
  lu_byte flags;  /* 1<<p means tagmethod(p) is not present */  // lu_byte其实是 typedef unsigned char lu_byte，lu_byte flags用于表示表中提供了哪些元方法
  lu_byte lsizenode;  /* 以2的lsizenode次方作为哈希表长度 */　　// 它的值就是表的长度，但是散列表大小的扩增一定是2的幂，如果散列桶数组要扩展的话，也是每次在原大小的基础上乘以2的形式扩展。
  struct Table *metatable /* 元表 */;
  TValue *array;  /* 数组 */
  Node *node; /* 哈希表 */
  Node *lastfree;  /* 指向最后一个为闲置的链表空间 */
  GCObject *gclist;
  int sizearray;  /* 数组的大小 */
} Table;

元表的关联和设置

元表是 Lua 中用于定制表行为的机制。每个表可以关联一个元表，元表中包含了一些特定的元方法（metamethods），用于重载表的某些操作。

元表的底层实现原理也涉及到 Lua 的内部数据结构。在 Lua 的底层实现中，元表实际上是一个普通的表，可以看作是一个存储了特定函数的关联数组。这些特定函数就是元方法，例如 __index, __newindex, __add 等。

当 Lua 需要执行一些特定的操作时（例如访问表中不存在的键、给表中不存在的键赋值、进行加法运算等），它会检查表的元表中是否定义了相应的元方法。如果定义了，则调用相应的元方法来执行操作；如果未定义，则执行默认的操作。

在 Lua 中，可以通过 setmetatable 函数将元表关联到表，通过 getmetatable 函数获取表的元表。关联元表后，表就可以通过元表中定义的元方法来改变或扩展其行为。

示例

-- 创建一个普通表
local myTable = {key1 = "value1"}

-- 创建一个元表，并定义 __index 元方法
local metatable = {
    __index = function(table, key)
        if key == "key2" then
            return "default value"
        else
            return nil
        end
    end
}

-- 将元表关联到普通表
setmetatable(myTable, metatable)

-- 访问表的字段
print(myTable.key1)  -- 输出: value1
print(myTable.key2)  -- 输出: default value
print(myTable.key3)  -- 输出: nil

在这个示例中，metatable 就是一个普通的表，其中包含了一个 __index 元方法。当访问 myTable 中不存在的键 key2 时，Lua 会检查表的元表中是否定义了 __index 元方法，并调用该元方法来返回默认值 "default value"。

总结

表使用哈希表和数组实现，可包含任意类型的键和值。
元表实际上是一个普通的表，其中包含了一些特定的元方法，用于重载表的某些操作。
元表通过 setmetatable 关联到表，通过 getmetatable 获取表的元表。
Lua 在执行特定操作时会检查表的元表中是否定义了相应的元方法，如果定义了则执行对应的操作，否则执行默认操作。

17. Lua 中，. 和 : 用于访问表（table）中的函数时的区别

. 和 : 的区别

使用 . 访问函数时，不会自动传递 self，需要手动处理。
使用 : 访问函数时，其实是一种语法糖，Lua 自动将表自身作为第一个参数传递给函数，这是实现面向对象风格编程中对象方法调用的常用方式。

function obj:foo(a) 等价于 function obj.foo(self, a)
obj:foo(42)  等价于 obj.foo(obj, 42)

posted @ 2017-01-05 13:47 JeasonBoy 阅读(573) 评论(0) 编辑收藏举报

刷新页面返回顶部

海底世界

LUA 学习笔记

表的底层实现原理

元表的关联和设置

示例

总结

公告