Lua脚本语言简单学习

 
最近要研究Nmap的脚本编写,于是特定来看一下lua语言
 

什么是Lua

 
Lua 是一种轻量小巧的脚本语言,用标准C语言编写并以源代码形式开放， 其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。可用于游戏开发、独立应用脚本、Web应用脚本、扩展和数据库插件、安全系统等.
 

Lua语言特性

轻量级:它用标准C语言编写并以源代码形式开放，编译后仅仅一百余K，可以很方便的嵌入别的程序里
可扩展:Lua提供了非常易于使用的扩展接口和机制：由宿主语言(通常是C或C++)提供这些功能，Lua可以使用它们，就像是本来就内置的功能一样。
支持面向过程和函数式编程、自动内存管理等

基本语法

 
Hello World
 

print("Hello World")

• 注释

--  //两个减号是单行注释

--[[
xxx
xxx
--]]
则为多行注释

• 变量声明

直接使用  test=123  就行了
默认是全局变量

test=nil  //删除变量的话直接将其赋值为nil就行了

数据类型

nil //这个最简单，只有值nil属于该类，表示一个无效值（在条件表达式中相当于false）
boolean //  包含两个值：false和true。
number //表示双精度类型的实浮点数
string //字符串由一对双引号或单引号来表示
function //由 C 或 Lua 编写的函数
userdata //表示任意存储在变量中的C数据结构
thread //表示执行的独立线路，用于执行协同程序
table //Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字、字符串或表类型。在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。

print(type("Hello world"))      
print(type(10.4*3))             
print(type(print))             
print(type(type))               
print(type(true))              
print(type(nil))                
print(type(type(X)))            

 


• nil的删除作用

tab1 = { key1 = "val1", key2 = "val2", "val3" }
for k, v in pairs(tab1) do
    print(k .. " - " .. v)
end
 
tab1.key1 = nil
for k, v in pairs(tab1) do
    print(k .. " - " .. v)
end
-- 这里我们还可以了解lua的for循环是怎么用的,还有字符串连接符是..

• nil做比较时需要用引号



• 布尔型的数据类型

if true then
    print("QAQ")
else
    print("233")
end
--还学习到了if语句的使用格式

• 字符串的另一种表示方法

a = [[
asdassddsaasd
asdasdsa
]]
print(a)
-- 使用[[]]可以也表示字符串

 
当字符串进行算数运算的时候,Lua会尝试将字符串转换为数字
 

print("100"+"100")



 
使用#来计算字符串的长度(很像Shell脚本)
 

print(#"qwer")

 


• table(类似弱类型语言里面的关联数组)

-- 创建一个空的 table
local tbl1 = {}
 
-- 直接初始表
local tbl2 = {"apple", "pear", "orange", "grape"}

-- local代表局部变量
a = {}
a["key"] = "value"
key = 10
a[key] = 22
a[key] = a[key] + 11
for k, v in pairs(a) do
    print(k .. " : " .. v)
end

-- lua语言表里面一般默认的初始索引以1开始

• 函数

function factorial1(n)
    if n == 0 then
        return 1
    else
        return n * factorial1(n - 1)
    end
end
print(factorial1(5))
factorial2 = factorial1
print(factorial2(5))

-- 跟Shell脚本一样,函数也可以赋值给变量

--匿名函数

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
);

• 线程/自定义类型

xxx
 

Lua变量

 
变量分别为全局变量、局部变量、表中的域
 
赋值语句(因为其特性我们可以很方便的做变量交换)
 

a=123
b=321
a,b=b,a  --这样a,b就交换了值
print(a,b)



 
当变量个数和值的个数不一致时，Lua会一直以变量个数为基础采取以下策略：

a. 变量个数 > 值的个数             按变量个数补足nil
b. 变量个数 < 值的个数             多余的值会被忽略

a, b, c = 0, 1
print(a,b,c)             --> 0   1   nil
 
a, b = a+1, b+1, b+2     -- value of b+2 is ignored
print(a,b)               --> 1   2
 
a, b, c = 0
print(a,b,c)             --> 0   nil   nil

• 对表的索引

t["i"]
t.i
gettable_event(t,i)  
-- 以上就是对表中数据的索引获取

循环

-- while
while(condition)
do
   statements
end
-- for 循环
for var=exp1,exp2,exp3 do   -- exp3默认为1
    <执行体>  
end 
--  repeat...until 循环
repeat
   statements
until( condition )
-- break goto等等(没有continue)

流程控制

--[ 0 为 true ]
if(0)
then
    print("0 为 true")
end
-- if...else 语句
if(布尔表达式)
then
   --[ 布尔表达式为 true 时执行该语句块 --]
else
   --[ 布尔表达式为 false 时执行该语句块 --]
end

函数

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

运算符

 
算数运算符:+ - * / % ^ -
 
关系运算符
 

==   //等于
~=   //不等于
>    //大于
<    //小于
>=   //大于等于
<=   //小于等于

 
逻辑运算符
 

and or not

字符串

 
常用的一些操作忽略
 
字符串操作
 

string.upper(xxx)  //转为大写
string.lower(xxx)  //转为小写
string.gsub(mainString,findString,replaceString,num)  //替换
mainString 为要操作的字符串， findString 为被替换的字符，replaceString 要替换的字符，num 替换次数（可以忽略，则全部替换
string.find (str, substr, [init, [end]])  //在一个指定的目标字符串中搜索指定的内容(第三个参数为索引),返回其具体位置。不存在则返回 nil。
string.reverse(arg) //字符串反转
string.format(...)  //返回一个类似printf的格式化字符串
string.format("the value is:%d",4)
string.char(arg) 和 string.byte(arg[,int]) //char 将整型数字转成字符并连接， byte 转换字符为整数值(可以指定某个字符，默认第一个字符)。


> string.char(97,98,99,100)
abcd
> string.byte("ABCD",4)
68
> string.byte("ABCD")
65

string.len(arg) //计算字符串长度。
string.rep(string, n)  //返回字符串string的n个拷贝
string.match(str, pattern, init) //string.match()只寻找源字串str中的第一个配对. 参数init可选, 指定搜寻过程的起点, 默认为1。

Lua数组

 
跟表差不多,多维什么的都一样
 

lua表

-- 初始化表
mytable = {}

-- 指定值
mytable[1]= "Lua"

-- 移除引用
mytable = nil
-- lua 垃圾回收会释放内存

 
关于对表的操作
 

table.concat(table [, sep [, start [, end]]]) --指定table的数组部分从start位置到end位置的所有元素, 元素间以指定的分隔符(sep)隔开。
table.insert(table, [pos,] value) --在table的数组部分指定位置(pos)插入值为value的一个元素. pos参数可选, 默认为数组部分末尾.
table.remove(table [, pos])  --返回table数组部分位于pos位置的元素. 其后的元素会被前移. pos参数可选, 默认为table长度, 即从最后一个元素删起。
table.sort(table,)  -- 对给定的table进行升序排序

lua语言的模块与包机制

 
很类似于php中的文件包含
 
模块:是由变量、函数等已知元素组成的 table，因此创建一个模块很简单，就是创建一个 table，然后把需要导出的常量、函数放入其中，最后返回这个 table 就行。以下为创建自定义模块 module.lua
 

-- 文件名为 module.lua
-- 定义一个名为 module 的模块
module = {}
 
-- 定义一个常量
module.constant = "这是一个常量"
 
-- 定义一个函数
function module.func1()
    io.write("这是一个公有函数！
")
end
 
local function func2()
    print("这是一个私有函数！")
end
 
function module.func3()
    func2()
end
 
return module

 
使用require可以加载模块
 

require("xxx")
require "xxx"

 
调用
 

require("module")
print(module.constant)
module.func3()

 
或者重新定义一个名字
 

local m = require("module")
 
print(m.constant)
 
m.func3()

 
模块的加载机制
 

对于自定义的模块，模块文件不是放在哪个文件目录都行，函数 require 有它自己的文件路径加载策略，它会尝试从 Lua 文件或 C 程序库中加载模块,

 
包什么的就暂时放一下,应该够写Nmap脚本啦