Eric's Blog

Lua tables（表）

2008-04-28

Eric Wong

学习笔记

lua

阅读全文
Lua 迭代器

2008-04-20

Eric Wong

学习笔记

lua
- 泛型 for 迭代器
- 无状态的迭代器
迭代器（iterator）是一种对象，它能够用来遍历标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址

在 Lua 中迭代器是一种支持指针类型的结构，它可以遍历集合的每一个元素。

泛型 for 迭代器

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

泛型 for 迭代器提供了集合的 key/value 对，语法格式如下：
```
for k, v in pairs(t) do
    print(k, v)
end
```
上面代码中，k, v 为变量列表；pairs(t)为表达式列表。

查看以下实例:
```
array = {"Lua", "Tutorial"}

for key,value in ipairs(array)
do
   print(key, value)
end
```
以上代码执行输出结果为：
```
1  Lua
2  Tutorial
```
以上实例中我们使用了 Lua 默认提供的迭代函数 ipairs。

下面我们看看范性 for 的执行过程：
- 首先，初始化，计算 in 后面表达式的值，表达式应该返回范性 for 需要的三个值：迭代函数、状态常量、控制变量；与多值赋值一样，如果表达式返回的结果个数不足三个会自动用 nil 补足，多出部分会被忽略。
- 第二，将状态常量和控制变量作为参数调用迭代函数（注意：对于 for 结构来说，状态常量没有用处，仅仅在初始化时获取他的值并传递给迭代函数）。
- 第三，将迭代函数返回的值赋给变量列表。
- 第四，如果返回的第一个值为 nil 循环结束，否则执行循环体。
- 第五，回到第二步再次调用迭代函数
在 Lua 中我们常常使用函数来描述迭代器，每次调用该函数就返回集合的下一个元素。Lua 的迭代器包含以下两种类型：
- 无状态的迭代器
- 多状态的迭代器
无状态的迭代器

无状态的迭代器是指不保留任何状态的迭代器，因此在循环中我们可以利用无状态迭代器避免创建闭包花费额外的代价。

每一次迭代，迭代函数都是用两个变量（状态常量和控制变量）的值作为参数被调用，一个无状态的迭代器只利用这两个值可以获取下一个元素。

这种无状态迭代器的典型的简单的例子是 ipairs，他遍历数组的每一个元素。

以下实例我们使用了一个简单的函数来实现迭代器，实现数字 n 的平方：
```
function square(iteratorMaxCount,currentNumber)
   if currentNumber<iteratorMaxCount
   then
      currentNumber = currentNumber+1
   return currentNumber, currentNumber*currentNumber
   end
end

for i,n in square,3,0
do
   print(i,n)
end
```
以上实例输出结果为：
```
1	1
2	4
3	9
```
迭代的状态包括被遍历的表（循环过程中不会改变的状态常量）和当前的索引下标（控制变量），ipairs 和迭代函数都很简单，我们在 Lua 中可以这样实现：
```
function iter (a, i)
    i = i + 1
    local v = a[i]
    if v then
       return i, v
    end
end

function ipairs (a)
    return iter, a, 0
end
```
当 Lua 调用 ipairs(a)开始循环时，他获取三个值：迭代函数 iter、状态常量 a、控制变量初始值 0；然后 Lua 调用 iter(a,0)返回 1,a[1]（除非 a[1]=nil）；第二次迭代调用 iter(a,1)返回 2,a[2]……直到第一个 nil 元素。多状态的迭代器

很多情况下，迭代器需要保存多个状态信息而不是简单的状态常量和控制变量，最简单的方法是使用闭包，还有一种方法就是将所有的状态信息封装到 table 内，将 table 作为迭代器的状态常量，因为这种情况下可以将所有的信息存放在 table 内，所以迭代函数通常不需要第二个参数。

以下实例我们创建了自己的迭代器：
```
array = {"Lua", "Tutorial"}

function elementIterator (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
```
以上实例输出结果为：
```
Lua
Tutorial
```
以上实例中我们可以看到，elementIterator 内使用了闭包函数，实现计算集合大小并输出各个元素。
阅读全文
Lua 数组

2008-04-14

Eric Wong

学习笔记

lua
- 一维数组
- 多维数组
数组，就是相同数据类型的元素按一定顺序排列的集合，可以是一维数组和多维数组。

Lua 数组的索引键值可以使用整数表示，数组的大小不是固定的。

一维数组

一维数组是最简单的数组，其逻辑结构是线性表。一维数组可以用 for 循环出数组中的元素，如下实例：
```
array = {"Lua", "Tutorial"}

for i= 0, 2 do
   print(array[i])
end
```
以上代码执行输出结果为：
```
nil
Lua
Tutorial
```
正如你所看到的，我们可以使用整数索引来访问数组元素，如果知道的索引没有值则返回 nil。

在 Lua 索引值是以 1 为起始，但你也可以指定 0 开始。

除此外我们还可以以负数为数组索引值：
```
array = {}

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

for i = -2,2 do
   print(array[i])
end
```
以上代码执行输出结果为：
```
-4
-2
0
2
4
```
多维数组

多维数组即数组中包含数组或一维数组的索引键对应一个数组。

以下是一个三行三列的阵列多维数组：
```
-- 初始化数组
array = {}
for i=1,3 do
   array[i] = {}
      for j=1,3 do
         array[i][j] = i*j
      end
end

-- 访问数组
for i=1,3 do
   for j=1,3 do
      print(array[i][j])
   end
end
```
以上代码执行输出结果为：
```
1
2
3
2
4
6
3
6
9
```
不同索引键的三行三列阵列多维数组：
```
-- 初始化数组
array = {}
maxRows = 3
maxColumns = 3
for row=1,maxRows do
   for col=1,maxColumns do
      array[row*maxColumns +col] = row*col
   end
end

-- 访问数组
for row=1,maxRows do
   for col=1,maxColumns do
      print(array[row*maxColumns +col])
   end
end
```
以上代码执行输出结果为：
```
1
2
3
2
4
6
3
6
9
```
正如你所看到的，以上的实例中，数组设定了指定的索引值，这样可以避免出现 nil 值，有利于节省内存空间。
阅读全文

Lua 字符串

2008-04-08

Eric Wong

学习笔记

lua

字符串操作
字符串操作
- string.upper

字符串或串(String)是由数字、字母、下划线组成的一串字符。

Lua 语言中字符串可以使用以下三种方式来表示：

单引号间的一串字符。
双引号间的一串字符。
[[和]]间的一串字符。

以上三种方式的字符串实例如下：

string1 = "Hello"
print("\"字符串 1 是\"", string1)
string2 = 'lua'
print("字符串 2 是", string2)


string3 = [["Lua 教程"]]
print("字符串 3 是", string3)

以上代码执行输出结果为：

"字符串 1 是"	Hello
字符串 2 是	lua
字符串 3 是	"Lua 教程"

转义字符用于表示不能直接显示的字符，比如后退键，回车键，等。如在字符串转换双引号可以使用 “"“。

所有的转义字符和所对应的意义：

转义字符	意义	ASCII 码值（十进制）
\a	响铃(BEL)	007
\b	退格(BS) ，将当前位置移到前一列	008
\f	换页(FF)，将当前位置移到下页开头	012
\n	换行(LF) ，将当前位置移到下一行开头	010
\r	回车(CR) ，将当前位置移到本行开头	013
\t	水平制表(HT) （跳到下一个 TAB 位置）	009
\v	垂直制表(VT)	011
\	代表一个反斜线字符’’'	092
'	代表一个单引号（撇号）字符	039
"	代表一个双引号字符	034
空字符(NULL)	000
\ddd	1 到 3 位八进制数所代表的任意字符	三位八进制
\xhh	1 到 2 位十六进制所代表的任意字符	二位十六进制

字符串操作

Lua 提供了很多的方法来支持字符串的操作：

字符串大小写转换

以下实例演示了如何对字符串大小写进行转换：

string1 = "Lua";
print(string.upper(string1))
print(string.lower(string1))

以上代码执行结果为：

LUA
lua

字符串查找与反转

以下实例演示了如何对字符串进行查找与反转操作：

string = "Lua Tutorial"
-- 查找字符串
print(string.find(string,"Tutorial"))
reversedString = string.reverse(string)
print("新字符串为",reversedString)

以上代码执行结果为：

5    12
新字符串为   lairotuT auL

字符串格式化

以下实例演示了如何对字符串进行格式化操作：

string1 = "Lua"
string2 = "Tutorial"
number1 = 10
number2 = 20
-- 基本字符串格式化
print(string.format("基本格式化 %s %s",string1,string2))
-- 日期格式化
date = 2; month = 1; year = 2014
print(string.format("日期格式化 %02d/%02d/%03d", date, month, year))
-- 十进制格式化
print(string.format("%.4f",1/3))

以上代码执行结果为：

基本格式化 Lua Tutorial
日期格式化 02/01/2014
0.3333

字符与整数相互转换

以下实例演示了字符与整数相互转换：

-- 字符转换
-- 转换第一个字符
print(string.byte("Lua"))
-- 转换第三个字符
print(string.byte("Lua",3))
-- 转换末尾第一个字符
print(string.byte("Lua",-1))
-- 第二个字符
print(string.byte("Lua",2))
-- 转换末尾第二个字符
print(string.byte("Lua",-2))


-- 整数 ASCII 码转换为字符
print(string.char(97))

以上代码执行结果为：

其他常用函数

以下实例演示了其他字符串操作，如计算字符串长度，字符串连接，字符串复制等：

string1 = "wsdjeg."
string2 = "spacevim"
string3 = ".org"
-- 使用 .. 进行字符串连接
print("连接字符串",string1..string2..string3)


-- 字符串长度
print("字符串长度 ",string.len(string2))


-- 字符串复制 2 次
repeatedString = string.rep(string2,2)
print(repeatedString)

以上代码执行结果为：

连接字符串	wsdjeg.spacevim.org
字符串长度 	8
spacevimspacevim

字符串操作

Lua 提供了很多的方法来支持字符串的操作：

string.upper

字符串全部转为大写字母。

string.upper(argument)

示例：

str1 = "wsdjeg"
print(string.upper(str1))

输出：

WSDJEG

阅读全文

Lua 运算符

2008-03-28

Eric Wong

学习笔记

lua

算术运算符
关系运算符

运算符是一个特殊的符号，用于告诉解释器执行特定的数学或逻辑运算。Lua 提供了以下几种运算符类型：

算术运算符
关系运算符
逻辑运算符
其他运算符

算术运算符

下表列出了 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

实例

我们可以通过以下实例来更加透彻的理解算术运算符的应用：

a = 21
b = 10
c = a + b
print("Line 1 - c 的值为 ", c )
c = a - b
print("Line 2 - c 的值为 ", c )
c = a * b
print("Line 3 - c 的值为 ", c )
c = a / b
print("Line 4 - c 的值为 ", c )
c = a % b
print("Line 5 - c 的值为 ", c )
c = a^2
print("Line 6 - c 的值为 ", c )
c = -a
print("Line 7 - c 的值为 ", c )

以上程序执行结果为：

Line 1 - c 的值为 31
Line 2 - c 的值为 11
Line 3 - c 的值为 210
Line 4 - c 的值为 2.1
Line 5 - c 的值为 1
Line 6 - c 的值为 441
Line 7 - c 的值为 -21

关系运算符

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

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

实例

我们可以通过以下实例来更加透彻的理解关系运算符的应用：

a = 21
b = 10

if( a == b )
then
   print("Line 1 - a 等于 b" )
else
   print("Line 1 - a 不等于 b" )
end

if( a ~= b )
then
   print("Line 2 - a 不等于 b" )
else
   print("Line 2 - a 等于 b" )
end

if ( a < b )
then
   print("Line 3 - a 小于 b" )
else
   print("Line 3 - a 大于等于 b" )
end

if ( a > b )
then
   print("Line 4 - a 大于 b" )
else
   print("Line 5 - a 小于等于 b" )
end

-- 修改 a 和 b 的值
a = 5
b = 20
if ( a <= b )
then
   print("Line 5 - a 小于等于  b" )
end

if ( b >= a )
then
   print("Line 6 - b 大于等于 a" )
end

以上程序执行结果为：

Line 1 - a 不等于 b
Line 2 - a 不等于 b
Line 3 - a 大于等于 b
Line 4 - a 大于 b
Line 5 - a 小于等于 b
Line 6 - b 大于等于 a

阅读全文

Lua 函数

2008-03-20

Eric Wong

学习笔记

lua
- 多返回值
- 可变参数
在 Lua 中，函数是对语句和表达式进行抽象的主要方法。既可以用来处理一些特殊的工作，也可以用来计算一些值。

Lua 提供了许多的内建函数，你可以很方便的在程序中调用它们，如 print()函数可以将传入的参数打印在控制台上。

Lua 函数主要有两种用途：
1. 完成指定的任务，这种情况下函数作为调用语句使用；
2. 计算并返回值，这种情况下函数作为赋值语句的表达式使用。
函数定义

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

以下实例定义了函数 max()，参数为 num1, num2，用于比较两值的大小，并返回最大值：
```
--[[ 函数返回两个值的最大值 --]]
function max(num1, num2)

   if (num1 > num2) then
      result = num1;
   else
      result = num2;
   end

   return result;
end
-- 调用函数
print("两值比较最大值为 ",max(10,4))
print("两值比较最大值为 ",max(5,6))
```
以上代码执行结果为：

Lua 中我们可以将函数作为参数传递给函数，如下实例：
```
myprint = function(param)
   print("这是打印函数 -   ##",param,"##")
end

function add(num1,num2,functionPrint)
   result = num1 + num2
   -- 调用传递的函数参数
   functionPrint(result)
end
myprint(10)
-- myprint 函数作为参数传递
add(2,5,myprint)
```
以上代码执行结果为：

多返回值

Lua 函数可以返回多个结果值，比如 string.find，其返回匹配串”开始和结束的下标”（如果不存在匹配串返回 nil）。
```
> s, e = string.find("www.w3cschool.cn", "w3cschool")
> print(s, e)
5	13
```
Lua 函数中，在 return 后列出要返回的值得列表即可返回多值，如：
```
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}))
```
以上代码执行结果为：

可变参数

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))
```
以上代码执行结果为：
阅读全文

16/19

Lua tables（表）

Lua 迭代器

泛型 for 迭代器

无状态的迭代器

Lua 数组

一维数组

多维数组

Lua 字符串

字符串操作

字符串操作

string.upper

Lua 运算符

算术运算符

关系运算符

Lua 函数

多返回值

可变参数