lua - 这两个 Lua 示例有什么区别？一个更好吗？

Question

我刚刚开始使用 Lua。在我学习的示例(the Ghosts & Monsters Corona open source)中，我反复看到这种模式。

local director = require("director")

local mainGroup = display.newGroup()

local function main()

   mainGroup:insert(director.directorView)

   openfeint = require ("openfeint")
   openfeint.init( "App Key Here", "App Secret Here", "Ghosts vs. Monsters", "App ID Here" )

   director:changeScene( "loadmainmenu" )

   return true
end

main()

这是有经验的 Lua 程序员推荐的某种约定，还是这样做有真正的优势？您为什么不一起跳过该功能并执行以下操作:

local director = require("director")

local mainGroup = display.newGroup()

mainGroup:insert(director.directorView)

local openfeint = require ("openfeint")
openfeint.init( "App Key Here", "App Secret Here", "Ghosts vs. Monsters", "App ID Here" )

director:changeScene( "loadmainmenu" )

第一种风格比第二种风格有什么隐含的好处吗？谢谢!

Answer 1

Is this some sort of convention experienced Lua programmers recommend or are there genuine advantages to doing it this way?

这不是典型的。优点是对象状态是私有(private)的，但这还不足以推荐它。

I see this pattern repeatedly.

我以前从未见过它，而且它只在您发布的来源中发生过一次。

编辑:添加对本文下方评论中提出的问题的回复。

访问外部局部变量的函数绑定(bind)到这些变量，称为“闭包”。 Lua(出于历史原因)将这些绑定(bind)变量称为“上值”。例如:

local function counter()
   local i = 1
   return function()
      print(i)
      i = i + 1
   end
end

local a, b = counter(), counter()
a() a() a() b() --> 1 2 3 1

a和 b闭包是否绑定(bind)到 i 的不同副本？ ，从输出中可以看出。换句话说，您可以将闭包视为具有自己私有(private)状态的函数。您可以使用它来模拟对象:

function Point(x,y)
   local p = {}
   function p.getX() -- syntax sugar for p.getX = function()
      return x
   end
   function p.setX(x_)
      x = x_
   end
   -- for brevity, not implementing a setter/getter for y
   return p
end

p1 = Point(10,20)
p1.setX(50)
print(p1.getX())

Point返回一个闭包表，每个都绑定(bind)到本地 x和 y .该表不包含点的状态，闭包本身通过它们的 upvalues 包含。重要的一点是，每次 Point称为它创建新的闭包，如果您有大量对象，这不是很有效。

在 Lua 中创建类的另一种方法是创建将表作为第一个参数的函数，状态存储在表中:

function Point(x,y)
   local p = {x=x,y=y}
   function p:getX() -- syntax sugar for p.getX = function(self)
      return self.x
   end
   function p:setX(x)
      self.x = x
   end
   return p
end

p1 = Point(10,20)
p1:setX(50) -- syntax sugar for p1.setX(p1, 50)
print(p1:getX()) -- syntax sugar for p1.getX(p1)

到目前为止，我们仍在为每个方法创建新副本，但现在我们不依赖于状态的上值，我们可以解决这个问题:

PointClass = {}
function PointClass:getX() return self.x end
function PointClass:setX(x) self.x = x end
function Point(x,y)
   return {
      x = x,
      y = y,
      getX = PointClass.getX,
      setX = PointClass.getY,
   }
end

现在方法创建一次，所有 Point实例共享相同的闭包。一个更好的方法是使用 Lua 的元编程工具来创建新的 Point实例自动查找 PointClass对于在实例本身中找不到的方法:

PointClass = {}
PointClass.__index = PointClass -- metamethod
function PointClass:getX() return self.x end
function PointClass:setX(x) self.x = x end
function Point(x,y)
   return setmetatable({x=x,y=y}, PointClass)
end

p1 = Point(10,20)
-- the p1 table does not itself contain a setX member, but p1 has a metatable, so 
-- when an indexing operation fails, Lua will look in the metatable for an __index
-- metamethod. If that metamethod is a table, Lua will look for getX in that table,
-- resolving p1.setX to PointClass.setX.
p1:setX(50)

这是在 Lua 中创建类的更惯用的方式。它更节省内存且更灵活(特别是，它使实现继承变得容易)。