[Unity] Lua 学习笔记

Posted 2021-12-04 哦哦呵呵

内容摘抄自runoob.com

1.Lua特性

1 轻量化
2 可扩展: 提供了非常易于使用的扩展接口和机制，宿主语言C/C++提供功能，Lua可以直接使用。
3 其它:

• 支持面向过程和函数式编程
• 自动内存管理：只提供一种通用类型的表(table)，用它可以实现数组，哈希表，集合，对象
• 语言内置模式匹配，闭包，函数也可以看作一个值，提供多线程(协同进程，并非操作系统所支持的线程)支持
• 通过闭包和table可以很方便地支持面向对象编程所需要的一些关键机制，比如数据抽象，虚函数，继承与重载。

2.基本语法

1 所有变量定义是默认为全局，如果访问一个没有定义的变量不会发生错误，得到的结果为nil
2 删除一个全局变量，只需要将变量赋值为nil
3 交互式编程，在命令行中输入程序就可以立即看到效果
4 脚本式编程，可以将lua程序保存到以lua结尾的文件中，使用$ lua xxx.lua可以得到结果。
5 单行注释--，多行注释--[[ xxxxx --]]

3.数据类型

  Lua为动态类型语言，变量不需要类型定义，只需要为变量赋值。值可以存储在变量中，作为参数传递或结果返回。共8个基本类型变量。

3.1 nil (空类型)

  nil类型与C/C++中的nullptr相类似。表示没有任何的有效值，例如打印一个没有赋值或者声明的变量那么就会输出一个nil值。
   注意: 对于全局变量和table，nil还有删除作用，将全局变量或table中的某一个变量赋为nil，那么就相当于把这个值删除。
nil做比较时需要加上双引号，因为使用type(xxx) == "nil"作比较时，type(xxx)的返回值为字符串类型。

3.2 string (字符串类型)

表示字符串的几种方式

• 单引号 'xxxxxx'
• 双引号 "xxxxxx"
• 一块字符串 [[xxx 可以是多行]]

注意: 在对一个数字字符串进行算数操作时，Lua会自动将该数字字符串转换成为一个数字，并进行计算。
字符串连接使用 .. 进行连接，字符串计算使用#计算

示例：

>print(2 + "2")
>10:48:23.13-346: 4

>print("2" + "2")
>10:48:33.107-949: 4

>print("2 + 2")
>10:48:46.700-762: 2 + 2

>print("-2e2" * 3)
>10:49:00.837-608: -600

>print("-2e2" * "3")
>10:49:11.445-243: -600

>print("a" .. "b")
>10:49:24.361-15: ab

>print("hello" .. " world")
>10:49:42.610-106: hello world

>print(#"hello world")
>10:49:57.587-2: 11

3.3 table (表)

创建方式:

• 创建一个空表
  local tbl1 = {}
• 直接初始化表
  local tbl2 = {"apple", "pear", "orange", "grape"}

  在table中可以存储任意类型的数据类型，也就是第一个key-value可以和第二个键值对是完全不同的数据类型，数组的索引可以是数字或字符串.

a = {}
a["key"] = "value"
key = 10
a[key] = 22
a[key] = a[key] + 11
for k, v in pairs(a) do
    print(k .. " : " .. v)
end

结果：
$ lua table_test.lua 
key : value
10 : 33

  在Lua中，表的默认索引为1

-- table_test2.lua 脚本文件
local tbl = {"apple", "pear", "orange", "grape"}
for key, val in pairs(tbl) do
    print("Key", key)
end

脚本执行结果为：
$ lua table_test2.lua 
Key    1
Key    2
Key    3
Key    4

  table不会固定长度大小，有新数据添加时table长度会自动增长，没初始化的项都是nil

-- table_test3.lua 脚本文件
a3 = {}
for i = 1, 10 do
    a3[i] = i
end
a3["key"] = "val"
print(a3["key"])
print(a3["none"])

脚本执行结果为：
$ lua table_test3.lua 
val
nil

3.4 function (函数)

  function可以与C/C++语法中一样，可以将函数值当作指针值，将其存储在变量中，那个变量就相当于函数名，通过那个变量就可以调用函数。

-- function_test.lua 脚本文件
function factorial1(n)
    if n == 0 then
        return 1
    else
        return n * factorial1(n - 1)
    end
end
print(factorial1(5))
factorial2 = factorial1
print(factorial2(5))

脚本执行结果为：
$ lua function_test.lua 
120
120

匿名函数

-- function_test2.lua 脚本文件
function testFun(tab,fun)
        for k ,v in pairs(tab) do
                print(fun(k,v));
        end
end

tab={key1="val1",key2="val2"};
testFun(tab,
function(key,val)--匿名函数
        return key.."="..val;
end
);

结果:
$ lua function_test2.lua 
key1 = val1
key2 = val2

3.5 thread (线程)

  在 Lua 里，最主要的线程是协同程序（coroutine）。它跟线程（thread）差不多，拥有自己独立的栈、局部变量和指令指针，可以跟其他协同程序共享全局变量和其他大部分东西。

  线程跟协程的区别：线程可以同时多个运行，而协程任意时刻只能运行一个，并且处于运行状态的协程只有被挂起（suspend）时才会暂停。

3.6 userdata (自定义类型)

  userdata 是一种用户自定义数据，用于表示一种由应用程序或 C/C++ 语言库所创建的类型，可以将任意 C/C++ 的任意数据类型的数据（通常是 struct 和 指针）存储到 Lua 变量中调用。

4.变量

变量类型

• 全局变量: 所有变量均为全局变量，在函数中或者语句块中定义的变量也是全局变量
• 局部变量: 使用local显式声明的变量称为局部变量，局部变量的作用域从声明位置开始至所在语句块结束。

4.1 变量间赋值

  给变量赋值可以改变变量的值，和变量的基本类型。
  Lua可以对多个变量同时赋值，变量列表和值列表用都好隔开，赋值语句右边的值会依次赋给左边的变量

a, b = 10, 2 * x  ===>  a = 10; b = 2 * x

赋值语句Lua会计算右边所有的值然后再去执行赋值操作，可以利用此特性交换变量的值，不需要像C/C++那样需要使用中间变量进行值的交换

x, y = y, x  ===>  swap 'x' for 'y'
a[i], a[j] = a[j], a[i]  ===>  swap 'a[i]' for 'a[j]'

注意

如果变量个数与给定值的个数不一致时，Lua会以变量个数为基础采取如下策略

• 变量个数 > 值的个数 --> 按照变量个数补足nil
• 变量个数 < 值的个数 --> 忽略多余的值

>a, b, c = 0, 1
>print(a, b, c)
>13:45:34.893-234: 0    1    nil

>a, b = a + 1, b + 1, b + 2
>print(a, b)
>13:46:01.732-839: 1    2

>d, e, f = 0
>print(d, e, f)
>13:46:17.848-803: 0    nil    nil

多值赋值常用于交换变量，或者将函数的返回值返回给变量

a, b = f()
f()返回两个值，第一个赋给a，第二个赋给b。

尽可能的使用局部变量，有两个好处：
1.避免命名冲突。
2.访问局部变量的速度比全局变量更快。

4.2 索引

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

t[i]
t.i – 当索引为字符串类型时的一种简化写法
gettable_event(t,i) – 采用索引访问本质上是一个类似这样的函数调用

> site = {}
> site["key"] = "www.runoob.com"
> print(site["key"])
www.runoob.com
> print(site.key)
www.runoob.com

5.循环

5.1 while循环

while(condition)
do
   statements
end

statements(循环体语句) 可以是一条或多条语句，condition(条件) 可以是任意表达式，在 condition(条件) 为 true 时执行循环体语句

5.2 for循环

1.数值for循环

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

var从exp1变化到exp2，每次变化以exp3为步长递增var，并执行一次 “执行体”。exp3是可选的，如果不指定，默认为1。

2.泛型for循环

a = {"one", "two", "three"}
for k, v in ipairs(a) do
    print(k, v)
end 

i是数组索引值，v是对应索引的数组元素值。ipairs是Lua提供的一个迭代器函数，用来迭代数组。

5.3 repeat…until循环

  repeat...until循环语句不同于for和while循环，for 和 while 循环的条件语句在当前循环执行开始时判断，而 repeat...until循环的条件语句在当前循环结束后判断，相当于C/C++中的do{ }while()循环。

repeat
   statements
until( condition )

循环条件判断语句（condition）在循环体末尾部分，所以在条件进行判断前循环体都会执行一次。
如果条件判断语句（condition）为 false，循环会重新开始执行，直到条件判断语句（condition）为 true 才会停止执行。

5.4 循环嵌套

Lua 编程语言中 for 循环嵌套语法格式:

for init,max/min value, increment
do
   for init,max/min value, increment
   do
      statements
   end
   statements
end

Lua 编程语言中 while 循环嵌套语法格式:

while(condition)
do
   while(condition)
   do
      statements
   end
   statements
end

Lua 编程语言中 repeat…until 循环嵌套语法格式:

repeat
   statements
   repeat
      statements
   until( condition )
until( condition )

5.5 goto语句

语法格式：goto Label
Label 的格式：:: Label ::

local a = 1
::label:: print("--- goto label ---")

a = a+1
if a < 3 then
    goto label   -- a 小于 3 的时候跳转到标签 label
end

i = 0
::s1:: do
  print(i)
  i = i+1
end
if i>3 then
  os.exit()   -- i 大于 3 时退出
end
goto s1

有了 goto，我们可以实现 continue 的功能：

for i=1, 3 do
    if i <= 2 then
        print(i, "yes continue")
        goto continue
    end
    print(i, " no continue")
    ::continue::
    print([[i'm end]])
end

6.流程控制

Lua中 0 为 true

if语句

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

if…else语句

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

if…elseif…else 语句

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

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

elseif( 布尔表达式 3)
then
   --[ 在布尔表达式 3 为 true 时执行该语句块 --]
else 
   --[ 如果以上布尔表达式都不为 true 则执行该语句块 --]
end

if嵌套语句

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

7.函数

定义格式

optional_function_scope function function_name( argument1, argument2, argument3..., argumentn)
    function_body
    return result_params_comma_separated
end

optional_function_scope: 该参数是可选的制定函数是全局函数还是局部函数，未设置该参数默认为全局函数，如果你需要设置函数为局部函数需要使用关键字 local。
function_name: 指定函数名称。
argument1, argument2, argument3..., argumentn: 函数参数，多个参数以逗号隔开，函数也可以不带参数。
function_body: 函数体，函数中需要执行的代码语句块。
result_params_comma_separated: 函数返回值，Lua语言函数可以返回多个值，每个值以逗号隔开。

7.1 函数作为参数

myprint = function(param)
   print("这是打印函数 -   ##",param,"##")
end

function add(num1,num2,functionPrint)
   result = num1 + num2
   -- 调用传递的函数参数
   functionPrint(result)
end
myprint(10)
-- myprint 函数作为参数传递
add(2,5,myprint)

7.2 多返回值

接受多返回值时，就可以用到上面说到的多个变量去接收res1, res2,...resn = fun()

function maximum (a)
    local mi = 1             -- 最大值索引
    local m = a[mi]          -- 最大值
    for i,val in ipairs(a) do
       if val > m then
           mi = i
           m = val
       end
    end
    return m, mi
end

print(maximum({8,10,23,12,5}))

7.3 可变参数

  Lua 函数可以接受可变数目的参数，和 C 语言类似，在函数参数列表中使用三点 … 表示函数有可变的参数。

function add(...)  
local s = 0  
  for i, v in ipairs{...} do   --> {...} 表示一个由所有变长参数构成的数组  
    s = s + v  
  end  
  return s  
end  

// 调用
print(add(3,4,5,6,7))  --->25

例如，计算几个数的平均值：

function average(...)
   result = 0
   local arg={...}    --> 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))

也可以通过 select("#",…) 来获取可变参数的数量:

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

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

有时候可能需要几个固定参数加上可变参数，固定参数必须放在变长参数之前:

function fwrite(fmt, ...)  ---> 固定的参数fmt
    return io.write(string.format(fmt, ...))    
end

fwrite("runoob\\n")       --->fmt = "runoob", 没有变长参数。  
fwrite("%d%d\\n", 1, 2)   --->fmt = "%d%d", 变长参数为 1 和 2

函数技巧
  通常在遍历变长参数的时候只需要使用 {…}，然而变长参数可能会包含一些 nil，那么就可以用 select 函数来访问变长参数了：select('#', …)或者 select(n, …)

select('#', …) 返回可变参数的长度。
select(n, …) 用于返回从起点 n 开始到结束位置的所有参数列表。

function f(...)
    a = select(3,...)  -->从第三个位置开始，变量 a 对应右边变量列表的第一个参数
    print (a)
    print (select(3,...)) -->打印所有列表参数
end

f(0,1,2,3,4,5)

结果
2
2       3       4       5

do  
    function foo(...)  
        for i = 1, select('#', ...) do  -->获取参数总数
            local arg = select(i, ...); -->读取参数，arg 对应的是右边变量列表的第一个参数
            print("arg", arg);  
        end  
    end  
 
    foo(1, 2, 3, 4);  
end

结果:
arg    1
arg    2
arg    3
arg    4

8.运算符优先级

9.字符串操作

1 字符串全部转为大写字母: string.upper(argument)

2 字符串全部转为小写字母: string.lower(argument)

3 在字符串中替换: string.gsub(mainString,findString,replaceString,num)

mainString 为要操作的字符串， findString 为被替换的字符，replaceString 要替换的字符，num 替换次数（可以忽略，则全部替换），如：

> string.gsub("aaaa","a","z",3);
zzza    3

4 在一个指定的目标字符串中搜索指定的内容(第三个参数为索引),返回其具体位置。不存在则返回 nil: string.find (str, substr, [init, [end]])

> string.find("Hello Lua user", "Lua", 1) 
7    9

5 字符串反转: string.reverse(arg)

> string.reverse("Lua")
auL

6 返回一个类似printf的格式化字符串: string.format(...)

> string.format("the value is:%d",4
以上是关于[Unity] Lua 学习笔记的主要内容，如果未能解决你的问题，请参考以下文章
 
 [Unity] Lua 学习笔记
 [Unity] Lua 学习笔记
 Unity Shader入门精要学习笔记 - 第5章 开始 Unity Shader 学习之旅
 Lua学习笔记之：Lua环境搭建 Windows 不用 visual studio
 unity shader学习笔记 shader基础结构以及Properties面板
 lua学习笔记之-----5行代码完成ID发号器