关闭

Lua学习笔记(基础二)

标签: lua基础学习笔记
37人阅读 评论(0) 收藏 举报
分类:

四、表达式

1、算数操作符

      除了基本的“+ - * /”,Lua中特殊的在于“^”表示指数运算;“%”取模可用于任何实数(而非C中仅限整型)。

a=8^(1/3) --计算8的1/3次

10.3%4    --等于2.3

其中“%”是根据以下规则定义的:

a%b=a-floor(a/b)*b      --floor是向下取整函数

      故对于小数取模有一些特别的用法:

x%1结果是x的小数部分,x-x%1就是x的整数部分。x%0.01是x小数点后两位之后(小数点后第三位开始)的部分,x-x%0.01就是x精确到小数后两位的结果。类似地,可以x-x%0.001来获得精确到小数点后3位的结果。

2、关系操作符

“<”、“>”、“<=”、“>=”、“==”、“~=”

其中“~=”表示不等于。如果两个值的类型不同,则认为不等。关系操作符运算结果返回true或false。

值得注意的是只有同种类型的值才能进行大小性判断,不同类型的值只能进行相等性判断。

2<”15”  --类型不同,出错

2 == “15”--可以判断

对于table、userdata、function,Lua是做引用比较的。只有当它们引用用一个对象时,才认为相等。并且只能进行相等性判断。

只有数字和字符串可以进行大小性判断。

3、逻辑操作符

     and      or        not

区别于C和Java的是,逻辑操作符返回的结果不一定是boolean型的,也可能是一个操作数!

与条件控制语句一样,所有的逻辑操作符将false和nil作为假,其他任何视为真。

对于and,如果第一个操作数为真,返回第二个操作数;如果第一个操作数为假,返回第一个操作数——操作数本身的值,故操作数是什么就返回什么。

print(4 and 5) -->5

print(false and 5)   -->false

print(nil and 3)       -->nil

同理,对于or也是返回操作数。第一个操作数为真,则返回第一个操作数,否则返回第二个操作数。

print(4 or 5)           -->4

print(false or 5)      -->5

print(nil or false)    -->false

与C相同的是,Lua的逻辑操作符也会“short-cut evaluation”,即前面的条件已可得到结果就不计算后面的。

Lua中常用“x=x or v”来对x设默认值为v。这句话表示x为假(没有设置x时为nil),则取v的值;如果不为假则不改变。

还有“a and b or c”,当b恒为真时,等价与C中的“a?b:c”。常用于求两者之间的最大值:

max=(x>y) and x or y

x>y时,(x>y)为真,(x>y) and x等于x,x必为真故x or y等于x,所以max=x;反之(x>y)为假,(x>y) and x返回假,假or y等于y。(and的优先级高于or)

非操作符not只返回true或false。

 

4、操作符优先级

 

 

 

 

 

 

^

not   #  - (一元操作符)

*   /  %

+  -

..

<      >      <=      >=       ~=      ==

and

or

其中“^”和”..”是“右结合”的,即自右向左结合,其余为左结合。

5、构造式

构造式是用于初始化table的。除了用{}来初始化一个空table外,还有“列表”风格、“记录”风格、“通用”风格的方式来初始化table。

(1)“列表”风格

days={“Mon”,”Tue”,”Wed”,”Thu”}

这种方式直接对table赋值,不指定索引值,故默认为是一个普通数组,默认索引为从1开始的整数。故days[1]=”Mon”;days[2]= ”Tue”。

(2)“记录”风格

      “记录”风格即“什么等于什么”的形式,指定索引值和元素值。

      a={x=1,y=2}  -- 等价于a={};a.x=1;a.y=2

      x=1,y=2中x、y是字符串“x”、“y”。而不是变量x(如果前面有定义x变量)

      可以用这种方式实现链表:

      list=nil

       for i=1,10 do

              list={next=list,val=i}

       end

      上述程序得到一个反序的链表。链表的每一个结点都是个table,table中包含next和val两个字段。next指向上一次创建的表,所以是反序的:

      nilß1ß2ß3ß4ß5ß6ß7ß8ß9ß10

      “记录”风格指定了索引(字段名),就可以用“表名.索引名”的方式引用元素。如print(a.x)

     (3)“列表”风格与“记录”风格结合

polyline={color=”red”,thickness=2,npoint=4;

{x=0,y=0},

{x=-10,y=0},

{x=-10,y=1},

{x=0,y=1},

} --“;”常用来分割两种不同风格,用“,”也没错

其中{x=0,y=0}是一个table,作为polyline的元素,由于其形式是“列表”风格,故其索引值为1.有

print(polyline[2].x)  -->-10

print(polyline[4].y)  -->1

(4)通用”风格

“列表”风格与“记录”风格都存在不能使用负数、运算符作为索引的限制。Lua提供了通用的初始化格式——在方括号之间,显式地用一个表达式来初始化索引值:

opsnames={[“+”]=”add”,[“-”]=”sub”,[“*”]=”mul”,[“/”]=”div”}

print(opsnames["+"])    -->add

i=20;s=”-”;

a={[i+0]=20,[i+1]=s..s}      -->a[20]=20;a[21]=”--”

之所以是通用的,“列表”风格与“记录”风格可以用这个方式表示:

{x=1,y=2}      --等价于{[“x”]=1,[“y”]=2}

{“r”,”g”,”b”}    --等价于{[1]=”r”,[2]=”g”,[3]=”b”}

还可以指定数组从0开始:

days={[0]=”Sun”,“Mon”,”Tue”,”Wed”,”Thu”}则days[1]= ,“Mon”。但不推荐将Lua的数组从0开始。

 

五、语句

1、赋值

      Lua支持“多重赋值”,即用一个赋值符号(“=”)对多个变量赋值,每个变量之间用“,”分隔:

      a,b=1,2          -- a=1;b=2

      当变量数量大于值的数量时,多余的变量赋nil值:

      a,b,c=0          --a=0;b=nil;c=nil

      当值的数量大于变量数量时,多余的值被舍弃:

      a,b=1,2,3       --a=1;b=2;3被舍弃

      Lua对于多重赋值,是先将“=”后面的值从左到右计算之后寄存,然后对变量依次赋值。所以多重赋值可用于值的交换:

      x,y=y,x           --x,y互换

一般情况很少会对一组没有关联的值一起赋值。多重赋值也没有比分开赋值高效。多重赋值通常用于上述的两值交换和收集函数(如string.find)的多个返回值。

2、局部变量

      Lua中用local关键字类声明局部变量。局部变量的作用域仅限于它所在的块(block)。一个块是指一个控制结构(如if..then..else、while等)的执行体、或者是一个函数的执行体(function..end)或是一个程序块。

      x=10              --全局变量x

local i=1  --局部变量i

while i<=x do --此处的x是全局的x(等于10)

              print(x)

              local x=i*2             --局部变量x,在其作用域内覆盖全局的x

              print(x)

              i=i+1

end

上述程序应放在lua文件中执行,如果在交互模式下,没行输入内容就形成一个程序块。当输入local i=1是就会立马执行。而下面的语句是另一个独立的程序块,i的作用域不能达到。若要在交互模式下执行,应在最外层加上do-end(显式的界定一个块)。当输入do时,Lua就不会单独执行后面每行的内容,而是知道遇到一个相应的end才执行整个块的内容。

      使用局部变量的优势:

      ①避免将一些无用的名称引用全局环境,破坏全局环境

②访问局部变量比访问全局变量更快

③局部变量随着作用域结束而消失,利于垃圾收集器回收释放

3、控制结构

Lua控制语句都有显式的终止符:if、for、while以end为结尾,repeat以until为结尾。

(1)if …then… else…end

if或者elseif后面都要加then来跟要执行的语句,else之后不需要then:

if(表达式1) then

       执行语句1

elseif(表达式2) then

       执行语句2

elseif(表达式3) then

       执行语句3

else

执行语句4

end

if..then..end可单独使用,不支持switch语句。

(2)while…do…end

while后要加do来跟执行语句:

while 条件表达式 do

       执行语句

end

(3)repeat…until

相当于C中的do…while语句。测试语句在循环体之后,所以至少会执行一次循环体:

repeat

       循环体

until 条件表达式

值得注意的是,在Lua中一个声明在循环体重的局部变量的作用域包括了until中的测试条件:

y=10

repeat

       local i=y/2

       print(i)

       y=y-1

until i<=0              --在此仍可访问i

(4)数字型for(numeric)

for语句有两种:数字型for和泛型for

数字型for语法如下:

for var=exp1,exp2,exp3 do

       <执行体>

end

var从exp1变到exp2,exp3是步长,省略时默认为1,exp3可以是负数。

值得注意的是,var变化范围可以是任意实数(小数),但由于Lua用双精度表示任意数字,会存在误差,导致循环范围与定义的不同的情况:

for i=1,2,0.1 do

       print(i)

end

输出1,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,而2没有输出!改成

for i=1,2.000000000000001,0.1 do

       print(i)

end

则输出2。验证程序:

print(2<2.0000000000000001)     -->false

print(2==2.0000000000000001) -->true

另外Lua只能计算到小数点后13位:

print(1.9000000000001+0.1000000000001)    --> 2.0000000000002,多一个0就变成2了。

数字型for需要注意的点:

①for的3个表达式是在循环开始前一次性求值的,即exp1,exp2,exp3只会执行一次!所以结束条件、步长不能是动态的!

②var被自动声明为for语句的局部变量,尽在循环体中可见。

③不要在循环体中修改控制变量var,否则会导致不可预知的效果。

若不想给循环设置上限的话,可以使用常量math.huge(a value larger than or equal to any other numerical value):

for i=1,math.hugedo …end

(5)泛型for(generic for)

泛型for通过一个迭代器遍历table。标准库提供的迭代器有:

io.lines()                --用于迭代文件中的每一行

pairs()             --用于迭代table所有的元素

ipairs()             --用于迭代数组的元素

string.gmatch()  --迭代字符串中单词

泛型for要配合关键字in使用,以下是pairs和ipairs的区别:

a={[1]="111",[2]="222",[5]="555",x=1,y=2,z=3}

for k,v in pairs(a) do

       print(k,v)

end

--输出a中所有的key-value,顺序不一定是定义时的顺序

for k,v in ipairs(a) do

       print(k,v)

end

--只输出[1]="111",[2]="222"

分析:pairs返回的迭代器包含table中所有的key-value对;

ipairs只返回数组元素,即下标为从1开始的整数做key的key-value对。当遇到table[i]=nil时就终止。所以[5]="555"没有输出,因为a[3]=nil。

如果一个table中table[1]没有定义,则用ipairs返回的迭代器没有元素。如把a改成a={[2]="222",[5]="555",x=1,y=2,z=3}则ipairs(a)不能输出任何值。

也可以只给key赋值:

for k in pairs(a) do print(k) end

(5)break和return

break和return的用法与C中相同。break和return只能用在block结束的地方, 不能用在block的一个中间部分,即后面跟的是end或者elseif、esle

function test()

       return --doreturn end

       print("abc")

end

上述程序会输出abc,但如果在return前后加上do-end就可直接返回,而不输出。

 

 


六、函数

function 函数名(参数列表)    <function body> end

当调用的函数参数只有一个,并且此参数是一个字符串常量或table构造式时,则可以不加圆括号,如:

print “hello”           -- print (“hello”)

func{x=10,y=20} --func({x=10,y=20}).{x=10,y=20}是一个table构造式

给函数传入参数时,实参数量可以与形参数量不同。这与多重赋值一样“多舍弃,少nil”的方式处理。这种机制有一些作用。如下面的程序:

count=0

function iCount(n)   --全局计数函数

       n=n or 1

       count = count + 1

end

当调用iCount()(即不传入参数)时,n被初始化为nil,在函数中又被初始化为1,起到了对全局变量count加1的用作。

当一个lua文件中定义相同名称(参数列表不同)的时候,后面定义函数会覆盖前面的。

1、多重返回值

Lua支持函数返回多个值,在return后加上要返回的值,并用逗号分隔。

多重返回值的函数调用在不同情况下会得到不同的结果:

(1)作为单独的语句时(不将结果赋给任何变量),函数返回值会被舍弃;

(2)函数作为表达式的一部分时(如算数表达式),只保留第一个返回值;

(3)只有以下4种情况中,函数调用是最后一个元素时才能获得所有返回值:

假设foo()有返回”a”,”b”。

①多重赋值

x,y,z=”c”,foo()              --x=”c”;y=”a”;z=”b”

x,y,z=foo(),”c”              --x=”a”;y=”c”;z=nil;因为foo()不是赋值表达式的最后一个元素!

②一个函数调用作为另一个函数的参数列表

最常见的就是print函数,该函数支持任意多个参数。函数调用作为要输出的内容时,放在最后才能输出全部返回值——

print(foo(),1)         -->a,1

print(1,foo())         -->1,a,b

对于一般的多个形参的函数,其传入的实参是函数调用时也要注意是否在最后位置,否则也当做一个参数传入,若实参个数小于形参个数就会初始化为nil了!

③用table构造式中调用函数

t={foo(),1}    --t[1]=”a”;t[2]=1

t={1,foo()}    -- t[1]=1;t[2]=”a”; t[3]=”b”;

④return一个函数调用

return 1,foo() --返回1,“a”,“b”

return foo(),1 --返回“a”,1

注意以上4中情况都是在函数调用作为最后一个元素时有效!

可以将函数调用放入一对圆括号中,迫使它只返回一个结果:

print((foo()))          -->a

关于多重返回值,有一个特殊函数——unpack。该函数接受一个数组作为参数,返回从下标1开始的所有元素,直到遇到nil元素。

print(unpack({1,2,3}))          -->1,2,3

unpack函数是泛型调用的体现,即unpack的参数可以是任何类型的数据。

2、变长参数

Lua支持函数的参数个数是不定的,用“…”来表示形参。如以下程序:

function add(...)

       local sum=0

       for k,v in ipairs{...} do    --{...}表示以“...”组成的数组

              sum=sum+v

       end

       return sum

end

函数中访问它的变长参数也要用到“…”,其中{...}表示由“...”组成的数组。在调用add函数时直接传入所有参数:

add(1,2,3)

普通指定参数个数的函数也可以用这种形式来表示:

function foo(a,b,c)等同于

function foo(…)

       local a,b,c = …

end

这种用“…”表示参数的方式对跟踪某个特定的函数调用有帮助。

具有变长参数的函数同样可以有任意数量的固定参数,但固定参数要在“…”之前。如

io.wirte(string.format(fmt,…))

fmt是固定参数(指定的字符串格式),“…”是变长参数。

{...}用于遍历数组,但有时候变长参数在传入实参时会特意传入nil值,这样{...}不能访问所有的参数,此时用到select。

select函数的第一个参数是指定返回第几个参数,第二个参数是“…”。

select(n,…)            --返回“…”中的第n个参数

select(“#”,…)         --返回“…”中所有参数的总个数

functionvariable_arguments(...)

       for i=1,select("#",...) do -- select("#",...)指定循环上限

              local arg=select(i,...)   -- select(i,...)选出第i个参数,可以是nil

              print(arg)

       end

end

Lua5.0对于变长参数是采用一个隐含的局部table变量“arg”来接收所有变长参数的,arg有一个“n”字段来记录arg的长度。但这种机制 缺点在于每当程序调用一个具有变长参数的函数时都会创建一个table。(概述中提供arg是存放脚本启动参数的全局变量)

3、具名实参

传入函数的参数根据其实参的顺序与形参匹配,但有时候也可以通过名称来指定实参。这时需要用一个table作为函数参数,在传入实参时指定参数是table的哪一个字段。这种方式对于有大量参数并且大部分是可选参数的函数有帮助(对于未指定的字段有默认值,只需传一些必要参数即可)。

function rename(t) --定义rename函数,参数t是一个table

       return os.rename(t.old,t.new) --os.rename是os库的重命名函数

end

rename{old=”old.lua”,new=”new.lua”} --调用rename,指定字段的值

 

 

七、深入函数

在第三章中就提到Lua的变量类型包括了function,所以Lua中函数与其他传统数据类型的统一级别的——“第一类值”(First-Class Value)。所以函数与string、number一样都是匿名的,都是一个值,而函数名如普通变量名一样只是一个指向这个值“引用”名称。例如print函数只是一个具有打印功能的变量,“print”这个名字可以指向别的函数:

a={p=print}           --a是一个table,字段p指向print函数

a.p(“hello”)            --打印hello

print=math.sin       --变量名“print”指向正弦函数

a.p(print(1))          --打印sin(1),0.841470

sin=a.p                 --变量名“sin”指向了原来的打印函数

sin(10,20)             -->10      20

因此函数的本质是“值”,函数名是指向它的变量名,函数的本质定义是一种赋值语句,这条语句创建了一个类型为“函数”的值:

foo = function (x)return 2*x end

它等同与functionfoo(x) return 2*x end,而这种传统的定义方式是一种“语法糖”而已。

可以将表达式“function(x) <body> end”视为一种函数的构造式,就像table的{}一样。将这种函数构造式的结果称为“匿名函数”。

一般情况下为了方便使用函数都会给函数一个名字,但在某些情况下使用匿名函数带来方便——将函数作为参数传入另一个函数。这里的函数作为参数是指参数类型就是函数,而不是一个函数调用(函数的返回值)。这类似于C中的函数指针和Java的匿名内部类。table.sort就是一个接受另一个函数作为参数的排序函数。它的第一个参数是要排序的table名,第二参数是一个函数(“次序函数”)。这个次序函数负责实现具体的排序方式(升序、降序、还是按哪种关键字顺序,类似Java的Comparator)

像sort这样以另一个函数作为参数的函数称为“高阶函数”,其实质仍是一个值。

-- derivative是一个近似求导函数,以函数作为参数,返回值也是一个函数

functionderivative(f,delta)

       delta=delta or 1e-4

       return   function (x)

                            return(f(x+delta)-f(x))/delta

                     end

end

c=derivative(math.sin)

print(math.cos(10),c(10))             -->-0.83907152907645   -0.83904432662041

1、闭包函数(closure)

Lua允许在一个函数中定义一个新的内部函数,并且这个新的内部函数可以访问外部函数的局部变量,这个特征称为“词法域”。“词法域”与“第一类”特性使Lua编程变得简洁、灵活多变。

在内部函数中可以调用属于外部函数的局部变量,而这个局部变量在内部函数中既不是局部变量也不是全局变量,而是“非局部的变量”(non-local value/upvalue)。

function newCounter()    --计数函数,该函数返回值是一个函数

       locali=0

       returnfunction ()    --匿名的内部函数调用外部函数的局部变量

                     i=i+1

                     returni

                 end

end

c1=newCounter()   --c1获得一个返回的函数

print(c1())                    -->1

print(c1())                    -->2

c2=newCounter()   --c2获得一个返回的函数

print(c2())                    -->1

print(c2())                    -->2

上述程序中c1虽然获得了一个内部函数,但看上去已经超出了i的作用域,所以在i=i+1时应该不能正常使用。但Lua有一个“闭包”(closure)来处理这种情况。所谓closure就是一个函数及一系列这个函数会访问到的“非局部的变量”。所以i仍可以使用。从c2可以看出,c1、c2分别持有各自的closure。

因此,函数本身就是一种特殊的closure——即没有“非局部变量”的closure。

closure的作用:

①作为table.sort这种高阶函数的参数;

②用于那些创建其他函数的函数,如上面的newCounter()。又比如在GUI设计中会很实用;

③重新定义某些函数,甚至是重新定义那些预定义的函数(库函数):

do   --重写math.sin函数,将参数从弧度转为角度

       local oldSin=math.sin

       local k=math.pi/180

       math.sin=function (x) return oldSin(x*k)end

end

上面的程序把原来的sin函数保存在一个局部变量oldSin中(do-end界定了局部变量的作用域),do-end之外的函数用math.sin来计算时参数就变成了角度,并且不能掉用原来的sin函数(oldSin),做到了“彻底地”改变。

类似的还可以用于创建一个安全的运行环境。比如服务器要运行来自网络的程序,要检测这段程序对文件的访问权限,就可以重写io.open函数,在其中添加权限检查,避免非法访问。

2、非全局函数(non-globalfunction)

函数是值,所以可以定义在table的字段和局部变量中。

(1)函数定义在table中

如同io.read是在名为io的table中调用read字段(实为函数)一样,可以自定义带函数的table。只需将函数定义与table构造式结合:

①使用常规的函数语法与table语法相结合来创建局部函数

Lib={}

Lib. add=function(x,y) return x+y end

Lib. sub=function(x,y) return x-y end

②使用table构造式来创建局部函数

Lib={

       add=function (x,y) return x+y end,

       sub=function (x,y) return x-y end

}

③另类的方法创建局部函数

Lib = {}

function Lib.foo(x,y)

    return x + y

end

function Lib.goo(x,y)

    return x - y

end

(2)函数赋给局部变量

将函数存储到一个局部变量中,就得到了一个局部函数。局部函数的作用域限定在某个特定范围内。

local f1=function(<参数>)

   <函数体>                                                                                           ①

end

local g1=function(<参数>)

   <函数体>                                                                                          

    f1()   --f1在这里是可用的

end

或者用“语法糖”:

local functionf(<args>)

<body>                                                                                                             ②

end

在定义递归函数时,采用第一个方式就不可行,而第二种却可以。因为“语法糖”的展开实际上是

local f

f=functionf(<args>)

       f(<args >) --递归调用f。及在函数定义时,这个局部变量的值尚未完成定义,但之后的函数执行时,f已经拥有的了正确的值。

end

区别于

local f=functionf(<args>)

     f(<args>) --递归调用f,会出错!因为f本身没有定义完毕,这里调用f会被认为是一个全局的f而非当前要定义的f

end

再比较以下两段程序:

 

local test1

local test2

test1=function ()

       print(1)

       test2()

end

test2=function ()

       print(2)

end

test1()                 ③

 

test1()

local test1=function ()

       print(1)

       test2()

end

local test2=function ()

       print(2)

end

test1()

    

左边的程序会出错,因为test2未定义。而右边程序可以,因为在运行时test2已经有了正确内容。

但对于间接递归(f中调用g,g中调用f)②也不可用了。必须是③的明确的前向声明。

3、尾调用

尾调用是指一个函数调用是另一个函数最后一个动作。只有“return<func>(<args>)”的形式是一条尾调用。并不意味着最后一句话是一个函数调用就是一个尾调用,而是最后一个动作:

function   f(x) return g(x) end        --尾调用

function f(x) g(x)end                          --舍弃g(x)的返回值,所以不是一个尾调用

function f(x)return 1+g(x) end            --进行加法运算,所以不是一个尾调用

function f(x)return x or g(x) end   --必须将返回值调整为一个

function f(x)return (g(x)) end              ---必须将返回值调整为一个(g(x)可能有多个函数值),不是一个尾调用。

◆尾调用的作用

若g(x)是f(x)的尾调用,当g(x)执行完后就不需要返回f(x)了。因此程序不需要保存任何关于f(x)的栈信息——区别于一般的函数调用。一般的函数调用要保存f(x)的栈信息,待g(x)执行完后返回到f(x)继续执行,而尾调用则省去了返回f(x)的动作。

尾调用不会耗费空间,故一个程序尾可以调用无数嵌套的尾调用,并且不会导致栈溢出。

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:1871次
    • 积分:296
    • 等级:
    • 排名:千里之外
    • 原创:29篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章分类
    文章存档