1. 关于 (…) 操作符
编译阶段优化：
Lua 编译器会对常量字符串进行优化处理，将连续的字符串拼接操作 (…)
合并为单个字符串。这种优化仅适用于编译期确定的常量字符串，不适用于运行时生成的动态字符串。 示例：
local str = "Hello" .. " " .. "World".."!!"
print(str) -- 编译时等价于：local str = "Hello World"
--这段代码运行后只会产生一个字符,（..）拼接过程中不会产生临时字符串
运行时拼接：
当拼接操作涉及变量或动态值时，优化不会生效，拼接将在运行时执行。对于频繁的字符串拼接操作，建议使用 table.concat
以避免创建大量临时字符串导致的性能问题。 示例：
local a = "Hello"
local b = "World"
local c = "!!"
local str = a .. " " .. b.." "..c -- 运行时执行拼接
print(str)
2. 关于 table.concat
table.concat 要求数组元素必须是字符串或数字类型。数字会自动转换为字符串，其他类型（如 boolean、table 或
nil）会引发错误。
3. 关于 xLua 调用 C# 重载方法
数字类型匹配：
Lua 仅使用 number 类型表示数字，而 C#包含多种数值类型（int、float、double、long）。当调用重载方法时，xLua 会按方法定义顺序依次匹配参数类型。 需要注意的是int，float，double，long都属于number 所以即使传递的是1.1这种浮点型，但是c#中仍然会调到第一个匹配以上四个参数的函数。
示例：比如如下代码.lua调用会走到第一个也就是int型的重载函数中
//Main.cs
public class Main{
static int c1, c2, c3, c4, c5,c6,c7;
public static void Execute(int a)
{
c1++;
}
public static void Execute(float a)
{
c2++;
}
}
--text.lua
CS.Main.Execute(1.1)
nil 类型
Lua 传 nil 会被c#转换为 null，这种情况下，对于引用类型参数的传递null，仍可以正常调用，匹配规则仍然是按照重载定义的顺序。
lua传递参数个数多于#方法参数个数
传递参数多余c#方法的参数上限会报错。
// C# 重载方法
public class MethodOverloading : MonoBehaviour
{
public void Method(float num1)
{
Debug.Log("Method(float num1)");
}
public void Method(int num1)
{
Debug.Log("Method(int num1)");
}
public void Method(string num1)
{
Debug.Log("Method(string num1)");
}
}
local classObject = CS.MethodOverloading()
classObject:Method(10) -- 输出结果取决于方法定义顺序
注：修改方法定义顺序将影响最终的调用结果。
下面是关于Xlua的luaCallc#调用反射源码（非warp方式调用）：
//xlua匹配函数代码：
public int Call(RealStatePtr L)
{
try
{
//若仅存在一个重载方法，且该方法无默认参数且无需强制类型检查，则直接调用该重载。
if (overloads.Count == 1 && !overloads[0].HasDefalutValue && !forceCheck) return overloads[0].Call(L);
for (int i = 0; i < overloads.Count; ++i) //顺序遍历所有重载
{
var overload = overloads[i];
if (overload.Check(L))//检查参数是否匹配当前重载
{
return overload.Call(L);
}
}
return LuaAPI.luaL_error(L, "invalid arguments to " + methodName);
}
catch (System.Reflection.TargetInvocationException e)
{
return LuaAPI.luaL_error(L, "c# exception:" + e.InnerException.Message + ",stack:" + e.InnerException.StackTrace);
}
catch (System.Exception e)
{
return LuaAPI.luaL_error(L, "c# exception:" + e.Message + ",stack:" + e.StackTrace);
}
}
//xlua检查函数参数是否匹配代码：
public bool Check(RealStatePtr L)
{
int luaTop = LuaAPI.lua_gettop(L); // 获取 Lua 栈顶索引（参数总数）
int luaStackPos = luaStackPosStart; // 从指定起始位置开始检查参数
for (int i = 0; i < checkArray.Length; i++) // 遍历预定义的检查函数数组
{
// 1. 跳过最后一个参数（若为可变参数）
if ((i == (checkArray.Length - 1)) && (paramsType != null))
break;
// 2. 检查参数缺失（非可选参数）
if (luaStackPos > luaTop && !isOptionalArray[i])
return false; // 参数不足 → 检查失败
// 3. 检查参数类型不匹配
else if (luaStackPos <= luaTop && !checkArray[i](L, luaStackPos))
return false; // 类型不匹配 → 检查失败
// 4. 移动栈指针（仅当参数存在或非可选时）
if (luaStackPos <= luaTop || !isOptionalArray[i])
luaStackPos++; // 指向下一个参数
}
// 5. 处理可变参数（params）情况
return paramsType != null ? (luaStackPos < luaTop + 1 ? checkArray[checkArray.Length - 1](L, luaStackPos) : true) : luaStackPos == luaTop + 1;
}
4. 关于table的rehash时机
我们都知道table是有数组和哈希两部分组成，但是实际上数组部分和哈希部分都是使用数组数据结构实现的，也就是意味着他们的，只不过table的数组部分的数组存储的是tValue,而哈希部分存储的是一个Node节点。并且table初始化时如果没有指定数组的长度，那么数值和哈希部分的长度都是0。那么后续增加数据的时候当如果储存不下的时候就会触发扩容-rehash。并且rehash都是按照2的指数增长。
local a = {}
for k = 1,5 do
table.insert(a,k,k)
end
-- 以上代码执行后会触发四次rehash，分别时添加1，2，3，5的时候
5.关于lua中面向对象
lua中继承类的实例之间共享基类的静态属性。并且修改会实时同步所有实例。比如下段代码中的A的M变量，所有继承A的类的实例之间该属性是共享的。
---@class A
---@field M _A
local A = class("A")
A.M = {A = 1,B = true}
lua中同一个类的所有实例的方法是共享的，在 Lua 的面向对象实现中，T1 和 T2 作为 B
类的实例，共享类的方法，但各自拥有独立的成员变量。这种设计是 Lua 面向对象编程的核心机制，其原理基于 元表（Metatable）和 **__index 元方法**。比如：下列代码的e是结果是true
---@class B:A
local B = class("B",A)
function B:Execute()
self.super.Execute(self)
end
local T1 = B.new()
local T2 = B.new()
local e = T1.Execute==T2.Execute