lua middleclass 学习记录

已于 2023-04-29 17:08:38 修改
阅读量188 收藏
点赞数
文章标签： lua 学习 开发语言
于 2023-04-29 16:58:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lele0503/article/details/130434806
版权

1. 创建类

local class = require "middleclass"
local parent = class("parent")

function middleclass.class(name, super)
  assert(type(name) == 'string', "A name (string) is needed for the new class")
  return super and super:subclass(name) or _includeMixin(_createClass(name), DefaultMixin)
end

setmetatable(middleclass, { __call = function(_, ...) return middleclass.class(...) end })

class调用通过middleclass的__call元方法调用到middleclass.class。在class函数中有两个不同的处理情况，如果传入父类，根据父类生成类模板，否则生成一个基类模板。

1.1 无基类情况

1.1.1 _createClass

无论是否有基类，首先都会通过_createClass函数创建类的基本模板：

local function _createClass(name, super)
  local dict = {}
  dict.__index = dict

  local aClass = { name = name, super = super, static = {},
                   __instanceDict = dict, __declaredMethods = {},
                   subclasses = setmetatable({}, {__mode='k'})  }

  if super then
    setmetatable(aClass.static, {
      __index = function(_,k)
        local result = rawget(dict,k)
        if result == nil then
          return super.static[k]
        end
        return result
      end
    })
  else
    setmetatable(aClass.static, { __index = function(_,k) return rawget(dict,k) end })
  end

  setmetatable(aClass, { __index = aClass.static, __tostring = _tostring,
                         __call = _call, __newindex = _declareInstanceMethod })

  return aClass
end

函数首先创建了类模板aClass，包含六个字段

名称含义
name类名称
super基类模板
static类静态函数（包含allocate、new、subclass、subclassed、isSubclassOf、include)
__instanceDict实例属性table（包含实例化出的对象拥有的函数，字段等），该table的__index字段指向自己
__declaredMethods类自身声明的属性，不包括继承来的
subclasses子类列表，key为弱引用

之后设置aClass的static字段的原表，当触发原表索引时，无论是否有父类，首先在aClass的__instanceDict中查找目标，如果没有找到且有父类，则会继续在父类的static中继续查找，所有的上表里列出的static函数只有在最上层基类的static字段中存储，最主要的使用就是调用new函数，不过从代码上看是可以通过类模板直接调用成员函数

local child = require "child"
child:func1()

最后设置aClass的元表，元表的__index指向aClass的static方法，因此通过类模板调用函数可以通过上述路径进行查找；__call函数设置为一个调用new方法的函数，因此可以不使用new进行实例化：

local function _call(self, ...) return self:new(...) end

local child = require "child"
local c1 = child() -- 等同于 child:new()

__newindex指向_declareInstanceMethod函数，该函数会将该类声明时的函数或字段添加到aClass的__declaredMethods字段中，并通过_propagateInstanceMethod函数将该函数或字段写入aClass的__instanceDict字段并通过递归调用_propagateInstanceMethod函数传递给所有子类

local function _declareInstanceMethod(aClass, name, f)
  aClass.__declaredMethods[name] = f

  if f == nil and aClass.super then
    f = aClass.super.__instanceDict[name]
  end

  _propagateInstanceMethod(aClass, name, f)
end

在_propagateInstanceMethod中对子类进行传播时会先判断aClass的__declaredMethods是否已经有同名的函数或字段，如果有则不覆盖，这样就达到了子类同名函数或字段覆盖父类值的目的

local function _propagateInstanceMethod(aClass, name, f)
  f = name == "__index" and _createIndexWrapper(aClass, f) or f
  aClass.__instanceDict[name] = f

  for subclass in pairs(aClass.subclasses) do
    if rawget(subclass.__declaredMethods, name) == nil then
      _propagateInstanceMethod(subclass, name, f)
    end
  end
end

从上面的代码可以看出，aClass中添加的所有新函数或字段都会存储到__instanceDict中。

1.1.2 _includeMixin & DefaultMixin

在类模板创建完成之后通过class函数通过调用_includeMixin函数将DefaultMixin中的字段拷贝到aClass对应字段里。首先先看DefaultMixin的内容：

local DefaultMixin = {
  __tostring   = function(self) return "instance of " .. tostring(self.class) end,

  initialize   = function(self, ...) end,

  isInstanceOf = function(self, aClass)
    return type(aClass) == 'table'
       and type(self) == 'table'
       and (self.class == aClass
            or type(self.class) == 'table'
            and type(self.class.isSubclassOf) == 'function'
            and self.class:isSubclassOf(aClass))
  end,

  static = {
    allocate = function(self)
      assert(type(self) == 'table', "Make sure that you are using 'Class:allocate' instead of 'Class.allocate'")
      return setmetatable({ class = self }, self.__instanceDict)
    end,

    new = function(self, ...)
      assert(type(self) == 'table', "Make sure that you are using 'Class:new' instead of 'Class.new'")
      local instance = self:allocate()
      instance:initialize(...)
      return instance
    end,

    subclass = function(self, name)
      assert(type(self) == 'table', "Make sure that you are using 'Class:subclass' instead of 'Class.subclass'")
      assert(type(name) == "string", "You must provide a name(string) for your class")

      local subclass = _createClass(name, self)

      for methodName, f in pairs(self.__instanceDict) do
        if not (methodName == "__index" and type(f) == "table") then
          _propagateInstanceMethod(subclass, methodName, f)
        end
      end
      subclass.initialize = function(instance, ...) return self.initialize(instance, ...) end

      self.subclasses[subclass] = true
      self:subclassed(subclass)

      return subclass
    end,

    subclassed = function(self, other) end,

    isSubclassOf = function(self, other)
      return type(other)      == 'table' and
             type(self.super) == 'table' and
             ( self.super == other or self.super:isSubclassOf(other) )
    end,

    include = function(self, ...)
      assert(type(self) == 'table', "Make sure you that you are using 'Class:include' instead of 'Class.include'")
      for _,mixin in ipairs({...}) do _includeMixin(self, mixin) end
      return self
    end
  }
}

DefaultMixin是一个table，包含了三个实例函数和一个静态函数列表。_includeMixin 函数主要会将这些不同的函数分别拷贝的aClass的不同字段里

local function _includeMixin(aClass, mixin)
  assert(type(mixin) == 'table', "mixin must be a table")

  for name,method in pairs(mixin) do
    if name ~= "included" and name ~= "static" then aClass[name] = method end
  end

  for name,method in pairs(mixin.static or {}) do
    aClass.static[name] = method
  end

  if type(mixin.included)=="function" then mixin:included(aClass) end
  return aClass
end

首先对于key不为"included"（或者"static"的值，会直接插入aClass中，由于aClass的__newindex指向_declareInstanceMethod函数，因此DefaultMixin中定义的非static函数都会被最终设置到aClass的__instanceDict中。static函数会被设置到aClass的static字段中。included没有找到相关的声明，不懂这个是啥。。。。

总结一下，在没有基类时，创建一个类模板，会首先创建一个aClass的table，包含名称、基类、字段、子类等信息，并设置该table的元表，元表的__index指向aClass的static字段，可以使用类模板调用静态函数；__call指向一个调用new的函数，可以直接通过类模板创建实例对象；__newindex指向一个函数，该函数把新增函数或字段都填入__instanceDict和__declaredMethods中。

通过断点看一下具体的内容：

在这里插入图片描述
当调用完成class方法，parent类应该只包含默认的信息：
在这里插入图片描述
再往下走一步，添加member1之后，可以看到__instanceDict和__declaredMethods中都加入了member1的数值
在这里插入图片描述

1.2 有基类情况

有基类的情况会调用基类的subclass函数

function middleclass.class(name, super)
  assert(type(name) == 'string', "A name (string) is needed for the new class")
  return super and super:subclass(name) or _includeMixin(_createClass(name), DefaultMixin)
end

前文提到subclass是DefaultMixin中定义的一个static函数，因此通过类模板进行调用。函数首先通过_createClass创建一个模板，之后通过_propagateInstanceMethod将模板的__instanceDict除了table类型的__index之外的字段复制给子类模板，之后将子类的初始化函数设置为调用父类初始化函数的封装，并将子类模板注册给父类模板的subclasses字段中，并调用父类的subclassed静态方法。

subclass = function(self, name)
  assert(type(self) == 'table', "Make sure that you are using 'Class:subclass' instead of 'Class.subclass'")
  assert(type(name) == "string", "You must provide a name(string) for your class")

  local subclass = _createClass(name, self)

  for methodName, f in pairs(self.__instanceDict) do
    if not (methodName == "__index" and type(f) == "table") then
      _propagateInstanceMethod(subclass, methodName, f)
    end
  end
  subclass.initialize = function(instance, ...) return self.initialize(instance, ...) end

  self.subclasses[subclass] = true
  self:subclassed(subclass)

  return subclass
end,

这里有个问题，父类向子类拷贝对象时是浅拷贝，因此像member2这种字段如果像测试代码中这么声明会导致所有的实例化对象引用的是同一个值

local child = require "child"

local c1 = child()
local c2 = child()

c1.member2.value = 30
c2.member2.value = 40
print(c1.member2.value, c2.member2.value)

上面代码的输出为
40 40
使用时要注意这个问题，可以在initialize函数中创建避免这个问题：

function parent:initialize()
    self.member3 = {
        value = 1
    }
    print("parent initialize")
end

2 实例化对象

根据前文所述，在调用new函数时，会调用到最顶层基类static中的new方法，也就是DefaultMixin中定义的new方法

allocate = function(self)
  assert(type(self) == 'table', "Make sure that you are using 'Class:allocate' instead of 'Class.allocate'")
  return setmetatable({ class = self }, self.__instanceDict)
end,

new = function(self, ...)
  assert(type(self) == 'table', "Make sure that you are using 'Class:new' instead of 'Class.new'")
  local instance = self:allocate()
  instance:initialize(...)
  return instance
end,

实例化的对象中只有一个class指向类模板，并将元表设置为类模板的__instanceDict字段，在用实例调用函数或者访问字段时访问的是__instanceDict对应的属性。

3 其他函数说明

3.1 isInstanceOf

该函数用来判断某个实例的类型是否是制定类模板，从函数实现上看也会判断实例的类型是否是继承自制定类模板

  isInstanceOf = function(self, aClass)
    return type(aClass) == 'table'
       and type(self) == 'table'
       and (self.class == aClass
            or type(self.class) == 'table'
            and type(self.class.isSubclassOf) == 'function'
            and self.class:isSubclassOf(aClass))
  end,

isSubclassOf = function(self, other)
      return type(other)      == 'table' and
             type(self.super) == 'table' and
             ( self.super == other or self.super:isSubclassOf(other) )
    end,

3.2 _createIndexWrapper

对类模板自定义的__index进行封装，没有用过，希望有大佬能帮说明一下

local function _createIndexWrapper(aClass, f)
  if f == nil then
    return aClass.__instanceDict
  elseif type(f) == "function" then
    return function(self, name)
      local value = aClass.__instanceDict[name]

      if value ~= nil then
        return value
      else
        return (f(self, name))
      end
    end
  else -- if  type(f) == "table" then
    return function(self, name)
      local value = aClass.__instanceDict[name]

      if value ~= nil then
        return value
      else
        return f[name]
      end
    end
  end
end

3.3 include

DefaultMixin中定义的static函数，可以把其他table中的内容插入到类声明中

-- staticfunc.lua
return {
    extraFunc = function ()
        print("extraFunc")
    end,

    static = {
        extraStaticFunc = function ()
            print("extraStaticFunc")
        end,
    }
}

local class = require "middleclass"
local staticfunc = require "staticfunc"
local parent = class("parent") : include(staticfunc)

local child = require "child"

local c1 = child()
c1:extraFunc()
child:extraStaticFunc()

测试代码

-- parent.lua
local class = require "middleclass"
local staticfunc = require "staticfunc"
local parent = class("parent") : include(staticfunc)

parent.member1 = 1
parent.member2 = {
    value = 1
}

function parent:initialize()
    self.member3 = {
        value = 1
    }
    print("parent initialize")
end

function parent:func1()
    print("parent func1")
end

return parent

-- child.lua
local class = require "middleclass"
local parent = require "parent"
local child = class("child", parent)

function child:initialize()
    child.super.initialize(self)
    print("child initialize")
end

return child
单色光光
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
middleclass.lua分析
龙小龍的博客
07-12 1872
-- middleclass.lua - v2.0 (2011-09) --记录所有由这个体系建立的表，用来记录创建的所有类表 local _classes = setmetatable({}, {__mode = "k"}) --类元表字典  klass为传入的表  即代表一个类   用来给这个klass类表的static表建立访问关系，关系如下注释 local functi
lua middleclass 的一个要注意的问题,静态属性
NRatel
08-09 1472
lua 中没有类， lua middleclass 实现了类。 github地址： https://github.com/kikito/middleclass 今天写代码的时候遇见一个问题，纠结了一下午。  最后发现  用middleclass，实例化多个对象时，好像后面的对象会覆盖前面对象的 其基类中的属性。 做了个测试如下： 类A，（类B的基类）： 类
lua类库 middleclass学习笔记
weixin_34406086的博客
08-14 138
middleclass使在lua中面象对象变的简单 抄了一遍他的示例代码运行着试了试，基本懂了 local class = require 'middleclass' --类的继承 Person = class('Person') --定义一个Person类 function Person:initialize(name) --构造函数 self.name = na...
推荐开源项目：Middleclass——Lua的简单面向对象库
最新发布
gitblog_00070的博客
05-13 357
推荐开源项目：Middleclass——Lua的简单面向对象库 项目地址:https://gitcode.com/kikito/middleclass Middleclass 是一个专为 Lua 设计的轻量级面向对象编程（OOP）库，它提供了继承、元方法（操作符）、类变量以及弱化的混入支持。如果你在寻找一种简洁易用的方式来为你的 Lua 应用程序引入 OOP 概念，那么 Middleclass 将...
middleclass源码阅读笔记
平凡者的专栏
05-27 713
middleclass源码阅读笔记 lua中的面向对象(纯lua实现)思路按照新类的建立流程类的建立: 1,由middleclass直接创造出来的为类,或者父类源码解析 1. _createClasss(aClass, super)name 类名 string super 父类表 (没有父类时不存在这个域) static 静态表 __instanceDict 实例表 存放类
lua 学习记录
qq_40133830的博客
01-26 128
2021/01/26 一、lua 字符串原理： 与c#字符串不变性一致
Lua学习笔记之表达式
09-22
【Lua学习笔记之表达式】 在Lua编程语言中，表达式是构成程序的基本元素，用于表示计算或逻辑操作。表达式的结果可以是一个值，也可以是一个布尔值，这取决于执行的操作。下面我们将深入探讨Lua中的各种表达式类型...
Lua学习笔记之类型与值
09-22
本文详细的总结了Lua中的类型与值，对于实际编程中容易出错的地方也进行了详细的总结，十分的全面实用。有需要的小伙伴可以参考下。
lua基础学习笔记
03-05
有其他语言基础学习lua入门是比较快的，主要是学习lua跟其他语言的一些区别，一些特性
Lua表达式和控制结构学习笔记
01-02
Lua 的算术操作符有： “+”（加法）： 代码如下: print(1 + 2) “-“（减法）： 代码如下: print(2 – 1) “*”（乘法）： 代码如下: print(1 * 2) “/”（除法）： 代码如下: print(1 / 2) “^”（指数）...
lua面向对象编程类库笔记
05-27
lua面向对象编程类库笔记(源码中)
middleclass, Lua的对象方向.zip
10-11
middleclass, Lua的对象方向 MiddleClass 一个面向Lua的简单。 它具有继承。metamethods ( 运算符) 。类变量和弱mixin支持。快速查看local class = require 'middleclass'loca
lua学习资料lua学习资料lua学习资料lua学习资料lua学习资料
11-23
首先，从标题和描述中我们可以看出，这个资料包专门针对Lua学习，反复提及“lua学习资料”，表明其内容可能包括教程、示例代码、练习题等，全面覆盖了学习的各个环节。 在标签中提到了“lua 课程资源”，这可能意味...
lua 常用语法
过期的码农
02-21 1314
// 读取ccb文件 self.layer = CCBuilderReaderLoad("jiLuLayer.ccbi",CCBProxy:create(),self) // 强转类型 self.layer = tolua.cast(self.layer,"CCLayer") 等价于 #ttable.getn(t)但是它计算的是数组元素。不包括hash 键值。而且数组是
LUA 面向对象
~。~|||
01-10 6985
类继承的实现方式有三种类式继承、原型继承、掺元继承。 lua是采用类式继承。 1. PIL中的例子 http://book.luaer.cn/_98.htm 2.云风的例子 http://blog.codingnow.com/2006/06/oo_lua.html 定义类的函数 ->类的vtbl（除ctor super new外，这3个是定义在 类.xxx 中，而不是 vtbl
lua--面向对象使用middleclass
weixin_34187822的博客
12-27 188
昨天本来还想写一篇love2d之角色移动的,可是不知怎么回事, 我在一个类里有setXY(),在love.load()里调用了,可是居然没 按我的预想坐标,而是直接显示在了顶点.后来各种print,发现 确实是调用了,但就是不显示,郁闷,只好作罢. 后来也想不出原因,于是又看了一下lua面向对象,想到以后可能 很多地方会用到类,便想找一个简洁的lua面向对象的扩展.先推荐一个很好的lua...
Lua middleclass(v4.1) 解析
wuwangxinan的专栏
08-08 615
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
Lua 自己实现类Class代码，和高级用法
heyuchang666的专栏
08-22 4500
### 高级用法class() 除了定义纯 Lua 类之外，还可以从 C++ 对象继承类。比如需要创建一个工具栏，并在添加按钮时自动排列已有的按钮，那么我们可以使用如下的代码。class() 的这种用法让我们可以在 C++ 对象基础上任意扩展行为。既然是继承，自然就可以覆盖 C++ 对象的方法：注意:** Lua 继承类覆盖的方法并不能从 C++ 调用到。也就是说通过 C++ 代码调用这个 cc.Node 对象的 setPosition() 方法时，并不会执行我们在 Lua 中定义的 Toolbar:set
lua脚本学习：从入门到实战技巧
《lua脚本学习》是一份面向初学者的资源，特别适合那些想要将C++和Lua进行混合编程的人。这份资料包含了两部分：《Programming in Lua》和《Simple is Beautiful》，由 Roberto Ierusalimschy 所著，版权由 luachina...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值