lua的类型与值

| 分类 lua  | 标签 lua 

本文为xiedantibu在学习lua程序设计的笔记 ，转载请注明作者及出处！ ###目录 —-     type()-返回类型名称
    nil(空)
    boolean(布尔)
    number(数字)
    string（字符串）
    table（表）
    function（函数）
    userdata（自定义类型）和thread（线程）

####type()-返回类型名称 — 在Lua中有8种基础类型：nil(空)、boolean(布尔)、number(数字)、string(字符串)、userdata(自定义类型)、function(函数)、thread(线程)和tabel(表)

函数type可根据一个值返回其类型名称。

  1. b=nil
  2. print(b)              		--nil
  3. print(type("hello"))  		--string
  4. print(type(10.4*3))   		--number
  5. print(type(print))    		--function
  6. print(type(type))     		--function
  7. print(type(true))     		--boolean
  8. print(type(nil))      		--nil
  9. print(type(type(x)))  		--string 
  10. print(type(a))        		--nil(a 尚未初始化)
  11. a=10
  12. print(type(a))        		--number
  13. a="a string!!"
  14. print(type(a))        		--string
  15. a=print               		--lua的变量没有预定义的类型，任何变量都可以包含任何类型的值
  16. a(type(a))            		--function --- <a id='nil' name='nil'> </a> ####[nil-空](#top) --- nil是一种类型，只有一个值nil.他主要功能是用于区别其他任何值(无效值)。全局变量在第一次赋值前的默认值是nil,将nil赋值于一个全局变量等同于删除他

####boolean(布尔) — boolean类型有两个可选值：false和true。lua将值false和nil视为假,而将除此之外的其他值视为真。将数字0和空字符串也都视为真

####number(数字) — number类型用于表示实数。Lua没有整数类型，Lua中的数字可以表示任何32位整数，而不产生四舍五入的错误。

####string(字符串) — Lua中的字符串通常表示“一个字符序列”。Lua完全采用8位编码,任何二进制数据存储到一个字符串中。
Lua的字符串是不可变的值。不能像C语言中那样直接修改字符串的某个字符，而是应该根据修改要求来创建一个新的字符串，如：

a=”one string” 
  1. b=string.gsub(a,"one","another");
  2. print(a)              --one string（原来的string 还是没有变化）
  3. print(b)              --another string

#####字符串的表示形式.

Lua的字符串和其它对象(如table或者函数)都是自动内存管理机制所管理的对象，无须担心字符串的内存分配和释放。
字母字符串需要以一对匹配的单引号或者双引号来界定，如：

  1. a="a line"
  2. b='another line' 还可以用一对匹配的双方括号来界定一个字母字符串，就像写“块注释”那样，以这种形式书写的字符串可以延伸多行。如果字符串的第一个字符是一个换行字符，那么Lua就好忽略。如：
  4. local page = [[
  6.  <html>
  7.       <head>
  8.            <title>xiedantibu</title>
  9.       </head>
  10.       <body>
  11.            <a href="http://blog.xulingmin.com">lua</a>
  12.       </body>
  13.  </html>
  14. ]]
  15. print(page)     有时字符串可能需要包含这样的内容：a=b[c[i]]。或者，可能需要保护已经被注释掉的代码。为了应付这种情况，需要在两个左方括号间加上任意数量的等好，就像`[===[`,右方括号加上相等数量的等号`]===]`,这样就可以在不加转义的情况下，直接嵌入任意的字符串内容。同样的道理，注释也可以这样。如以`--[=[`开始，`]=]`结束。 #####数子与字符串的转换.

Lua在设计的时候提供了运行的时数字和字符串的自动转换:

  1. print("10"+1)          --11
  2. print("10+1")          --10+1
  3. print("-5.3e-10"*"2")  --1.06e-09
  4. print("hello"+1)       --报错(不能转换"hello")

自动转换虽好，但可能我们期望一个字符串却得到一个数字时，字符串和数字是两样不同的东西。比较运算10==“10”总为false,因为10为一个数字，而“10”是一个字符串。

######字符串转换成数字

  1. line=io.read()             --读取一行
  2. n=tonumber(line)           --尝试将它转换成一个数字，失败返回nil
  3. if n==nil then
  4.    		error(line .. " is not a valid number")
  5.  	else
  6. 	print(n*2)
  7. end ######数字转换成字符串
  9. print(10 == "10")             --false
  10. print(tostring(10) == "10")   --true
  11. print(10 .. "" == "10")       --true(".."是字符串连接操作符。当直接在一个数字后面输入他的时候，必须要一个空格来分隔它们) ######获取该字符串的长度 在字符串前放置操作符“#”来获得该字符串的长度：
  13. a="hello"
  14. print(#a)              --5
  15. print(#"good\0bye")    --8 --- <a id='table' name='table'> </a> ####[table(表)](#top) --- table类型实现了“关联数组”。“关联数组”是一种特殊索引方式的数组。不仅可以通过整数来索引它，还可以使用字符串或其他类型的值(除了nil)来索引它。同时，table没有固定的大小，可以动态的添加任意数量的元素到一个tabel中。   在Lua中，table既不是“值”，也不是“变量”，而是对象。可以将table想象成一种动态分配的对象，程序仅持有一个它们的引用（指针）。table的创建是通过“构造表达式”完成的，最简单的构造表达式就是{}。   
  17. local a = {}            --创建一个table,并将它的引用存储到a
  18. k = 'x'
  19. a[k] = 10               --新条目，key="x",value=10
  20. a[20] = 'great'         
  21. print(a['x'])           --10
  22. k=20
  23. print(a[k])             --'great'
  24. a['x']=a['x']+1
  25. print(a['x'])           --11

table永远是匿名的，一个引用table的变量与table自身之间没有固定的关联性，例如以下代码：

  1. local a = {}            --创建一个table,并将它的引用存储到a
  2. a['x'] = 10
  3. b = a 					--b与a引用了同一个table
  4. print(b['x'])           --10
  5. b['x'] = 20
  6. print(a['x'])			--20
  7. a=nil                   --现在只有b还在引用table
  8. print(a['x'])           --报错了
  9. b=nil                   --再也没有table的引用，当一个程序再也没有对一个table的引用时，lua的垃圾收集器最终会删除该table 当table的某个元素没有初始化时，它的内容就是nil；另外还可以像全局变量一样，将nil赋予table的某个元素来删除该元素

#####语法糖 在Lua中，a[“name”]这种形式的写法等价于a.name，如：

  1. local a= {}
  2. a.name="xiedantibu"
  3. print(a['name'])          --xiedantibu 等价于a.name a.x和a[x]，前者表示a['x'],表示以字符串'x'来索引table,而后者是以变量x的值来索引table，下面来看例子:  
  5. local a = {}
  6. x='y'
  7. a[x] = 10
  8. print(a[x])         --10 等价于a.y
  9. print(a.x)          --nil 等价于a['x']
  10. print(a.y)          --10  等价于a['y'] 在Lua 5.1中，长度操作符“#”用于返回一个数组或线性表的最后一个索引值。
  12. -- 读取10行内容，并保存到一个table中
  13. local a = {}
  14. for i=1,10 do
  15. 	a[i] = io.read()     --等价于a[#a+1]=io.read
  16. end
  17. -- 打印所有的行
  18. for i=1, #a do
  19. 	print("序号" .. i,a[i])
  20. end
  21. print("================")
  22. print(a[#a])             --打印列表a的最后一个值
  23. a[#a] = nil              --删除最后一个值

数组实际上是一个tabel,所以关于其大小的概念可能会有陷阱啊，以下数组的大小多少呢？

  1. local a={}
  2. a[1000]=1
  3. print(#a)     --0 在Lua中，对于所有未初始化的元素的索引结果都是nil。Lua将nil作为界定数组结尾的标志。当一个数组有“空隙”时，即中间含有nil时，长度操作符会认为这些nil元素就是结尾标记。在上诉例子中因为a[1] = nil，所以，对于上述代码的输出应该是0。所以，在处理table的时候，需要考虑这个问题。那么对于含有nil的table，如何获取它的长度呢？我们可以使用table.maxn，它将返回一个table的最大正索引数：
  5. local a={}
  6. a[1000]=1
  7. print(table.maxn(a))     --1000 --- <a id='function' name='function'> </a> ####[function-函数](#top) --- 在Lua中，函数是作为‘第一类值’来看待。这表示函数可以存储在变量中通过参数传递给其他函数，当然也可以作为其他函数的返回值。	 Lua既可以调用以自身Lua语言编写的函数，也可以调用以C语言编写的函数。Lua中所有的标准库都是用C语言写的。

####userdata-自定义类型和thread-线程 — 由于userdata类型可以将任意的C语言数据存储到Lua变量中。在Lua中，这种类型没有太多的预定义操作，只能进行赋值和相等性测试。userdata用于表示一种由应用程序或C语言库所创建的新类型。。
thread主要用于“协同程序”，在之后章节继续学习吧…

####END

青春是一场大雨，即使感冒了，还盼回头再淋一次...image...微笑永远是一个人身上最好看的东西...


PREVIOUS     NEXT