Lua中可以用三种方式定义字符串:

  • 单引号 ‘hello world’
  • 双引号 “heool world”
  • [[ ]] [[hello world]]

字符串操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

print(string.upper("hello world")) --HELLO WORLD

--string.lower(str)转小写
print(string.lower("HELLO WORLD")) --hello world

--[[string.gsub(mainStr,findStr,replaceStr,num)字符串替换,返回替换后的字符串和替换的次数
mainStr 整个需要被替换的字符串
findStr 要被替换的部分
replaceStr 新的字符串
要替换的数量,不填就是替换所有
--]]
print(string.gsub("aaaa","a","b",3)) --bbba 3

--string.find()在一个指定的目标字符串中搜索指定的内容(第三个参数为索引,从第几个开始查找),返回其具体位置(从开始的第一个)。不存在则返回 nil
print(string.find("hello world","o",6)) --结果 8 8

--string.reverse()字符串反转
print(string.reverse("hello"))

--string.format() 字符串格式化
print(string.format("the value is:%d",4)) --the value is:4

--string.char()转成字符串 string.byte() 转成整数值(指定某个位置,不知道默认第一个)
print(string.char(97,98,99,100)) -- abcd
print(string.byte("abcd")) --97
print(string.byte("abcd",2)) --98 第二个字母转成整数值

--string.len("abcd") 字符串长度
print(string.len("abcd")) --4
print(#"abcd") --4

--string.rep("",n) 字符串的n次拷贝
print(string.rep("abcd",2)) --abcdabcd

-- .. 字符串拼接
print("abc".."d") --abcd

--string.gmatch(str, pattern) 回一个迭代器函数,每一次调用这个函数,返回一个在字符串 str 找到的下一个符合 pattern 描述的子串
for world in string.gmatch("Hi hello world","%a+") do
print(world)
end
--[[ 结果
Hi
hello
world
--]]

--string.match(str, pattern, init)只寻找源字串str中的第一个配对. 参数init可选, 指定搜寻过程的起点, 默认为1。
print(string.match("I have 2 questions for you.", "%d+ %a+")) --2 questions

Lua数组

一维数组

Lua中数组索引从1开始

1
2
3
4
array = {"hello","world"}
for i=0,2 do
print(array[i])
end

结果:

1
2
3
nil
hello
world

可以以负数作为数组的索引:

1
2
3
4
array = {}
for i = -1,2 do
array[i] = i
end

多维数组

1
2
3
4
5
6
7
local array = {}
for i = 1,3 do
array[i] = {}
for j = 1,3 do
array[i][j] = i * j
end
end

迭代器

泛型for迭代器

1
2
3
for k,v in pairs(table) do
print(k,v)
end

泛型 for 在自己内部保存迭代函数,实际上它保存三个值:迭代函数、状态常量、控制变量

无状态的迭代器

无状态的迭代器是指不保留任何状态的迭代器

多状态的迭代器

可以通过闭包来实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
array = {"Google", "Runoob"}

function (collection)
local index = 0
local count = #collection
-- 闭包函数
return function ()
index = index + 1
if index <= count
then
-- 返回迭代器的当前元素
return collection[index]
end
end
end

for element in elementIterator(array)
do
print(element)
end

table

table 是 Lua 的一种数据结构用来帮助我们创建不同的数据类型,如:数组、字典等。

1
2
3
4
5
6
7
8
9
-- 初始化表
table = {}

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

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

table的操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
t = {"aaa","bbb","ccc"}
--[[
table.concat (t , sep , start , end)
将t的所有元素连接起来,用sep作为连接符
从start开始到end结束
sep,start,end可以不写
--]]
print("concat:",table.concat( t, ", ")) --aaa, bbb, ccc

--[[
table.insert (table, pos, value):
在t的pos位置插入value
pos可以省略,表示在末尾插入
--]]
table.insert(t,"ddd")
print("t[4]:",t[4]) --ddd

--[[
table.remove (t , pos)
删除t的pos位置上的元素
--]]
table.remove(t)
print("t[4]:",t[4]) --nil

--[[
table.sort (t , comp)
给t升序排序
comp可以省略
--]]
tt = {"ddd","fff","xxx","aaa"}
table.sort(tt)
for i,v in ipairs(tt) do
print(i,v)
end
--[[
1 aaa
2 ddd
3 fff
4 xxx
--]]

无论是#还是table.getn都会在索引中断的地方停止计数,所以要自己去table的长度

1
2
3
4
5
6
7
function table_leng(t)
local leng=0
for k, v in pairs(t) do
leng=leng+1
end
return leng;
end