发帖
翼度科技»论坛 › 编程开发 › python › 查看内容

aardio教程三) 元表、元方法

大月

4

主题

4

帖子

12

积分

新手上路

Rank: 1

积分
12
显示全部楼层
前言

还有个迭代器，基础语法基本已经说完了，后面想到啥再补充，之后的教程会从以下方面来讲：

  • 基础库的使用，比如string、table等
  • 基础控件的使用，比如listview、tab等
  • aardio和Python交互，比如给Python写个界面
  • 自带的范例程序
  • 我写的一些小程序
当然，我的理解也是很基础的，特别是在界面设计上，我都是用的默认控件的默认设置，不会去自定义控件内容。要想做出特别炫酷的程序，你还得依赖其他语言和工具的基础。例如用HTML和CSS来实现界面。
元表、元方法

参考文档:

  • https://bbs.aardio.com/doc/reference/libraries/kernel/table/meta.html
  • https://bbs.aardio.com/doc/reference/the%20language/operator/overloading.html
主要是用于重载运算符和内置函数的行为。
表可以定义另一个表作为元表，然后在元表里定义元方法来定义操作符或内置函数操作表的一些行为。这种类似于Python的魔法方法，在Python中使用__eq__定义==的行为，而在aardio中用_eq元方法来定义==的行为。
初级使用例子

举个例子，python中print会调用对象的__str__或__repr__来打印一个对象，而aardio也是调用tostring来打印一个对象，但表默认并没有定义_tostring元方法，导致打印出来的内容是table: 03B2E3A8的格式
我们可以通过给表定义_tostring元方法，来使io.print或者console.log正常显示表
  1. import console;
  2. io.open()
  3. var tab = {
  4.         a=1;
  5.         b=2;
  6.         @{
  7.                 _tostring = function(...) {
  8.                     // 元方法里不能调用触发元方法的函数，比如_tostring里不能调用tostring
  9.                     // _get元方法可以通过[[k]]运算符来避开元方法,通过.和[]会触发_get，而[[]]不会
  10.                         return table.tostring(owner);
  11.                 }
  12.         }
  13. }
  14. io.print("没有定义元方法" , {});
  15. io.print("定义了元方法" , tab);
  16. console.pause(true);
复制代码
输出如下:
  1. 没有定义元方法  table: 03A8E2F8
  2. 定义了元方法    {
  3. a=1;
  4. b=2
  5. }
复制代码
运算符重载

这个就不细说了，应该很容易理解。
  1. io.open(); tab = { x=10 ; y=20 };
  2. tab2 = { x=12 ; y=22 }
  3. //c = tab + tab2; //这样肯定会出错，因为 table默认是不能相加的
  5. //创建一个元素，元表中的__add函数重载加运算符。
  6. tab@ = {
  7.         _add = function(b) {
  8.                 return owner.x + b.x
  9.         };
  10. }
  12. c = tab + tab2; //这时候会调用重载的操作符 tab@._add(tab2)
  13. io.print( c ) //显示22
复制代码
入门使用例子

还有一个很常用的元方法是_get和_set，是定义访问对象属性时触发的。利用这个可以让代码量少很多，看起来逻辑也更清晰。
这里举个实际例子，我在封装sunny的时候，遇到个很累人的事。sunny的dll导出函数，返回值有些是指针，你需要手动给他转成字符串，而且还需要手动释放这个指针指向的内存，也就是说你调用一次导出函数，就得写至少三行代码(调用、转字符串和释放)。
那么，有没有一种方法，定义完这个导出函数，在使用的时候就调用函数释放内存，并转成字符串返回，而不用我每次都手动释放和转字符串。
先定义request类，现在只需要给它定义一个messageId属性和_meta元方法：
  1. namespace sunny;
  3. class request{
  4.         ctor(messageId){
  5.                 this.messageId = messageId;
  6.         }
  7.         @_meta;
  8.        
  9. }
复制代码
@后面跟的是元表的名称，你可以将元表定义在名字空间里，这样看起来代码更舒服。下面在类的名字空间里定义dll方法和元表.
  1. namespace request{
  2.     //释放指针的函数
  3.         Free = ::SunnyDLL.api("Free","void(pointer p)");
  4.         // 下面的函数第一个参数都是messageId
  5.     DelRequestHeader = ::SunnyDLL.api("DelRequestHeader","void(int id,str h)");
  6.     GetRequestBodyLen = ::SunnyDLL.api("GetRequestBodyLen","int(int id)");
  7.         GetRequestBody = ::SunnyDLL.api("GetRequestBody","pointer(int id)");
  8.         // 定义一个中间方法
  9.     // name是要调用的导出函数，messageId则是导出函数的第一个参数
  10.         xcall = function(name, messageId, len){
  11.                 var func = self[name];
  12.                 if(!func) error("不支持的函数!");
  13.                 function proxyFunc(...){
  14.                         var v = func(messageId, ...);
  15.                         var result;
  16.                         if(type(v) == type.pointer){
  17.                                 if(len) result = ..raw.tostring(v,1,len);
  18.                                 else result = ..raw.tostring(v);
  19.                                 Free(v);
  20.                         }else{
  21.                                 result = v;
  22.                         }
  23.                         return result;
  24.                 }
  25.                
  26.                 return proxyFunc;
  27.         }
  28.         // 定义元表
  29.         _meta = {
  30.                 _get = function(k){
  31.                         return xcall(k, owner.messageId);
  32.                 }
  33.                
  34.         }
  35. }
复制代码
这个代码初看可能有点费劲，我们拆解着来看。
首先前面几行只是定义了四个dll的导出函数，然后下面定义了_meta这个表。
而_meta里只定义了一个元方法_get，它的作用是当你访问对象的属性时会触发这个方法，然后给你返回值。比如我先实例化一个request对象
  1. r = request(111111);
  2. // 当访问r.GetRequestBody时，这个对象没有GetRequestBody属性，所以会触发_get元方法
  3. // 得到的返回值就是 返回它的返回值也就是`xcall("GetRequestBody", owner.messageId)`.
  4. console.log(r.GetRequestBody)
复制代码
这里的owner就是指r这个对象。然后定义了xcall这个函数，它里面又定义了一个函数proxyFunc，并将它作为返回值，这种被称为闭包。先分析下xcall方法
  1. // 这里的self指的是当前名字空间，也就是request，name则是需要调用的方法名，例如是GetRequestBody
  2. // 这里func的值就等于GetRequestBody，也就是::SunnyDLL.api("GetRequestBody","pointer(int id)");
  3. var func = self[name];
  4. // 如果func是null的话，说明当前名字空间下没有这个函数，也就不是我们定义的sunny导出函数
  5. if(!func) error("不支持的函数!");
  6. // 定义了proxyFunc函数，`xcall(k, owner.messageId)`返回的值就是proxyFunc函数，这里的三个点表示传入任意个参数，类似于Python中的*args
  7. function proxyFunc(...){
  8.     // 调用GetRequestBody(messageId, ...)
  9.         var v = func(messageId, ...);
  10.         // 定义返回结果
  11.         var result;
  12.         // 如果结果是指针的话
  13.         if(type(v) == type.pointer){
  14.             // 就把它转为字符串，二进制数据需要指定长度，不然就是到\0结束
  15.                 if(len) result = ..raw.tostring(v,1,len);
  16.                 else result = ..raw.tostring(v);
  17.                 // 调用导出函数释放内存
  18.                 Free(v);
  19.         }else{
  20.             // 如果是其他类型数据就直接返回，比如数值或null
  21.                 result = v;
  22.         }
  23.         return result;
  24. }
复制代码
这样一番折腾，起了什么效果呢，看一下下面两段代码，如果不利用元方法的话，你使用dll导出函数得这么写
  1. // 导入request名字空间
  2. improt request;
  3. // 调用名字空间下的函数
  4. var messageId = 111111
  5. var pResult = request.GetRequestBody(messageId);
  6. // 将指针转为字符串
  7. var result = raw.tostring(pResult,1);
  8. // 释放内存
  9. request.Free(pResult);
  10. // 再使用其他导出函数也需要重复写这几行代码
复制代码
看着就几行代码，但是你想想调用一个函数都得写好几行，如果调用多次呢。而定义了xcall和_meta之后，只需要这样写代码:
  1. improt request;
  2. var messageId = 111111;
  3. var req = request(messageId);
  4. var result = req.GetRequestBody();
  5. // 后面调用都只需要用req.方法名()调用，不需要管raw.tostring和Free了
复制代码
因为req是可以复用的，所以我调用任何导出函数都只需要写一行代码，使用sunny库的代码也变得更简洁易懂了。
官方例子

给表创建一个代理，监控表属性的访问和设置：
  1. // 创建一个代理，为另一个table对象创建一个替身以监控对这个对象的访问
  2. function table.createProxy(tab) {
  3.     var real = tab;//在闭包中保存被代理的数据表tab
  4.     var _meta = {
  5.         _get = function(k){
  6.             io.print(k+"被读了");
  7.             return real[k];
  8.         };
  9.         _set = function (k,v){
  10.             io.print(k+"被修改值为"+v)
  11.             real[k]=v; //删除这句代码就创建了一个只读表
  12.         }
  13.     }
  14.     var proxy = {@_meta};//创建一个代理表
  15.    
  16.     return proxy; //你要访问真正的表？先问过我吧，我是他的经纪人！！！
  17. }
  19. //下面是使用示例
  21. tab = {x=12;y=15};
  22. proxy = table.createProxy(tab);//创建一个代理表，以管理对tab的存取访问
  24. io.open();
  25. c = proxy.x; //显示 "x被读了"
  26. proxy.y = 19; //显示 "y被修改值为19"
  27. io.print(proxy.y); //显示 "y被读了" 然后显示19
复制代码
所有的元方法

元方法/属性函数定义Python中的魔法方法说明_weak用不到_type属性type(obj)函数的行为_readonly属性等于false，_开头的成员也不是只读属性_defined感觉没啥用_keys属性可用于table.keys等函数动态获取对象的键名列表（例如动态生成键值对的外部JS对象可使用这个元方法返回成员名字列表_startIndex属性用于table.eachIndex等函数动态指定数组的开始下标。_getfunction(k,ownerCall)__getattr__和__getitem__如果读取表中不存在的键会触发_get元方法并返回值_setfunction(k,v)__setattr__和__setitem__当你给表的一个缺少的键赋值时会触发_set元方法_tostringfunction(...)__str__和__repr__tostring(obj, ...)_tonumberfunction()tonumber(obj)_jsonfunction()web.json.stringify(obj),可返回一个可被转化为json的值。或者返回一个字符串和true_toComObject用于自定义一个表对象如何转换为 COM 对象，可定义为函数，也可以直接定义为对象_eqfunction(b)__eq__ 和__ne__==和!=，比较对象时，两个对象的_eq必须是同一个_lefunction(b)__le__和__ge__=_ltfunction(b)__lt__和__gt___addfunction(b)__add__+_subfunction(b)__sub__-_mulfunction(b)__mul__*_divfunction(b)__truediv__/_lshiftfunction(b)__lshift__ 右移_modfunction(b)__mod__% 取模_powfunction(b)__pow__**幂运算_unmfunction()__neg__- 负号_lenfunction()__len__#取长运算符，Python中则为len函数_concatfunction(b)++ 连接运算符_call function(...)__call__对象当函数来调用属性元表

不仅可以给对象定义元表，也可以给对象的属性定义一个元表，有点类似于Python中的property，可以控制属性修改和获取的行为。
如果要看例子的话，可以在aardio的目录全局搜下@_metaProperty
以使用最多的属性text为例，基本每个控件都有一个text属性，你可以很方便的通过.text获取和修改空间显示的文字。
其实不用属性元表也能实现这个效果，代码如下：
  1. import console;
  2. class staticText{
  3.         getText = function(){
  4.                 ..console.log("获取到界面文本内容")
  5.         };
  6.         setText = function(v){
  7.                 ..console.log("将文本("+v+")显示到界面控件上")
  8.         }
  9.         @_meta;
  10. }
  12. namespace staticText{
  13.     _meta = {
  14.         _get = function(k){
  15.                 if(k == "text"){
  16.                     return owner.getText();
  17.                 }
  18.         };
  19.         _set = function(k,v){
  20.                 if(k == "text"){
  21.                     return owner.setText(v);
  22.                 }
  23.         }   
  24.     }
  25. }
  27. s = staticText()
  28. console.log(s.text);
  29. s.text = "修改文本";
  30. console.pause(true);
复制代码
但是如果属性多了的话，就需要一堆的if来判断属性，所以aardio作者就引入了metaProperty这个功能。这样写的代码看起来更简洁和清晰，用法如下：
  1. import console;
  2. import util.metaProperty;
  4. class staticText{
  5.         getText = function(){
  6.                 ..console.log("获取到界面文本内容")
  7.         };
  8.         setText = function(v){
  9.                 ..console.log("将文本("+v+")显示到界面控件上")
  10.         }
  11.         @_metaProperty;
  12. }
  14. namespace staticText{
  15.     _metaProperty = ..util.metaProperty(
  16.         text = {
  17.             _get = function(){
  18.                     return owner.getText();
  19.             };
  20.             _set = function(v){
  21.                     return owner.setText(v);
  22.             }
  23.         };
  24.         // 可以写其他属性
  25.     );
  26.     // 可以打印下_metaProperty看看
  27.     ..console.dump(_metaProperty);
  28. }
  30. s = staticText()
  31. console.log(s.text);
  32. s.text = "修改文本";
  33. console.pause(true);
复制代码
本文由博客一文多发平台 OpenWrite 发布！

来源:https://www.cnblogs.com/kanadeblisst/p/18084708
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！

上一篇: aardio教程三) 元表、元方法

下一篇: Python基于Excel生成矢量图层及属性表信息：ArcPy

发表于 2024-3-20 15:53:36

举报 回复 使用道具

返回列表 发新帖

Archiver|手机版|小黑屋|翼度科技

Copyright © 2001-2020, Tencent Cloud.　Powered by Discuz! X3.4