Lua程序设计 | 基础知识与数值类型

Bertha 。 2023-02-16 04:19 1阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pZWk1aTV8_size_16_color_FFFFFF_t_70_pic_center]

> From《Programming in Lua》 by Roberto Ierusalimschy

### 文章目录 ###

*  Lua简介
 *  基础
 *   *  词法规范
     *  全局变量
     *  局部变量和代码块
     *  控制结构
     *   *  if then else
         *  while
         *  repeat
         *  数值型for
         *  泛型 for
         *  break、return 和 goto
     *  类型和值
     *   *  nil
         *  Boolean
 *  数值
 *   *  数值常量
     *  算术运算
     *  关系运算
     *  数学库
     *   *  伪随机数发生器
         *  取整函数
     *  表示范围
     *  惯例
     *  运算符优先级

--------------------

# Lua简介 #

Lua语言从1993年诞生至今已20余年，是**开源嵌入式脚本语言**领域中一门独树一帜的语言，在包括嵌入式、物联网、游戏、游戏外挂、软件安全、逆向工程乃至机器学习等领域中均具有不可替代的重要地位和极为广泛的应用。近年来，除了游戏领域典型的应用外，包括Redis、Nginx/OpenResty. NMAP、WOW、OpenWRT、PhotoShop 等大量的著名产品也均使用Lua作为其嵌入式脚本引擎，以供开发者进行功能扩展和二次开发等。伴随着移动互联网、DevOps等的迅猛发展，Lua语言在包括热更新、不停机部署等的实现方面也提供了一种现实的解决方案（例如银行等金融应用中某些釆用C语言编写的性能密集型核心交易逻辑）。在Lua语言多年的发展过程中，也有大量的第三方机构对Lua语言进行了多方面的改进和增强，诸如**Lua JIT等的发展也十分迅速。**

除了语言本身的使用外，从语言的实现、原理、设计哲学等角度看，Lua语言也是学习编译原理、虚拟机、脚本引擎等的重要参考和现实依据，可以成为相关领域教科书式的典范,在国外也一直是部分高校计算机专业开展相关课程时的重要学习对象之一。在游戏领域，深入学习Lua语言后进行消化、吸收、优化、重构、增强甚至基于Lua语言的思想重新开发一种脚本语言或一个脚本引擎的例子屡见不鲜；在软件安全领域，基于虚拟机的思想设计出的各类混淆、VM保护产品更是有无数的先例；在各种灰色产业中，Lua语言也同样扮演了更加鲜为人知的重要角色。

Lua语言从一开始就被设计为能与C/C++及其他常用语言开发的软件集成在一起使用的语言，这种设计带来了非常多的好处。一方面，Lua语言不需要在性能、与三方软件交互等C语言已经非常完善的方面重复“造轮子”，可以直接依赖C语言实现上述特性，因而Lua语言非常精简；另一方面，通过引入安全的运行时环境、自动内存管理、良好的字符串处理能力和可变长的多种数据类型，**Lua语言弥补了C语言在非面向硬件的高级抽象能力、动态数据结构、鲁棒性、调试能力等方面的不足**。

Lua语言强大的原因之一就在于它的标准库，这不是偶然，毕竟扩展性本身就是Lua语言的主要能力之一。Lua语言中的许多特性为扩展性的实现提供了支持：动态类型使得一定程度的多态成为了可能，自动内存管理简化了接口的实现（无须关心内存的分配/释放及处理溢出），作为第一类值的函数支持高度的泛化，从而使得函数更加通用。Lua语言除了是一门可扩展的语言外，还是一门胶水语言。Lua语言支持组件化的软件开发方式，通过整合已有的高级组件构建新的应用。这些组件通常是通过C/C++等编译型强类型语言编写的，Lua语言充当了整合和连接这些组件的角色。通常，组件（或对象）是对程序开发过程中相对稳定逻辑的具体底层（如小部件和数据结构）的抽  
象，这些逻辑占用了程序运行时的大部分CPU时间，而产品生命周期中可能经常发生变化的逻辑则可以使用Lua语言来实现。当然，除了整合组件外，Lua语言也可以用来适配和改造组件，甚至创建全新的组件。

诚然，Lua语言并非这个世界上唯一的脚本语言，还有许多其他的脚本语言提供了类似的能力。尽管如此，Lua语言的很多特性使它成为解决许多问题的首选，这些特性如下。

*  **可扩展**：Lua语言具有卓越的可扩展性。Lua的可扩展性好到很多人认为Lua超越了编程语言的范畴，其甚至可以成为一种用于构建领域专用语言的工具包。Lua从一开始就被设计为可扩展的，既支持使用Lua语言代码来扩展,也支持使用外部的C语言代码来扩展。在这一点上有一个很好的例证：Lua语言的大部分基础功能都是通过外部库实现的。我们可以很容易地将Lua与C/C++、Java、C\#和Python等结合在一起使用。
 *  **简明**：Lua语言是一门精简的语言。尽管它本身具有的概念并不多，但每个概念都很强大。这样的特性使得Lua语言的学习成本很低，也有助于减小其本身的大小（其包含所有标准库的Linux 64位版本仅有220 KB ）。
 *  **高效**：Lua语言的实现极为高效。**独立的性能测试说明Lua语言是脚本语言中最快的语言之一**。
 *  **可移植**：Lua语言可以运行在我们听说过的几乎所有平台之上，包括所有的类UNIX操作系统（Linux、FreeBSD 等）、Windows、Android、iOS、OSX、IBM 大型机、游戏终端（PlayStation、Xbox、Wii等）、微处理器（如Arduino）等。针对所有这些平台的  
    源码本质上是一样的，Lua语言遵循ANSI （ISO ）C标准，并未使用条件编译来对不同平台进行代码的适配。因此，当需要适配新平台时，只要使用对应平台下的ISO C编译器重新编译Lua语言的源码就可以了。

诸如Adobe Lightroom、Nmap和魔兽世界等在内的许多应用程序中嵌入式地使用了 Lua语言。这些应用使用Lua语言的C语言API去注册新函数、创建新类型和改变部分运算符的行为，以最终达到将Lua语言用于特定领域的目的。一般情况下，这些应用的用户根本感受不到Lua语言其实是一门被用于特定领域的独立编程语言。例如，Lightroom插件的很多开发者压根儿不知道他们使用的是Lua语言，Nmap的用户也倾向于将Lua语言视为Nmap脚本引擎所使用的语言，魔兽世界的很多玩家也认为Lua语言是这个游戏所独有的。尽管应用场景各异，Lua语言的核心是相同的，接下来的博文中将要讲的编程技巧也都是适用的。

--------------------

# 基础 #

## 词法规范 ##

Lua语言中的标识符（或名称）是由任意字母、数字和下划线组成的字符串（**注意，不能以数字开头**）。

“下划线 + 大写字母”（例如 \_ENV）组成的标识符通常被Lua语言用作特殊用途，应避免将其用作其他用途。

以下是Lua语言的保留字，它们不能被用作标识符：

<table> 
 <thead> 
  <tr> 
   <th align="center">and</th> 
   <th align="center">Break</th> 
   <th align="center">do</th> 
   <th align="center">else</th> 
   <th align="center">elseif</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">end</td> 
   <td align="center">false</td> 
   <td align="center">goto</td> 
   <td align="center">for</td> 
   <td align="center">Function</td> 
  </tr> 
  <tr> 
   <td align="center">if</td> 
   <td align="center">in</td> 
   <td align="center">local</td> 
   <td align="center">nil</td> 
   <td align="center">not</td> 
  </tr> 
  <tr> 
   <td align="center">or</td> 
   <td align="center">repeat</td> 
   <td align="center">return</td> 
   <td align="center">then</td> 
   <td align="center">true</td> 
  </tr> 
  <tr> 
   <td align="center">until</td> 
   <td align="center">while</td> 
   <td align="center"></td> 
   <td align="center"></td> 
   <td align="center"></td> 
  </tr> 
 </tbody> 
</table>

Lua语言对**大小写敏感**，因此AND、And就是两个不同的标识符，不会与保留字and冲突。

Lua语言中**使用两个连续的连字符（–）表示单行注释的开始**，使用**两个连续的连字符加两对连续的左方括号表示长注释或多行注释的开始**（直到两个连续的右括号为止，中间都是注释）。

--[[
    		多行长注释
    ]]

在注释一段代码时，可将这些代码放入–\[\[和–\]\]之间。

--[[
    	print(10)		--> 被注释
    --]]

重新启用只需在首行添加一个连字符即可。

---[[
    	print(10)		--> 10
    --]]

## 全局变量 ##

在Lua语言中，全局变量**无须声明即可使用**，使用未经初始化的全局变量也不会导致错误。当使用未经初始化的全局变量时，得到的结果是nil：

print(b)	--> nil
    b = 10
    print(b)	--> 10

当把nil赋值给全局变量时，Lua会回收该全局变量（就像该全局变量从来没有出现过一样）。Lua语言不区分未初始化变量和被赋值为nil的变量。在上述赋值语句执行后，Lua语言最终会回收该变量占用的内存。

## 局部变量和代码块 ##

**Lua语言中的变量在默认情况下是全局变量**，所有的局部变量在使用前必须声明。与全局变量不同，局部变量的生效范围仅限于声明它的代码块。一个代码块（block）是一个控制结构的主体，或是一个函数的主体，或是一个代码段（即变量被声明时所在的文件或字符串）:

x = 10
    local i = 1			-- 对于代码段来说是局部的
    
    while i <= x do
      local x = i * 2	-- 对于循环体来说是局部的
      print(x)
      i = i + 1			--> 2, 4, 6, 8, 10
    end
    
    if i > 20 then
      local x			-- 对于"then"来说是局部的
      x = 20
      print(x + 2)		-- （如果测试成功会输出22）
    else
      print(x)			--> 10 （全局的）
    end
    
    print(x)			--> 10	(全局的)

请注意，上述示例在交互模式中不能正常运行。因为在交互模式中，每一行代码就是一个代码段（除非不是一条完整的命令）。一旦输入示例的第二行（local i =1）, Lua语言解释器就会直接运行它并在下一行开始一个新的代码段。这样，局部（local）的声明就超出了原来的作用范围。

解决这个问题的一种方式是显式地声明整个代码块，即**将它放入一对do-end中**。一旦输入了 do，命令就只会在遇到匹配的end时才结束，这样Lua语言解释器就不会单独执行每一行的命令。

当需要更好地控制某些局部变量的生效范围时，do程序块也同样有用：

local x1, x2
    do
      local a2 = 2*a
      local d = (b^2 - 4ac) ^ (1/2)
      x1 = (-b + d) / a2
      x2 = (-b - d) / a2
    end				-- 'a2'和'd'的范围在此结束
    
    print(x1, x2)	-- 'x1'和'x2'仍在范围内

尽可能地使用局部变量是一种良好的编程风格，它的优点是：

*  局部变量可以避免由于不必要的命名而造成全局变量的混乱
 *  局部变量还能避免同一程序中不同代码部分中的命名冲突
 *  访问局部变量比访问全局变量更快
 *  局部变量会随着其作用域的结束而消失,从而使得垃圾收集器能够将其释放

局部变量的声明可以包含初始值，其赋值规则与常见的多重赋值一样：多余的值被丢弃，多余的变量被赋值为nil。如果一个声明中没有赋初值，则变量会被初始化为nil：

local foo = foo
    local a, b = 1, 10
    if a < b then
      print(a)			--> 1
      local a			--'= nil'是隐式的
      print(a)			--> nil
    end					-- 结束'then'开始的代码块
    
    print(a, b)			--> 1		10

Lua语言中有一种常见的用法：

local foo = foo

这段代码声明了一个局部变量foo，然后用全局变量foo对其赋初值（局部变量foo只有在声明之后才能被访问）。这个用法在需要提高对foo的访问速度时很有用。当其他函数改变了全局变量foo的值，而代码段又需要保留foo的原始值时，这个用法也很有用。尤其是在进行运行时动态替换时，即使其他代码把print动态替换成了其他函数，在local print = print语句之前的所有代码使用的还都是原先的print函数。

有些人认为在代码块的中间位置声明变量是一个不好的习惯，实际上恰恰相反：我们很少会在不赋初值的情况下声明变量，在需要时才声明变量可以避免漏掉初始化这个变量。此外，**通过缩小变量的作用域还有助于提高代码的可读性。**

## 控制结构 ##

Lua语言提供了一组精简且常用的控制结构，包括用于条件执行的if以及用于循环的while、repeat和for。所有的控制结构语法上都有一个显式的终结符：end。用于终结if、for及while结构，until用于终结repeat结构。

控制结构的条件表达式的结果可以是任何值。请记住，Lua语言将所有不是false和nil的值当作真（特别地，Lua语言将0和空字符串也当作真）。

### if then else ###

if语句先测试其条件，并根据条件是否满足执行相应的then部分或else部分。else部分是可选的。

if a < 0 then a = 0 end
    
    if a < b then return a else return b end
    
    if line > MAXLINES then
      showpage()
      line = 0
    end

如果要编写嵌套的if语句，可以使用elseif。它类似于在else后面紧跟一个if，但可以避免重复使用end：

if op == "+" then
      r = a + b
    elseif op == "-" then
      r = a - b
    elseif op == "*" then
      r = a * b
    elseif op == "/" then
      r = a / b
    else
      error("invalid operation")
    end

由于Lua语言不支持switch语句，所以这种一连串的else-if语句比较常见。

### while ###

顾名思义，当条件为真时while循环会重复执行其循环体。Lua语言先测试while语句的条件，若条件为假则循环结束；否则，Lua会执行循环体并不断地重复这个过程。

local i = 1
    while a[i] do
      prlnt(a[i])
      i = i + 1
    end

### repeat ###

顾名思义，repeat-until语句会重复执行其循环体直到条件为真时结束。由于条件测试在循环体之后执行，所以循环体至少会执行一次。

-- 输出第一个非空的行
    local line
    repeat
    	line = io.read()
    until line ~= ""
    print(line)

和大多数其他编程语言不同，在Lua语言中，循环体内声明的局部变量的作用域包括测试条件：

-- 使用Newton-Raphson法计算‘X’的平方根
    local sqr = x / 2
    repeat
      sqr = (sqr + x/sqr) / 2
      local error = math.abs(sqr^2 - x)
    until error < x/10000			-- 局部变量'error'此时仍然可见

### 数值型for ###

for语句有两种形式：数值型for和泛型for。

数值型for的语法如下：

for var = exp1, exp2, exp3 do
    	something
    end

在这种循环中，var的值从exp1变化到exp2之前的每次循环会执行something，并在每次循环结束后将步长(step) exp3增加到var上。第三个表达式exp3是可选的，若不存在，Lua语言会默认步长值为1。

如果不想给循环设置上限，可以使用常量math.huge：

for i = 1, math.huge do
    	if (0.3*i^3 - 20*i^2 - 500 >= 0) then
    		print(i)
    		break
    	end
    end

为了更好地使用for循环，还需要了解一些细节。首先，在循环开始前，三个表达式都会运行一次；其次，控制变量是被for语句自动声明的局部变量，且其作用范围仅限于循环体内。一种典型的错误是认为控制变量在循环结束后仍然存在：

for i = 1, 10 do print(i) end
    max = i		-- 可能会出错! 此处的'i'是全局的

如果需要在循环结束后使用控制变量的值（通常在中断循环时），则必须将控制变量的值保存到另一个变量中:

-- 在一个列表中寻找一个值
    local found = nil
    for i = 1, #a do
      if a[i] < 0 then
        found = i -- 保存'i'的值
        break
      end
    end
    print(found)

最后，不要改变控制变量的值，随意改变控制变量的值可能产生不可预知的结果。如果要在循环正常结束前停止for循环，那么可以参考上面的例子，使用break语句。

### 泛型 for ###

泛型for遍历迭代函数返回的所有值，例如我们已经在很多示例中看到过的pairs、ipairs和io.lines等。虽然泛型for看似简单，但它的功能非常强大。使用恰当的迭代器可以在保证代码可读性的情况下遍历几乎所有的数据结构。

当然，我们也可以自己编写迭代器。尽管泛型for的使用很简单，但编写迭代函数却有不少细节需要注意。我们会在后续的博文中继续讨论该问题。

与数值型for不同，泛型for可以使用多个变量，这些变量在每次循环时都会更新。当第一个变量变为nil时，循环终止。像数值型for一样，控制变量是循环体中的局部变量，我们也不应该在循环中改变其值。

### break、return 和 goto ###

break和return语句用于从当前的循环结构中跳出，goto语句则允许跳转到函数中的几乎任何地方。

我们可以使用break语句结束循环，该语句会中断包含它的内层循环（例如for、repeat或者while ）；该语句不能在循环外使用。break中断后，程序会紧接着被中断的循环继续执行。

return语句用于返回函数的执行结果或简单地结束函数的运行。所有函数的最后都有一个隐含的return，因此我们不需要在每一个没有返回值的函数最后书写return语句。

按照语法，return只能是代码块中的最后一句：换句话说，它只能是代码块的最后一句，或者是end、else和until之前的最后一句。例如，在下面的例子中，return是then代码块的最后一句：

local i = 1
    while a[i] do
      if a[i] == v then return i end
      i = i + 1
    end

通常，这些地方正是使用return的典型位置，return之后的语句不会被执行。不过，有时在代码块中间使用return也是很有用的。例如，在调试时我们可能不想让某个函数执行。在这种情况下，可以显式地使用一个包含return的do：

function foo （）
    	return					--<< SYNTAX ERROR
      --'return'是下一个代码块的最后一句
      do return end		-- OK
      other statements
    end

goto语句用于将当前程序跳转到相应的标签处继续执行。goto语句一直以来备受争议，至今仍有很多人认为它们不利于程序开发并且应该在编程语言中禁止。不过尽管如此，仍有很多语言出于很多原因保留了 goto语句。goto语句有很强大的功能，只要足够细心，我们就能够利用它来提高代码质量。

在Lua语言中，goto语句的语法非常传统，即保留字goto后面紧跟着标签名，标签名可以是任意有效的标识符。标签的语法稍微有点复杂，即标签名称前后各紧跟两个冒号，形如::name::。这个复杂的语法是有意而为的，主要是为了在程序中醒目地突出这些标签。

在使用goto跳转时，Lua语言设置了一些限制条件。

*  首先，标签遵循常见的可见性规则，因此不能直接跳转到一个代码块中的标签（因为代码块中的标签对外不可见）
 *  其次，goto不能跳转到函数外（注意第一条规则已经排除了跳转进一个函数的可能性）
 *  最后，goto不能跳转到局部变量的作用域

## 类型和值 ##

Lua语言是一种**动态类型语言**，在这种语言中没有类型定义，每个值都带有其自身的类型信息。

Lua语言中有8种基本类型：nil（空）、boolean（布尔）、number（数值）、string（字符串）、userdata（用户数据）、function（函数）、thread（线程）、table（表）。使用函数type可以获取一个值对应的类型名称：

local coor = coroutine.create(function() print("") end)
    print(type(nil))            --> nil
    print(type(true))           --> boolean
    print(type(10.4 * 3))       --> number
    print(type("Hello World"))  --> string
    print(type(io.stdin))       --> userdata
    print(type(print))          --> function
    print(type(coor))           --> thread
    print(type({}))             --> table
    print(type(type(X)))        --> string

userdata类型允许把任意的C语言数据保存在Lua语言变量中。在Lua语言中，用户数据类型除了赋值和相等性测试外，没有其他预定义的操作。用户数据被用来表示由应用或C语言编写的库所创建的新类型。例如，标准I/O库使用用户数据来表示打开的文件。

变量没有预定义类型，任何变量都可以包含任何类型的值：

print(type(a))		--> nil
    a = 10
    print(type(a))		--> number
    a = "a string!!"
    print(type(a))		--> string
    a = nil
    print(type(a))		--> nil

接下来我们介绍两种简单类型：nil和boolean，在后续章节对其他的类型进行详细介绍。

### nil ###

nil是一种只有以一个nil值的类型，它的主要作用就是与其他所有值进行区分。Lua语言使用nil来表示无效值的情况。

类似于我们之前介绍的，一个全局变量在第一次被赋值前的默认值就是nil，而将nil赋值给全局变量则相当于将其删除。

### Boolean ###

Boolean具有两个值：true和false，它们分别代表了传统的布尔值。不过，在Lua语言中，Boolean值并非是用于条件测试的唯一方式，任何值都可以表示条件。在Lua语言中，条件测试将除Boolean值false和nil以外的所有其他值都是为真。特别的是，在条件检测中Lua语言把零和空字符串也都视为真。

Lua语言支持常见的逻辑运算符：and、or和not。

print(4 and 5)				--> 5
    print(nil and 13)			--> nil
    print(false and 13)			--> false
    print(0 or 5)				--> 0
    print(false or "hi")		--> "hi"
    print(nil or false)			--> false

and和or都遵循短路求值的原则，即只在必要时才会对第二个操作数进行求值。

在Lua语言中，形如x = x or v的惯用写法非常有用，它等价于：

if not x then x = v end

即当x为被初始化时，将其默认值设为v（假设x不是Boolean类型的false）

当b不为fasle时，下面代码段等价于C语言的三目运算符a?b:c。

((a and b) or c) 或 (a and b or c)  --> and的运算符优先级高于or

not运算符永远返回Boolean类型的值：

print(not nil)			--> true
    print(not false)		--> true
    print(not 0)			--> false
    print(not not 1)		--> true
    print(not not nil)		--> false

# 数值 #

## 数值常量 ##

从Lua 5.3版本开始，Lua语言为数值格式提供了两种选择：被称为integer的64位整型和被称为float的双精度浮点类型。

我们可以使用科学计数法（一个可选的十进制部分外加一个可选的十进制指数部分）书写数值常量。

4					--> 4
    0.4					--> 0.4
    4.57e-3				--> 0.00457
    0.3e12				--> 300000000000.0
    5E+20				--> 5e+20

具有十进制小数或者指数的数值会被当作浮点型值，否则会被当作整型值。

整型值和浮点型值的类型都是“number”：

type(3)		-->	number
    type(3.5)	-->	number
    type(3.0)	-->	number

由于整型值和浮点型值的类型都是“number”，所以它们是可以相互转换的。同时，具有相同算术值的整型值和浮点型值在Lua语言中是相等的：

1 == 1.0			--> true
    -3 == -3.0			--> true
    0.2e3 == 200		--> true

在少数情况下，当需要区分整型值和浮点型值时，可以使用函数math.type:

math.type(3)		--> integer
    math.type(3.0)		--> float

Lua语言像其他语言一样也支持以0x开头的十六进制常量。与其他很多编程语言不用，Lua还支持十六进制的浮点数，这种十六进制浮点数由小数部分和以p或P开头的指数部分组成。例如：

0xff			--> 255
    0x1A3			--> 419
    0x0.2			--> 0.125
    0x1p-1			-->	0.5
    0xa.bp2			--> 42.75

可以使用%a参数，通过函数string.format对这种格式进行格式化输出：

string.format("%a", 419)			--> 0x1.a3p+8
    string.format("%a", 0.1)			--> 0x1.999999999999ap-4

## 算术运算 ##

除了加、减、乘、除、取反等常见的算术运算外，Lua语言还支持取整除法（floor除法）、取模和指数运算。

当操作数一个是整型值，一个是浮点型值时，Lua语言会在进行算术运算前先将整型值转换为浮点型值：

13.0 + 25		--> 38.0
    -(3 * 6.0)		--> -18.0

Lua 5.3针对整数除法引入了一个称为floor除法的新算术运算符//。floor除法会对得到的商向负无穷取整，从而保证结果是一个整数。floor除法与其他算数运算遵循同样的规则：如果操作数都是整型值，那么结果就是整型值，否则就是浮点型值（其值是一个整数）。

3 // 2				--> 1
    3.0 // 2			--> 1.0
    6 // 2				--> 3
    6.0 // 2.0			--> 3.0
    -9 // 2				--> -5
    1.5 // 0.5			-->	3.0

以下公式是取模运算的定义：

a % b == a - ((a // b) * b)

对于实数类型的操作数而言，取模运算有一些不同。例如，x - x % 0.01恰好是x保留两位小数的结果，x - x % 0.001恰好是x保留三位小数的结果：

x = math.pi
    x - x % 0.01		--> 3.14
    x - x % 0.001		--> 3.141

Lua语言同样支持幂运算，使用符号^表示。像除法一样，幂运算的操作数也永远是浮点类型。

x ^ 0.5			--> x的平方根
    x ^ (1/3)		--> x的立方根

## 关系运算 ##

Lua语言提供了下列关系运算：

< > <= >= == ~=

这些关系运算的结果都是Boolean类型。

==用于相等性测试，~=用于不等性测试。这两个运算符可以用于任意两个值，当这两个值的类型不同时，Lua语言认为它们是不相等的；否则，会根据它们的类型再对两者进行比较。

比较数值时应永远忽略数值的子类型，数值究竟是以整型还是浮点型类型表示并无区别，只与算术值有关。

## 数学库 ##

Lua语言提供了标准数学库math。标准数学库由一组标准的数学函数组成，包括三角函数（sin、cos、tan、asin等）、指数函数、取整函数、最大和最小函数max和min、用于生成伪随机数的伪随机数函数（random）以及常量pi和huge（最大可表示数值，在大多数平台上代表inf）。

所有的三角函数都以弧度为单位，并通过函数deg和rad进行角度和弧度的转换。

### 伪随机数发生器 ###

函数math.random用于生成伪随机数，共有三种调用方式。

*  不带参数调用：该函数将返回一个在\[0,1)范围内均匀分布的伪随机实数。
 *  带有一个整型n调用：该函数将返回一个在\[1,n\]范围内的伪随机整数。例如我们可以通过调用random(6)来模拟掷骰子的结果。
 *  带有两个整型值l和u调用：该函数返回在\[l,u\]范围内的伪随机整数。

函数randomseed用于设置伪随机数发生器的种子，该函数的唯一参数就是数值类型的种子。在一个程序启动时，系统固定使用1为种子初始化伪随机数发生器。如果不设置其他的种子，那么每次程序运行时都会生成相同的伪随机数序列。

通常调用math.randomseed(os.time())来使用当前系统时间作为种子初始化随机数发生器。

### 取整函数 ###

数学库提供了三个取整函数：floor、ceil和modf。

*  floor：向负无穷取整（向下取整）
 *  ceil：向正无穷取整（向上取整）
 *  modf：向零取整

math.floor(3.3)			--> 3
    math.floor(-3.3)		--> -4
    math.ceil(3.3)			--> 4
    math.ceil(-3.3)			--> -3
    math.modf(3.3)			--> 3 	0.3
    math.modf(-3.3)			--> -3	-0.3

如果想将数值x向最近的整数取整，可以对x+0.5调用floor函数。不过，当参数是一个很大的整数时，简单的加法可能会导致错误。例如：

x = 2 ^ 52 + 1
    print(string.format("%d %d", x, math.floor(x + 0.5)))
    --> 4503599627370497 4503599627370498

2^52 + 1.5的浮点值表示时不精确的，因此内部会以不可控的方式取整。为了避免这个问题，我们可以单独处理整数值：

function round(x)
      local	f = math.floor(x)
      if x == f then return f
      else return math.floor(x + 0.5)
      end
    end

## 表示范围 ##

**标准Lua使用64个比特位来存储整型值**，其最大值为2^63 - 1，约等于10^19。数学库中的常量定义了整型值的最大值（math.maxinteger）和最小值（math.mininteger）。当我们在整型操作时出现比mininteger更小或者比maxinteger更大的数值时，结果就会回环。

math.maxinteger + 1 == math.mininteger				--> true
    math.mininteger - 1 == math.maxinteger 				--> true
    -math.mininteger == math.mininteger					--> true
    math.mininteger // -1 == math.mininteger			--> true

最大可以表示的整数是0x7ff…fff，即除最高位（符号位，零为非负数值）外其余比特位均为1，当我们对0x7ff…fff加1时，其结果便为0x800…000，即最小可表示的整数。最小整数比最大整数的表示幅度大1:

math.maxinteger          --> 9223372036854775807
    0x7fffffffffffffff       --> 9223372036854775807
    math.mininteger   	     --> -9223372036854775808
    0x8000000000000000       --> -9223372036854775808

## 惯例 ##

我们可以简单地通过增加0.0的方法将整型值强制转换为浮点型值，一个整型值总是可以被转换成浮点型值：

-3 + 0.0								--> -3.0
    0x7fffffffffffffff + 0.0				--> 9.2233720368548e+18

小于2^53（即9007199254740992）的所有整型值的表示与双精度浮点型值的表示一样，对于绝对值超过了这个值的整型值而言，在将其强制转换为浮点型值时可能导致精度损失：

9007199254740991 + 0.0 == 9007199254740991			--> true
    9007199254740992 + 0.0 == 9007199254740992 			--> true
    9007199254740993 + 0.0 == 9007199254740993 			--> false

通过与零进行按位或运算，可以把浮点型值强制转换为整型值：

2 ^ 53			--> 9.007199254741e+15	(浮点型值)
    2 ^ 53 | 0		--> 9007199254740992	 （整型值）

在将浮点型值强制转换为整型值时，Lua语言会检查数值是否与整型值表示完全一致，即没有小数部分且其值在整型值的表示范围内，如果不满足条件则会抛出异常：

3.2 | 0				--> 小数部分
    stdin:1: number has no integer representation
    
    2^64 | 0			--> 超出范围
    stdin:1: number has no integer representation
    
    math.random(1, 3.5)
    stdin:1: bad argument #2 to 'random' (number has no integer representation)

对小数进行取整必须显式地调用取整函数。

另一种把数值强制转换为整型值的方式是使用函数math.tointeger，该函数会在输入参数无法转换为整型值时返回nil：

math.tointeger(-258.0)		--> -258
    math.tointeger(2 ^ 30)		--> 1073741824
    math.tointeger(5.01)		--> nil		(不是整数值)
    math.tointeger(2 ^ 64)		--> nil		(超出范围)

该函数在需要检查一个数字能否被转换成整型值时尤为有用。例如，以下函数在可能时会将输入参数转换为整型值，否则保持原来的值不变：

function cond2int(x)
      return math.tointeger(x) or x
    end

## 运算符优先级 ##

Lua语言中的运算符优先级如下（优先级从高到低）：

^
    一元运算符（-		#		~		not）
    *		/		//		%
    +		-
    ··					（连接）
    <<	>>				（按位移位)
    &					（按位与）
    ~					（按位异或）
    |					（按位或）
    <		>		<=		>=		~=		==
    and
    or

在二元运算符中，除了幂运算和连接操作符是右结合外，其他运算符都是左结合的。因此，以下各个表达式的左右两边等价：

a + i < b / 2 + 1				<==>			(a + i) < ((b / 2) + 1)		
    5 + x ^ 2 * 8					<==>			5 + ((x ^ 2) * 8)		
    a < y and y <= z 				<==>			(a < y) and (y <= z) 
    -x ^ 2							<==>			-(x ^ 2)
    x ^ y ^ z						<==>			x ^ (y ^ z)

当不能确定某些表达式的运算符优先级时，应该显式地用括号来指定所希望的运算次序，这样代码的可阅读性也更高。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pZWk1aTV8_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200612223527123.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1pZWk1aTV8=,size_16,color_FFFFFF,t_70#pic_center