lua工具库penlight--01简介

时间:2023-12-28 10:58:50

lua的设计目标是嵌入式语言,所以和其它动态语言(如python、ruby)相比其自带的库缺少很多实用功能。

好在有lua社区有Penlight,为lua提供了许多强大的功能,接下来的几篇博客,我会简译Penlight的wiki。

目的

 常有人说lua不带电池。因为lua的目标是可以运行在各种机器上的简洁语言,(有些机器甚至不

支持布尔系统)。lua类似于操作系统内核(注:即不是完整的系统,只有基本功能),lua的作者

并没有把围绕lua开发完整的生态系统看做自己的职责。这是社区的角色。

 软件设计的原则是识别通用模式,并复用。这不但让代码更易管理,而且更易阅读。

Penlight使用了许多编码原则,这样你的代码变得更简洁。如在Lua里通常用{unpack(t)}复制

表,但这只对“小”表有用而且不健壮。因此Penlight提供了tablex.deepcopy(),它可以用来复制

嵌套的表和相关联的元表,所以可以用它复制复杂对象。

 lua默认采用这样的错误处理:如果参数类型错误,抛出错误;如果有问题,返回nil,message。

也有些例外的函数,如input.fields默认是返回message并立即关闭程序(可以改变默认方式)。

对脚本而言,与提供堆栈跟踪相比,这是更合适的方式。词法函数为了简化编码,总是返回错误,

必须用pcall封装。

如果你习惯Python的约定,注意lua里的索引从1开始。

lua不建议用table.foreach,而是泛型for,但是使用Penlight提供的高阶函数,它在某些情况下

特别有用。注意tablex.foreach,颠倒了顺序,先传值,之后索引。虽然乖张,符合预期要更好。

Penlight唯一外部依赖是 LuaFileSystem (lfs ),如果你想dir.copyfile在Windows上成功工作

,你需要 alien 或 LuaJIT 。(如果失败,会调用等效的shell命令)

注入还是不注入

  人们很早就意思到大的程序里需要保证命名清晰的方法,如tables (Lua), namespaces (C++)

或modules (Python)。在大公司里很容易遇到命名冲突,在一些简单的语言,如Lua,并没有提

供像C++那样解决命名冲突的详细机制,因此更易遇到。在一小圈朋友里‘Bruce‘是唯一的,不需

要加姓。这取决于你写十多行的脚本,还是上万行的程序。

 Penlight提供了正规和非正规两种方式,你可以随意使用。

 正规方式:

 local utils = require 'pl.utils'
utils.printf("%s\n","hello, world!") 非正规方式:
 require 'pl'
utils.printf("%s\n","That feels better")

 require ‘pl’ 让所有的Penlight模块可用,而不需要单独调用。

 正规方式在写模块时更好。

 Andrew Starks贡献了另一种方法,很好的在两种方法里取得了平衡。

require'pl.import_into'返回一个函数,它有一个表参数,把Penlight库导入,如果参数为空,返回一个新的。 

local pl = require'pl.import_into'()

 pl表是一个 ‘lazy table’,即按需载入,因此可以使用pl.utils.printf,这样不会污染全局。

如果你在lua5.2里使用 _ENV来定义模块,要用Penlight可以这么做:

 local _ENV,M = require 'pl.import_into' ()

 function answer ()
-- all the Penlight modules are available!
return pretty.write(utils.split '10 20 30', '')
end return M

默认把Penlight放在_ENV里,可能会对模块造成意外效果(和 module(…,package.seeall)一样

。为了方便和安全,你需要向这个函数传入true,这样module M就和_ENV不一样,只包含导出的

函数。(注:对lua5.2不了解,这句话不解)

 你想把pl.stringx里的函数导入到标准库里,可以这么做:

 require 'pl'
stringx.import()
或者,更快的:
require('pl.stringx').import()

更好的方法师把表导入到局部环境,这样可以让名称简介。
 > require 'pl'
> utils.import(math) --把math里的函数直接导入到全局
> = sin(1.2)
0.93203908596723

当第一次require来导入时,utils.import 的参数也可以是字符串。在module里使用时,import会

把符号导入到module的上下文。

对于动态语言,保持全局域简洁是很重要的。 pl.strict模块,引入了简单的强制措施:全局变量必须

声明。如下:

 > require 'pl.strict'
> print(x)
stdin:1: variable 'x' is not declared
> x = nil
> print(x)
nil strict模块符合Penlight的“用时加载”策略。
strict也禁止对全局变量赋值,除非在主程序里。如果你想绕过这个机制使用rawset和rawget。
如果你想让strict全局生效,在pl/init.lua最后加上require 'pl.strict',并在主程序里调用。
从1.1.0之后,strict提供了strict.module函数来创建(或修改)模块,以符合此机制。
如:
 -- mymod.lua
local strict = require 'pl.strict'
local M = strict.module (...) function M.answer ()
return 42
end return M
如果你不小心错打成 mymod.Answer(),你会得到运行时错误:“variable ‘Answer’ is not declared
in ‘mymod’”。
这对已有的模块也有效,也可以修改lua标准库。
 strict.make_all_strict(_G)
这样当你错打成 math.cosine 时会得到错误信息,而不是nil。
Penlight的函数参数是什么?
许多Penlight里的函数的参数是函数,如map,它把函数作用到table的每个元素上。
pl.operator 导出了lua里的运算符,且和Python里的名字一样。如 operator.gt表示">".
map函数传递任何参数到函数,因此可以简写ls:filter(function(x) return x > 0 end)
为ls:filter(‘>’,0)
最后,pl.func支持Boost lambda(译注:C++里的)的占位符,如一个乘法的匿名函数可以
表示为;_1*_2.
可以直接用,在Penlight里的所有的函数参数都会通过 utils.function_arg ,pl.func在这个
函数中注册。所以你可以直接在标准函数里使用占位符。
 > _1 = func._1
> = List{10,20,30}:map(_1+1)
{11,21,31}
(译注:_1,_2表示第几个参数)
另外一个有用的是utils.string_lambda ,也会自动调用
 > = List{10,20,30}:map '|x| x + 1'
{11,21,31}
(译注:即|x|=x+1)
少用循环的利弊
循环是一种更机器的方式,如:
 local res = {}
for i = 1,#ls do
res[i] = fun(ls[i])
end
但是这可以更高效的写作,ls:map(fun),不但代码更少,而且更易理解。
通常人们认为,这么写效率低,更消耗内存。如ls1:map2(‘*’,ls2):reduce ‘+’
会产生多余的临时对象。但是效率是相对的。
写循环容易出错而且乏味。(译注:省略了许多议论,结论是利大于弊) 通用函数
 utils.memoize用来存储需要多次调用且花销大的函数。它可以保存调用函数后的已有结果,
如果参数相同直接返回结果。
sum = utils.memoize(function(n)
local sum = 0
for i = 1,n do sum = sum + i end
return sum
end)
...
s = sum(1e8) --takes time!
...
s = sum(1e8) --returned saved value!
 应用支持
app.parse_args是一个简单的命令行参数解析器,支持gnu风格。
app.appfile,用来存储应用的配置。
prett模块让table更易读。(译注:省略了很多用法讲解,可以直接看api)
简单的面向对象
提供了面想对象的支持,
-- animal.lua

 class = require 'pl.class'

 class.Animal()

 function Animal:_init(name)
self.name = name
end function Animal:__tostring()
return self.name..': '..self:speak()
end class.Dog(Animal) function Dog:speak()
return 'bark'
end class.Cat(Animal) function Cat:_init(name,breed)
self:super(name) -- must init base!
self.breed = breed
end function Cat:speak()
return 'meow'
end class.Lion(Cat) function Lion:speak()
return 'roar'
end fido = Dog('Fido')
felix = Cat('Felix','Tabby')
leo = Lion('Leo','African') $ lua -i animal.lua
> = fido,felix,leo
Fido: bark Felix: meow Leo: roar
> = leo:is_a(Animal)
true
> = leo:is_a(Dog)
false
> = leo:is_a(Cat)
true 也可以这么写:
 local class = require 'pl.class'

 class.Named {
_init = function(self,name)
self.name = name
end; __tostring = function(self)
return 'boo '..self.name
end;
} b = Named 'dog'
print(b)
--> boo dog Penlight提供了一些有用的类如:List,Set,Map,MultiMap,OrderdMap.
所有的类有catch函数,可以处理未预料的情况,如:
Strings:catch(function(self,name)
return function() error("no such method "..name,2) end
end)
上面只是简单的输出错误,但你可以创造一些好玩的,如;
 Strings:catch(List.default_map_with(string))

 ls = Strings{'one','two','three'}
asserteq(ls:upper(),{'ONE','TWO','THREE'})
asserteq(ls:sub(1,2),{'on','tw','th'})
(译注:list没有upper,sub,但是catch让没有的函数都执行string里函数)
cast类型转换,它不产生新对象,而是返回你传入的对象。
local sizes = ls:map '#'  --即取长度
asserteq(sizes, {3,3,5})
asserteq(utils.type(sizes),'Strings')
asserteq(sizes:is_a(Strings),true)
sizes = Vector:cast(sizes)
asserteq(utils.type(sizes),'Vector')
asserteq(sizes+1,{4,4,6})
(译注,ls即Strings{'one','two','three'})
utils.type可以返回类中_name属性的字符串。

属性模式,我们想控制用户对属性的访问,但不想让用户,使用obj:get_field()这么长
的代码访问。解决办法如下:
local MyProps = class(class.properties)
local setted_a, got_b function MyProps:_init ()
self._a = 1
self._b = 2
end function MyProps:set_a (v)
setted_a = true
self._a = v
end function MyProps:get_b ()
got_b = true
return self._b
end local mp = MyProps() mp.a = 10 asserteq(mp.a,10)
asserteq(mp.b,2)
asserteq(setted_a and got_b, true)
 规则是内部的变量以"_"开头,当访问mp.a时先检查特定的getter(取值器),
get_a。同理setter(设定器)也被使用了。
当然这也带来了更多的花销,所以你需要自己把握。

原文:http://stevedonovan.github.io/Penlight/api/topics/01-introduction.md.html