【1】Lua数据类型

Lua语言共有8种基本类型

[1] nil　　　　空。最简单，有且仅有值nil，表示一个无效值（在条件表达式中相当于false）

[2] boolean　　布尔。包含两个值：false和true

[3] number　　 数字。double（双精度）类型（默认类型可以修改 luaconf.h 里的定义）

[4] string　　 字符串。字符串由一对双引号或单引号来表示

[5] function　 函数。由C或Lua编写的函数

[6] userdata　 自定义类型。表示任意存储在变量中的C数据结构

[7] thread　　 线程。表示执行的独立线程，用于执行协同程序

[8] table　　　表。Lua中的表（table）其实是一个“关联数组”（associative arrays），数组的索引可以是数字或者是字符串。

在Lua里，table的创建是通过“构造表达式”来完成，最简单构造表达式是{}，用来创建一个空表。

【2】各种数据类型示例

（1）各种数据类型

1.1 打印各种数据类型

 print(type("Good Good Study"))  --> string

 print(type(12.34))              --> number

 print(type(print))              --> function

 print(type(type))               --> function

 print(type(true))               --> boolean

 print(type(nil))                --> nil

 print(type(type(X)))            --> string

1.2 打印各种数据类型

 print(type(a))    --> nil

 a =

 print(type(a))    --> number

 a = "Day Day Up"

 print(type(a))    --> string

 a = print

 print(type(a))    --> function

 a(type(a))        --> function

1.3 待续

（2）nil

2.1 nil类型表示一种没有任何有效值，它只有一个值nil。例如：打印一个没有赋值的变量，结果为nil值。

 print(type(X))                  --> nil

2.2 nil 作比较时应该加上双引号：

 print(type(X) == nil)           --> false

 print(type(X) == "nil")         --> true

type(X) == nil结果为false，因为：

 print(type(type(X)))            --> string

2.3 对于全局变量和table，nil还有一个“删除”作用。如下示例：

 luaTable = {, , , , }

 for k, v in pairs(luaTable) do

     print(k .. " - " .. v)

 end

 luaTable[] = nil

 print("After set nil :: ")

 for k, v in pairs(luaTable) do

     print(k .. " - " .. v)

 end

 --[[

 1 - 10

 2 - 20

 3 - 30

 4 - 40

 5 - 50

 After set nil ::

 1 - 10

 3 - 30

 4 - 40

 5 - 50

 --]]

2.4 读入行数据作为数组元素

 --[[读入行 作为数组元素]]

 a = {}

 for i = ,  do

 a[i] = io.read()

 end

 for i, v in pairs(a) do

     print(i .. " ---> " .. v)

 end

 print(a)

 --[[ 执行结果

 10

 11

 12

 13

 14

 1 ---> 10

 2 ---> 11

 3 ---> 12

 4 ---> 13

 5 ---> 14

 ]]

2.5 待续

（3）boolean

3.1 lua语言中nil和false均是属于假，true和其他任何东西都属于真。

C++语言中0、NULL和false均是属于假，true其他任何非空的东西都属于真。

尤其注意：lua中0被视为真。

示例如下：

 print()              --> 0

 print( == false)     --> false

 b = ;

 print(b == true)      --> false

 if( and b) then

     print("0 and b is true")  --> 0 and b is true

 else

     print("0 and b id false")

 end

 if(nil) then

     print("nil is true")

 else

     print("nil is false")  --> nil is false

 end

 print(nil)            --> nil

 print(false == nil)   --> false

 print(true == nil)    --> false

 print(true == "nil")  --> false

 print(false == "nil") --> false

 print(false == "")    --> false

 print( == )     --> true

3.2 待续

（4）number

4.1 待续

（5）string

5.1 字符串由一对双引号或单引号来表示：

 string1 = "this is string1"

 print(string1)    --> this is string1

 string2 = 'this is string2'

 print(string2)    --> this is string2

5.2 除过以上两种表示方式，还可以使用方括号“[[]]”来表示“一块”字符串：

 html = [[

 <html>

 <head></head>

 <body>

     <a href="http://www.baidu.com/">百度首页</a>

 </body>

 </html>

 ]]

 print(html)

 --执行结果：

 --[[

 <html>

 <head></head>

 <body>

     <a href="http://www.baidu.com/">百度首页</a>

 </body>

 </html>

 --]]

5.3 在对一个数字字符串进行算术操作时，Lua会尝试将这个数字字符串转换为一个数字：

 print("" + )      --> 3

 print("" + "")    --> 7

 print("5 + 6")      --> 5 + 6

 print("" * "")    --> 64

 --print("nil" + 1)  --> syntax error

5.4 如上代码中“nil”+ 1执行报错了，字符串连接使用的是 ..，如下所示：

 print("a"..'b'.."cdefg".." ".."hijk")  --> abcdefg hijk

 print( ..  .. )               --> 112110119

5.5 使用 # 来计算字符串的长度，放在字符串前面。如下示例：

 strLength = "www.baidu.com"

 print(#strLength)          --

 print(#"www.baidu.com")    --

 print(#"www.bai\0du.com")  --

 print(#"www.bai\ndu.com")  --

5.6 字符串函数的应用示例

 --1 大小写转换

 --[[

 string.upper(argument)

 string.lower(argument)

 ]]

 str = "abcdefghijklmnopqrstuvwxyz"

 STR = string.upper(str)

 str1 = string.lower(STR)

 print(str)                -- abcdefghijklmnopqrstuvwxyz

 print(string.upper(str))  -- ABCDEFGHIJKLMNOPQRSTUVWXYZ

 print(STR)                -- ABCDEFGHIJKLMNOPQRSTUVWXYZ

 print(str1)               -- abcdefghijklmnopqrstuvwxyz

 --2 在字符串中替换

 --[[

 string.gsub(main string, find string, replace string, num)

 main string 要替换的字符串

 find string 被替换的字符

 relace string 要替换的字符

 num 替换次数 备注：可以忽略，默认是全部替换

 ]]

 str2 = "aaaaaaa"

 print(string.gsub(str2, "a", "b", )) -- bbbaaaa    3

 print(string.gsub(str2, "a", "c"))    -- ccccccc    7

 --3 搜索指定字符串

 --[[

 在一个指定的目标字符串中搜索指定的内容(第三个参数为起始索引)，返回其具体位置。不存在则返回nil。

 ]]

 str3 = "Welcome to Beijing"

 print(string.find(str3, "Beijing"))         -- 12 18

 local index = string.find(str3, "Beijing")

 print(index)                                --

 print(string.find(str3, "Beijing", ))     -- 12 18

 print(string.find(str3, "Beijing", ))     -- nil

 --4 字符串反转

 --[[

 string.reverse(argument)

 ]]

 str4 = "Welcome to xian."

 print(string.reverse(str4))  -- .naix ot emocleW

 --5 格式化字符串

 --[[返回一个类似于printf的格式化字符串

 string.format(...)

 ]]

 str5 = "the value is :: %d"

 print(string.format(str5, ))   -- the value is :: 10

 --6 整型数值与字符相互转换

 --[[将整型数字转成字符并连接string.char(argument)

 将字符转成整型数字值(可以指定某个字符，默认是第一个字符)

 ]]

 print(string.char(, , , ))   -- abcd

 str6 = "ABCDE"

 print(string.byte("ABCD", ))   --

 print(string.byte("ABCD"))      --

 --7 计算字符串长度

 --[[

 string.len(argument)

 ]]

 print(string.len("abcde"))    --

 --8 返回字符串string的n个拷贝

 --[[

 string.rep(string, n)

 ]]

 print(string.rep("abcde ", ))  -- abcde abcde abcde

 --9 链接两个字符串

 --[[

 ..

 ]]

 print("Welcome ".."to ".."Beijing") -- Welcome to Beijing

 --10 gmatch接口

 --[[string.gmatch(str, pattern)

 返回一个迭代器函数，每一次调用这个函数，返回一个在字符串str找到的下一个符合pattern描述的子串。如果参数pattern描述的字符串没有找到，迭代函数返回nil

 ]]

 local str10_1 = "Hello World By Lua"

 for word in string.gmatch(str10_1, "%a+") do

     print(word)

 end

 --[[执行结果

 Hello

 World

 By

 Lua

 ]]

 local str10_2 = "110abc119,def,120,ghij"

 local ret_func_itor = string.gmatch(str10_2, "%d+")

 -- 查看func_itor类型

 print("ret_func_itor is", ret_func_itor) -- func_itor is    function: 02D1DAC8

 -- 第一次调用函数func_itor

 print("ret_func_itor ret is ", ret_func_itor()) -- ret_func_itor ret is     110

 -- 再次调用函数func_itor

 print("ret_func_itor ret is ", ret_func_itor()) -- ret_func_itor ret is     119

 -- 再次调用函数func_itor

 print("ret_func_itor ret is ", ret_func_itor()) -- ret_func_itor ret is     120

 -- 再次调用函数func_itor

 print("ret_func_itor ret is ", ret_func_itor()) -- ret_func_itor ret is

 -- 使用循环来打印

 local str10_3 = "hello world by Lua"

 local index =

 print("\noutput capture using loop:")

 for word in string.gmatch(str10_3, "%a+") do

     print(index, word)

     index = index +

 end

 --[[执行结果

 output capture using loop:

 1    hello

 2    world

 3    by

 4    Lua

 ]]

 -- 查找属性对

 local str10_4 = "from=world, to=Lua, name=kaizen"

 print("\noutput attr pair capture using loop:")

 for k, v in string.gmatch(str10_4, "(%w+)=(%w+)") do

     print(k, v)

 end

 --[[执行结果

 output attr pair capture using loop:

 from    world

 to    Lua

 name    kaizen

 ]]

 local str10_5 = "fadfasd,.;p[];'asd"

 local func_numitor = string.gmatch(str10_5, "%d+")

 local numret = func_numitor()

 print("\nnumret ret is", numret)

 --[[执行结果

 numret ret is    nil

 ]]

5.7 可以通过数值来指定字符串中的字符

 --[[可以通过数值来指定字符串中的字符。

 数值以转义序列“\<ddd>”给出，其中<ddd>是一个至多3个十进制数字组成的序列]]

 print("\97bcdefg\10hijklmn\49")

 --[[执行结果

 abcdefg

 hijklmn1

 ]]

5.8 字符串格式化format函数

 str = string.format("字符串：%s\n整数：%d\n小数：%f\n十六进制数：%X", "zhongguorenmin", , 1.23, )

 print(str)

 --[[

 字符串：zhongguorenmin

 整数：1

 小数：1.230000

 十六进制数：1C8

 ]]

5.9 待续

（6）function

6.1 在Lua中，函数可以存在变量里:

 function factorial1(n)

     if n ==  then

         return

     else

         return n * factorial1(n - )

     end

 end

 print(factorial1())     --> 120

 factorial2 = factorial1

 print(factorial2())     --> 120

6.2 function可以以匿名函数（anonymous function）的方式通过参数传递

 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

 );

 --执行结果

 --[[

 key1 = val1

 key2 = val2

 --]]

6.3 待续

（7）userdata

7.1 待续

（8）thread

8.1 待续

（9）table

9.1 创建一个空表

 --1.创建一个空表

 local tab1 = {}

9.2 初始化表，且遍历表

 --2.直接初始化表

 local tal2 = {"apple", "pear", "orange", "grape"}

 --遍历表

 for k, v in pairs(tal2) do

     print("key", k, ": value", v)

 end

 --执行结果

 --[[

 key    1    : value    apple

 key    2    : value    pear

 key    3    : value    orange

 key    4    : value    grape

 ]]

9.3 关联数组，数组的索引可以是数字或字符串

 array = {}

 array["key"] = "value"

 key = ;

 array[key] =

 array[key] = array[key] + ;

 for k, v in pairs(array) do

     print(k .. " : " .. v)

 end

 --执行结果

 --[[

 key : value

 10 : 31

 --]]

 ar = {}

 for i = ,  do

     ar[i] = i

 end

 ar["key"] = "val"

 print(ar["key"])

 print(ar["none"])

 for k, v in pairs(ar) do

     print(k .. " : " .. v)

 end

 --执行结果

 --[[

 val

 nil

 1 : 1

 2 : 2

 3 : 3

 4 : 4

 5 : 5

 6 : 6

 7 : 7

 8 : 8

 9 : 9

 10 : 10

 key : val

 ]]

9.4 注意观察以上几个示例，Lua里表的初始索引一般以1开始。不同于其他语言把0作为数组的开始索引。

 local tbl = {"apple", "pear", "orange", "grape"}

 for key, val in pairs(tbl) do

     print("Key", key)

 end

 --执行结果

 --[[

 Key    1

 Key    2

 Key    3

 Key    4

 ]]

9.5 表的值置为nil，表示移除引用。

 --当我们定义table a 并设置元素，然后将 a 赋值给 b，则 a 与 b 都指向同一个内存。

 --如果 a 设置为 nil ，则 b 同样能访问 table 的元素。

 --如果没有指定的变量指向a，Lua的垃圾回收机制会清理相对应的内存。

 -- 简单的 table

 mytable = {}

 print("mytable 的类型是 ", type(mytable))

 mytable[] =  "Lua"

 mytable["wow"] = "修改前"

 print("mytable 索引为 1 的元素是 ", mytable[])

 print("mytable 索引为 wow 的元素是 ", mytable["wow"])

 -- alternatetable和mytable的是指同一个 table

 alternatetable = mytable

 print("alternatetable 索引为 1 的元素是 ", alternatetable[])

 print("mytable 索引为 wow 的元素是 ", alternatetable["wow"])

 alternatetable["wow"] = "修改后"

 print("mytable 索引为 wow 的元素是 ", mytable["wow"])

 -- 释放变量

 mytable = nil

 print("mytable 是 ", mytable)

 --print("mytable[1]", mytable[1]) --> syntax error

 -- alternatetable 仍然可以访问

 print("alternatetable 索引为 wow 的元素是 ", alternatetable["wow"])

 alternatetable = nil

 print("alternatetable 是 ", alternatetable)

 --执行结果

 --[[

 mytable 的类型是     table

 mytable 索引为 1 的元素是     Lua

 mytable 索引为 wow 的元素是     修改前

 alternatetable 索引为 1 的元素是     Lua

 mytable 索引为 wow 的元素是     修改前

 mytable 索引为 wow 的元素是     修改后

 mytable 是     nil

 alternatetable 索引为 wow 的元素是     修改后

 alternatetable 是     nil

 ]]

9.6 表操作

[1] concat方法

 --table.concat (table [, sep [, start [, end]]]):

 --concat是concatenate(连锁, 连接)的缩写.

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

 fruits = {"banana","orange","apple"}

 -- 返回 table 连接后的字符串

 print("连接后的字符串 ",table.concat(fruits))

 -- 指定连接字符

 print("连接后的字符串 ",table.concat(fruits, ", "))

 -- 指定索引来连接 table

 print("连接后的字符串 ",table.concat(fruits, ", ", , ))

 --执行结果

 --[[

 连接后的字符串     bananaorangeapple

 连接后的字符串     banana, orange, apple

 连接后的字符串     orange, apple

 --]]

[2] 插入和移除

 --table.insert (table, [pos,] value):

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

 --table.remove (table [, pos])

 --返回table数组部分位于pos位置的元素. 其后的元素会被前移. pos参数可选, 默认为table长度, 即从最后一个元素删起。

 fruits = {"banana", "orange", "apple"}

 -- 在末尾插入

 table.insert(fruits, "mango")

 print("索引为 4 的元素为 ", fruits[])

 -- 在索引为 2 的键处插入

 table.insert(fruits, , "grapes")

 print("索引为 2 的元素为 ", fruits[])

 print("最后一个元素为 ", fruits[])

 table.remove(fruits)

 print("移除后, 最后一个元素为 ", fruits[])

 table.remove(fruits, )

 print("移除后, 索引为 1 的元素为  ", fruits[])

 --[[

 索引为 4 的元素为     mango

 索引为 2 的元素为     grapes

 最后一个元素为     mango

 移除后, 最后一个元素为     nil

 移除后, 索引为 1 的元素为      grapes

 --]]

[3] 排序

 -table.sort (table [, comp])

 --对给定的table进行升序排序。

 --3.1 默认排序示例

 fruits = {"banana", "orange", "apple", "grapes", "melon"}

 print("排序前")

 for k, v in ipairs(fruits) do

     print(k, v)

 end

 --排序

 table.sort(fruits)

 print("排序后")

 for k, v in ipairs(fruits) do

     print(k, v)

 end

 --执行结果

 --[[

 排序前

 1    banana

 2    orange

 3    apple

 4    grapes

 5    melon

 排序后

 1    apple

 2    banana

 3    grapes

 4    melon

 5    orange

 --]]

 --3.2 键值排序

 local test1 = {a = , f = , d = , c = , b = }

 local key_test = {}

 for val in pairs(test1) do

    table.insert(key_test, val)   --提取test1中的键值插入到key_test表中

 end

 table.sort(key_test)

 for i, v in pairs(key_test) do

    print(v, test1[v])

 end

 --执行结果

 --[[

 a    1

 b    5

 c    8

 d    2

 f    9

 ]]

 --3.3 值排序之数组模式

 local test0 = {, , , , , , , }

 table.sort(test0)  --从小到大排序，默认方式

 for i, v in pairs(test0) do

    io.write(v.." ")

 end

 print("");

 table.sort(test0, function(a, b) return a > b end) --从大到小排序

 for i, v in pairs(test0) do

    io.write(v.." ")

 end

 print(" ")

 --[[

 1 2 3 4 6 7 8 9

 9 8 7 6 4 3 2 1

 ]]

 --3.4 值排序之表单模式

 local test2 =

 {

     {id = , name = "zhao"},

     {id = , name = "liu"},

     {id = , name = "wang"},

     {id = , name = "xi"},

     {id = , name = "qin"},

 }

 table.sort(test2, function(a,b) return a.id < b.id end)

 for i in pairs(test2) do

    print(test2[i].id, test2[i].name)

 end

 --[[

 1    zhao

 2    wang

 5    qin

 8    xi

 9    liu

 ]]

[4] 待续

9.7 计算表长度

 fruits = {"banana", "orange", "apple", "grapes", "melon", nil, "peach"}

 print(#fruits)             --> 7

 print(table.getn(fruits))  --> 7

 local myTable1 = {, , }

 print("table1 length :: ", table.getn(myTable1))   --> 3

 local myTable2 = {, a = , }

 print("table2 length :: ", table.getn(myTable2))   --> 2

 print(myTable2.a)             --> 2

 local myTable3 = {[] = , [] = , [] = }

 print("table3 length :: ", table.getn(myTable3))   --> 3

 local myTable4 = {[] = , [] = , [] = }

 print("table4 length :: ", table.getn(myTable4))   --> 4

 local myTable5 = {[] = , [] = , [] = }

 print("table5 length :: ", table.getn(myTable5))   --> 2

 local myTable6 = {, [] = , }

 print("table6 length :: ", table.getn(myTable6))   --> 3

 local myTable7 = {, nil}

 print("table7 length :: ", table.getn(myTable7))   --> 1

 local myTable8 = {, nil, }

 print("table8 length :: ", table.getn(myTable8))   --> 3

 local myTable9 = {, nil, , nil}

 print("table9 length :: ", table.getn(myTable9))   --> 1

 local myTable10 = {, nil, , nil, , nil}

 print("table10 length :: ", table.getn(myTable10))   --> 3

 local myTable11 = {, nil, , nil, , nil, , nil}

 print("table11 length :: ", table.getn(myTable11))   --> 1

Lua里计算表长度可以使用“#”或者getn接口。示例如下：

你看懂了？你看不懂？难道真看不懂？难道我写错了？

唉~  看不懂就对了。。。。我也看不懂。。。待剖析源码。

9.8 表其他待续

（10）总结

每种数据类型都各有特点，掌握得熟练还需多应用与摸索学习。

【3】总结

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

Good Good Study, Day Day Up.

顺序 选择 循环 总结

最新文章

  1. ORACLE优化器RBO与CBO介绍总结
  2. tomcat组成以及工作原理
  3. ios NSLayoutConstraint
  4. Linux Discuz论坛的安装
  5. loj 1055(bfs)
  6. hbase与mapreduce集成
  7. CCocos2Dx 一段遍历子节点的代码
  8. ios即时通讯客户端开发之－mac上搭建openfire服务器
  9. PHP防止SQL注入与几种正则表达式讲解
  10. 使用Filter防止浏览器缓存页面或请求结果
  11. 解决修改SQL SERVER 默认1433端口 访问出错的问题；
  12. 插件GsonFormat快速实现JavaBean
  13. IntelliJ IDEA中创建并运行scala应用程序
  14. Mego(04) - Mego入门
  15. 【爆料】-《阿伯泰大学毕业证书》Abertay一模一样原件
  16. android 资源
  17. [转] Quality Of Service In OpenStack
  18. mongodb学习(入门。。。。。)
  19. 采用VSPD、ModbusTool模拟串口、MODBUS TCP设备进行Python采集软件开发
  20. pyhton之Reportlab模块

热门文章

  1. Aop的基本介绍
  2. 【PyQt5-Qt Designer】QDoubleSpinBox-小数微调框
  3. Jenkins send build artifacts over ssh配置
  4. SSAS下玩转PowerShell
  5. nessus的安装
  6. UnicodeDecodeError异常
  7. 为chrome设置代理
  8. Spark中的partition和block的关系
  9. SQL中查询前几条或者中间某几行数据limit
  10. UML序列图的理解：