Lua优化内存

Question

I what to optimize my code. I have 3 option don't know which is better for memory in Lua:

1)

local Test = {}
    Test.var1 = function ()
        -- Code
    end

    Test.var2 = function ()
        -- Code
    end

2) Or

function var1()
    -- Code
end

function var2()
    -- Code
end

3) Or maybe

local var1 = function ()
    -- Code
end

local var2 = function ()
    -- Code
end

Answer 1

Quoting from Lua Programming Gem , the two maxims of program optimization:

• Rule #1: Don't do it.
• Rule #2: Don't do it yet. (for experts only)

Back to your examples, the second piece of code is a little bit worse as the access to global ones is slower. But the performance difference is hardly noticeable.

It depends on your needs, the first one uses an extra table than the third one, but the namespace is cleaner.

Answer 2

None will really affect memory, barring the use of a table in #1 (so some 40 bytes + some per entry).

If its performance you want, then option #3 is far better, assuming you can access said functions at the local scope.

Answer 3

If it's about memory usage more than processing and you're using object-oriented programming where you're instantiating multiple instances of Test as you showed above, you have a fourth option with metatables.

TestMt = {}
TestMt.func1 = function(self, ...)
    ...
end
TestMt.func2 = function(self, ...)
    ...
end
TestMt.func3 = function(self, ...)
    ...
end

function new_test()
    local t = {}
    t.data = ...
    setmetatable(t, {__index = TestMt})
    return t
end

foo = new_test()
foo:func1()
foo:func2()
foo:func3()

If you're doing object-oriented kind of programming, metatables can lead to a massive savings in memory (I accidentally used over 1 gigabyte once for numerous mathematical vectors this way, only to reduce it down to 40 megabytes by using the metatable).

If it's not about objects and tables that get instantiated many times, and just about organizing your globally-accessible functions, worrying about memory here is ridiculous. It's like putting the entirety of your lua code into one file in order to reduce file system overhead. You're talking about such negligible savings that you should really need an extraordinary use case backed by meticulous measurements to even concern yourself with that.

If it's about processing, then you can get some small improvements by keeping your global functions out of nested tables, and by favoring locals when possible.