Lua学习(二)

Lua基础学习

      • 7. lua函数
      • 8. lua运算符
        • 8.1 算数运算符
        • 8.2 关系运算符
        • 8.3 逻辑运算符
        • 8.4 其他运算符
      • 9. lua字符串
        • 9.1 字符串格式化
        • 9.2 匹配模式
      • 10. lua数组
      • 11. lua迭代器
        • 11.1 Lua table
      • 12. lua 模块
        • 12.1 加载机制
        • 12.2 C 包

接着上一篇的内容。Lua学习(一)

7. lua函数

函数是对语句和表达式进行抽象的主要方法

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语言函数可以返回多个值,每个值以逗号隔开。

8. lua运算符

8.1 算数运算符

下表列出了 Lua 语言中的常用算术运算符,设定 A 的值为10,B 的值为 20:

操作符 描述 实例
+ 加法 A + B 输出结果 30
- 减法 A - B 输出结果 -10
* 乘法 A * B 输出结果 200
/ 除法 B / A 输出结果 2
% 取余 B % A 输出结果 0
^ 乘幂 A^2 输出结果 100
- 负号 -A 输出结果 -10
// 整除运算符(>=lua5.3) 5//2 输出结果 2

8.2 关系运算符

下表列出了 Lua 语言中的常用关系运算符,设定 A 的值为10,B 的值为 20:

操作符 描述 实例
== 等于,检测两个值是否相等,相等返回 true,否则返回 false (A == B) 为 false。
~= 不等于,检测两个值是否相等,不相等返回 true,否则返回 false (A ~= B) 为 true。
> 大于,如果左边的值大于右边的值,返回 true,否则返回 false (A > B) 为 false。
< 小于,如果左边的值大于右边的值,返回 false,否则返回 true (A < B) 为 true。
>= 大于等于,如果左边的值大于等于右边的值,返回 true,否则返回 false (A >= B) 返回 false。
<= 小于等于, 如果左边的值小于等于右边的值,返回 true,否则返回 false (A <= B) 返回 true。

8.3 逻辑运算符

表列出了 Lua 语言中的常用逻辑运算符,设定 A 的值为 true,B 的值为 false:

操作符 描述 实例
and 逻辑与操作符。 若 A 为 false,则返回 A,否则返回 B。 (A and B) 为 false。
or 逻辑或操作符。 若 A 为 true,则返回 A,否则返回 B。 (A or B) 为 true。
not 逻辑非操作符。与逻辑运算结果相反,如果条件为 true,逻辑非为 false。 not(A and B) 为 true。

8.4 其他运算符

下表列出了 Lua 语言中的连接运算符与计算表或字符串长度的运算符:

操作符 描述 实例
连接两个字符串 a…b ,其中 a 为 "Hello " , b 为 “World”, 输出结果为 “Hello World”。
# 一元运算符,返回字符串或表的长度。 #“Hello” 返回 5

9. lua字符串

字符串是一种基本的数据类型,用于存储文本数据。Lua 中的字符串可以包含任意字符,包括字母、数字、符号、空格以及其他特殊字符。

--- 无论是单引号还是双引号 都是string
s = "nimaho1233"

string.len(s) --- 字符串的长度

9.1 字符串格式化

local sourcestr = "prefix--runoobgoogletaobao--suffix"
print("\n原始字符串", string.format("%q", sourcestr))

-- 截取部分,第4个到第15个
local first_sub = string.sub(sourcestr, 4, 15)
print("\n第一次截取", string.format("%q", first_sub))

-- 取字符串前缀,第1个到第8个
local second_sub = string.sub(sourcestr, 1, 8)
print("\n第二次截取", string.format("%q", second_sub))

-- 截取最后10个
local third_sub = string.sub(sourcestr, -10)
print("\n第三次截取", string.format("%q", third_sub))

-- 索引越界,输出原始字符串
local fourth_sub = string.sub(sourcestr, -100)
print("\n第四次截取", string.format("%q", fourth_sub))
  • %c - 接受一个数字, 并将其转化为ASCII码表中对应的字符
  • %d, %i - 接受一个数字并将其转化为有符号的整数格式
  • %f - 接受一个数字并将其转化为浮点数格式
  • %g(%G) - 接受一个数字并将其转化为%e(%E, 对应%G)及%f中较短的一种格式
  • %q - 接受一个字符串并将其转化为可安全被Lua编译器读入的格式
  • %s - 接受一个字符串并按照给定的参数格式化该字符串
  • %o - 接受一个数字并将其转化为八进制数格式
  • %u - 接受一个数字并将其转化为无符号整数格式
  • %x - 接受一个数字并将其转化为十六进制数格式, 使用小写字母
  • %X - 接受一个数字并将其转化为十六进制数格式, 使用大写字母
  • %e - 接受一个数字并将其转化为科学记数法格式, 使用小写字母e
  • %E - 接受一个数字并将其转化为科学记数法格式, 使用大写字母E
string.find (str, substr, [init, [plain]])
在一个指定的目标字符串 str 中搜索指定的内容 substr,如果找到了一个匹配的子串,就会返回这个子串的起始索引和结束索引,不存在则返回 nil-----init 指定了搜索的起始位置,默认为 1,可以一个负数,表示从后往前数的字符个数。

-----lain 表示是否使用简单模式,默认为 false,true 只做简单的查找子串的操作,false 表示使用使用正则模式匹配。

----- 以下实例查找字符串 "Lua" 的起始索引和结束索引位置:
string.find("Hello Lua user", "Lua", 1) 

string.format(...)
返回一个类似printf的格式化字符串
> string.format("the value is:%d",4)
the value is:4

9.2 匹配模式

  • .(点): 与任何字符配对

  • %a: 与任何字母配对

  • %c: 与任何控制符配对(例如\n)

  • %d: 与任何数字配对

  • %l: 与任何小写字母配对

  • %p: 与任何标点(punctuation)配对

  • %s: 与空白字符配对

  • %u: 与任何大写字母配对

  • %w: 与任何字母/数字配对

  • %x: 与任何十六进制数配对

  • %z: 与任何代表0的字符配对

  • %x(此处x是非字母非数字字符): 与字符x配对. 主要用来处理表达式中有功能的字符(^$()%.[]*±?)的配对问题, 例如%%与%配对

  • [数个字符类]: 与任何[]中包含的字符类配对. 例如[%w_]与任何字母/数字, 或下划线符号(_)配对

  • 单个字符类匹配该类别中任意单个字符;

  • 单个字符类跟一个 ‘*’, 将匹配零或多个该类的字符。 这个条目总是匹配尽可能长的串;

  • 单个字符类跟一个 ‘+’, 将匹配一或更多个该类的字符。 这个条目总是匹配尽可能长的串;

  • 单个字符类跟一个 ‘-’, 将匹配零或更多个该类的字符。 和 ‘*’ 不同, 这个条目总是匹配尽可能短的串;

  • 单个字符类跟一个 ‘?’, 将匹配零或一个该类的字符。 只要有可能,它会匹配一个;

  • %*n*, 这里的 n 可以从 1 到 9; 这个条目匹配一个等于 n 号捕获物(后面有描述)的子串。

10. lua数组

数组,就是相同数据类型的元素按一定顺序排列的集合,可以是一维数组和多维数组。在 Lua 中,数组不是一种特定的数据类型,而是一种用来存储一组值的数据结构。实际上,Lua 中并没有专门的数组类型,而是使用一种被称为 “table” 的数据结构来实现数组的功能。

总结来来说就是 lua中没有数组这里使用的其实是table

-- 创建一个数组
local myArray = {10, 20, 30, 40, 50}

-- 访问数组元素
print(myArray[1])  -- 输出 10
print(myArray[3])  -- 输出 30
function init()
    local myArray = {}
    for i = 1, 10 do
        myArray[i]=i
    end
    for i, v in ipairs(myArray) do
        print(v)
    end
end
--- 初始化

11. lua迭代器

迭代器(iterator)是一种对象,它能够用来遍历标准模板库容器中的部分或全部元素,每个迭代器对象代表容器中的确定的地址

for k, v in pairs(t) do
    print(k, v)
end
上面代码中,k, v为变量列表;pairs(t)为表达式列表。

-----------------------------------
function Iterators()
    local list = {"稳健打团","天意不可违","格局","莎莉","虞姬"}

    for key, value in pairs(list) do
        print(string.format("我是key:%02s 我是value:%s",key,value))
    end
end

Iterators()

11.1 Lua table

table 是 Lua 的一种数据结构用来帮助我们创建不同的数据类型,如:数组、字典等。Lua table 使用关联型数组,你可以用任意类型的值来作数组的索引,但这个值不能是 nil。

-- 初始化表
mytable = {}

-- 指定值
mytable[1]= "Lua"

-- 移除引用
mytable = nil
-- lua 垃圾回收会释放内存

当我们为 table a 并设置元素,然后将 a 赋值给 b,则 a 与 b 都指向同一个内存。如果 a 设置为 nil ,则 b 同样能访问 table 的元素。如果没有指定的变量指向a,Lua的垃圾回收机制会清理相对应的内存。

tables = {}
print(type(tables)) -- 查看table的类型

function TestTable(length)
    local myTable = {}
    for i = 1, length do
        myTable[i] = i*2+1;
        print(myTable[i])
    end
    myTable["tt"] = "恐龙"
    print(myTable["tt"])
end

TestTable(10)


table的方法

table.concat (table [, sep [, start [, end]]])
参数中指定table的数组部分从start位置到end位置的所有元素, 元素间以指定的分隔符(sep)隔开。

table.sort (table [, comp])
对给定的table进行升序排序。

table.insert (table, [pos,] value):
在table的数组部分指定位置(pos)插入值为value的一个元素. pos参数可选, 默认为数组部分末尾.

table.remove (table [, pos])
返回table数组部分位于pos位置的元素. 其后的元素会被前移. pos参数可选, 默认为table长度, 即从最后一个元素删起。	
function TestMethod()
    fruits = {"banana","orange","apple","Watermelon","persimmon"}
    list = {1,2,3,4,5,89,0}
    --print(table.concat(fruits,","))
    --print(table.concat(fruits))

    table.sort(list)
    table.insert(list,10)
    print("排序后")
    for i,v in ipairs(list) do
        print(i,v)
    end
end
TestMethod()

12. lua 模块

模块类似于一个封装库,从 Lua 5.1 开始,Lua 加入了标准的模块管理机制,可以把一些公用的代码放在一个文件里,以 API 接口的形式在其他地方调用,有利于代码的重用和降低代码耦合度。模块是一个table结构所很简单

--- 首先声明一下一个模块并且要和lua文件名一样
model = {}

model.const ="我是常量"

--- 公共函数
function model.fun1()
    print("我是共有函数")
end

--- 私有函数
function fun2()
    print("我是私有函数")
end

function model.fun3()
    fun2()
end
--- 最后需要返回
return model
--- 使用的时候只需要 使用require函数即可

local model =require("models")
print(model.fun3())

12.1 加载机制

对于自定义的模块,模块文件不是放在哪个文件目录都行,函数 require 有它自己的文件路径加载策略,它会尝试从 Lua 文件或 C 程序库中加载模块。require 用于搜索 Lua 文件的路径是存放在全局变量 package.path 中,当 Lua 启动后,会以环境变量 LUA_PATH 的值来初始这个环境变量。如果没有找到该环境变量,则使用一个编译时定义的默认路径来初始化。

12.2 C 包

Lua和C是很容易结合的,使用 C 为 Lua 写包。与Lua中写包不同,C包在使用以前必须首先加载并连接,在大多数系统中最容易的实现方式是通过动态连接库机制

local path = "/luaDownload/lua-5.4.6/lib/libluasocket.so"
local f = loadlib(path, "luaopen_socket")

loadlib 函数加载指定的库并且连接到 Lua,然而它并不打开库(也就是说没有调用初始化函数),反之他返回初始化函数作为 Lua 的一个函数,这样我们就可以直接在Lua中调用他。如果加载动态库或者查找初始化函数时出错,loadlib 将返回 nil 和错误信息。我们可以修改前面一段代码,使其检测错误然后调用初始化函数:

local path = "/luaDownload/lua-5.4.6/lib/libluasocket.so"
-- 或者 path = "C:\\windows\\luasocket.dll",这是 Window 平台下
local f = assert(loadlib(path, "luaopen_socket"))
f()  -- 真正打开库

你可能感兴趣的:(lua,unity,lua,热更新)