首页手记简单入门Lua编程语言

简单入门Lua编程语言

标签：

大数据 API

最近在学习写Kong的插件，作为新手，首先要学习的就是它所使用的编程语言lua，这个语言主要应用在nginx的开发中，Kong作为一个API网关系统，有时候需要写一些自定义的插件，所以会涉及到lua语言。这篇文章主要记录学习过程中的一些经验，希望对大家的学习有帮助。

Install 安装

学习的第一步，肯定是安装对应的开发环境。Lua的开发环境，在不同的操作系统上有不同的安装方法，比较简单的是在MAC上一条命令就搞定了。

brew install lua

Windows就下载对应的二进制安装包进行安装就好了。

Hello World

安装完环境后，我们来写一个hello world的程序，来测试一下环境是否正常。

新建一个helloworld.lua的文件:

print("Hello World")

在命令行中输入:

lua helloworld.lua

看到输出熟悉的hello world，就证明一切正常。

Comment注释

下来就是语言的基本语法，先学习一下注释的使用。lua语言当中采用的是–作为注释标示符，就像这样:

--- comment

变量声明

作为弱类型语言，在声明变量的时候，我们可以不必去指定它的数据类型。

来看个简单的例子：

name = "scq000"

io.write("Length of name", #name, "\n")

age = 4

io.write("My age is ", age, "\n")

使用io.write函数直接输出对应的变量名等，其中#作为运算符可以获取字符串的长度。

如果要生成一个长字符串，可以使用下面这种写法:

longString = [[
  I am a very long long string that 
  dfsfdsfsdfs
]]
io.write(longString, "\n")

longString = longString .. name
-- 连接操作
io.write(longString, "\n")

数据类型的话，lua语言当中只支持浮点数：

bigNum = 9234324342342 + 1
io.write("Big Number" , type(bigNum), "\n)

floatPrecision = 1.99999999999999 + 0.0000000000000005
floatPrecision = 1.99999999999999 + 0.00000000000000055

获取变量类型信息

我们可以使用type函数来获取变量的基本类型:

isWrite = true
io.write(type(isWrite))

Math Function

和其他语言类似，在lua语言内部包含了很多内置的数学函数可以直接调用。

io.write("5 + 3 = ", "\n")
io.write("5 * 3 = ")

-- number
-- floor ceil max min, sin, cos, sqrt

math.floor(134.33223)
math.random()
math.random(10)
math.random(5, 100)

math.randomseed(os.time())

print(string.format("Pi = %.10f", math.pi))

关系运算符和逻辑运算符

关系运算符和其他语言大同小异，逻辑运算符采用的是单词形式 and or not，简单的例子如下：

-- Relational Operators: > < >= <= == ~=
age = 13
if age < 16 then
  io.write("You can go to school", "\n")
  local localVar = 10
elseif (age <= 16) and (age < 18) then
  io.write("You can drive", "\n")
else
  io.write("You can vote", "\n")
end

-- Logical Operators: and or not

toString(not true)
canVote = age > 18 ? true : false

canvote = age > 18 and true or false

lua语言中的代码分块采用end进行结尾，和其它语言中使用{}进行分块不太一样。

字符串操作

以下是常用的字符串操作:

-- get length
string.len(quote)
-- or
#quote

-- replace string
string.gsub(quote, "I", "me")

-- find and get index
string.find(quote, "password")

-- upper /lower
string.upper(quote)
string.lower(quote)

循环，分支控制语句

lua中支持的循环语句类型比较多：

while循环：

i = 1

while (i <= 10) do
  io.write(i)
  i = i + 1
  
  if i == 8 then break end
end

until循环：和其它语言中do…until类似，这里采用的是repeat…until的语法。

repeat
  io.write("enter your guess:")
  
  guess = io.read()
  
until tonumber(guess) == 15

for循环：循环体的写法不需要用括号进行分隔，采用for…do的语法。

for i = 1, 10, 1 do
  io.write(i)
end

months = {"Juanary", "February", "March", "April"}

for key, value in pairs(months) do
  io.write(value, " ")
end

Table

在lua语言中，支持一种table的抽象数据结构，可以用来存储键值对对象。

aTable = {}

for i = 1, 10 do
  aTable[i] = i
end

io.write("First : ", aTable[1])

io.write("Number of Items: ", #aTable, "\n")

table.insert(aTable, 1, 0)

io.write("First : ", aTable[1])

-- remove
table.remove(aTable， 1)

-- convert to string
print(table.concat(aTable, ", "))

二维表结构的定义与上面的例子差不多：

aMultiTable = {}

for i = 0, 9 do
  aMultiTable[i] = {}
  for j = 0, 9 do
    aMultiTable[i][j] = tostring(i) .. tostring(j)
  end
  print()
end

io.write("Table[0][0] : ", aMultiTable[0][0], "\n")

functions

函数是进行语言抽象化必备的工具，所以在lua语言中，直接使用function来定义对应的函数就可以了：

function getSum(num1, num2)
  return num1 + num2
end

print(string.format(" 2 + 6= %d", getSum(2,6)

下面这里例子演示了如何一个实现分割字符串功能的函数：

function splitStr(theString)
  stringTable = {}
  
  local i = 1
  
  for str in string.gmatch(theString, "[^%s]+") do
    stringTable[i] = str
    i + i + 1
  end
 
  return stringTable, i
end

splitStrTable, numOfStr = splitStr("The Turtle")

for j = 1, numOfStr do
  print(string.format("%d : %s", j splitStrTable[j]))
end

这里需要注意在函数内部声明局部变量要使用local关键字，以确定变量的作用域。

function的参数支持不定长参数，使用...语法就可以了：

function getSumMore(...)
  local sum = 0
  
  for k, v in pairs{...} do
    sum = sum + v
  end
  return sum
end

io.write("Sum ", getSomeMore(1,2,3,4,5,6), "\n")

闭包这个结构在函数式编程语言中算是比较常见的，内部函数可以访问它上层所定义的局部变量。

doubleIt = function(x) return x * 2 end

print(doubleIt(4))

--- 输出 8

function outerFunc()
  local i = 0
  
  return function()
    i = i + 1
    return i
  end
end

getI = outerFunc()

print(getI())

-- 输出 1

coroutine 协程

协程是跟线程类似的概念，但在粒度上比线程要小，主要是在其自身上下文中进行切换。而且各个协程需要进行协作才能很好地工作。一个程序在同一时间只能运行一个协程，而且协程要显示挂起才能不强占资源。

主要的方法有create, resume, yield, running, status等，分别用来进行创建、恢复、传参、返回正在运行的协程和返回协程状态等操作。

co = coroutine.create(function()
	for i = 1, 10, 1 do
      print(i)
      print(coroutine.status(co))
      if i == 5 then coroutine.yield() end
      end
    end
)

print(coroutine.status(co))

coroutine.resume(co)

print(coroutine.status(co))

运行结果如下：

> print(coroutine.status(co))
suspended
>
> coroutine.resume(co)
1
running
2
running
3
running
4
running
5
running
true
>
> print(coroutine.status(co))
suspended

file文件操作

文件操作主要利用io这个接口中。常用的语法和c语言等都很类似，运行一个实例方法用采用:这种语法：

-- r
-- w
-- a: Append
-- r+： read & write existing file
-- w+: overwrite read or create a file
-- a+: append read or create file

file = io.open("test.lua", "w+")

file:write("Random String of text\n")
file:write("Some more text\n")

file:seek("set", 0)

print(file:read("*a"))

file:close()

file = io.open("test.lua", "a+")

file:write("Even more text\n")
file:seek("set", 0)

print(file:read("*a))

file:close()

Modules

在进行大工程化开发，模块化是必须的，所以我们直接在一个文件中声明一个模块，并将这个模块导出：

新建一个covert.lua的文件：

-- covert.lua

local convert = {}

function convert.ftToCm(feet)
  return feet + 30.48
end

return convert

在另一个入口文件index.lua中，使用require语法进行引用：

convertModule = require("convert")

print(string.format("%.3f cm", convertModule.ftToCm(12)))

在命令行中运行lua index.lua后结果显示：

42.480 cm

MetaTable

lua中有一种数据类型是元表，和哈希表类似，通常可以把它看做是一个备用查找表。在Lua中在一个表中查找元素，如果没有找到，会去其关联的元表中继续进行查找。

使用setmetatable方法可以给一个表对象新增一个元表。我们还可以自己去定义元表的操作方法：

aTable = {}

for x = 1, 10 do
  aTable[x] = x
end

--     _sub _mul _div _mod _concat
mt = {
 __add = function(table1, table2)
    sumTable = {}
    
    for y = 1, #table1 do
      if(table1[y] ~= nil) and (table2[y] ~= nil) then
        sumTable[y] = table1[y] + table2[y]
      else
        sumTable[y] = 0
      end
    end
    
    return sumTable
 end,
  
  __eq = function(table1 table2)
    return table1.value = table2.value
  end
}

setmetatable(aTable, mt)

print(aTable == aTable)

--- print true

Class OOP 面向对象

lua也支持面向对象的语言机制，在新建一个对象的时候，会调用其new方法

Animal = {height = 0, weight = 0, name = "No Name", sound = "No Sound"}

function Animal:new (height, weight, name, sound)
  setmetatable({}, Animal)
  
  self.height = height
  self.weight = weight
  self.name = name
  self.sound = sound
 
  return self
end

function Animal:toString()
  animalStr = string.format("%s weighs %.1f lbs, is %.1f in tall and says %s", self.name, self.height, self.weight, self.sound)
  return animalStr
end

spot = Animal:new(10, 15, "Spot", "woof")

print(spot:toString())

--- print Spot weighs 10.0 lbs, is 15.0 in tall and says woof