What does this code do?

[Codger]

I've seen this in a couple addons but haven't been able to find any info on what it does:

local frame1 = {}
myAddon.frame1 = frame1

I'm guessing it's another way of setting up a namespace?
What I am doing in an addon is:

local addonName, addonTable = ...
function addonTable:doSomething()

which requires me to preface everywhere I use doSomething() with addonTable.
Curious if this is a better way?

[Xrystal]

Yep, looks like it.

I use

local addonName, addonTable = ...

at the top of each of my lua files and give them their own sub table for their functionality and data.

For example - if I were to have my own ButtonManager for some reason I could have something like this

addonTable.ButtonManager = {}

And then I could create addon wide functions like this

addonTable.ButtonManager.Create = function(...)
end

I still use the regular local variables and functions if no other file needs to access it.
Or global functions if I want external addons access to certain variables or functions - uniquely named of course and validated

You could simplify the addonTables accessors as follows ( using the previous example )

-- Create the files data table
addonTable.ButtonManager = {}
 
-- Simplify it
local bm = addonTable.ButtonManager
 
-- Use it
bm.Create = function(...)
end

But I only do that if it's more than 5/10 lines worth of copying and pasting of the table.

[Fizzlemizz]

function addonTable:doSomething()

It's a matter of what scope you want the function/variable to have

• Added to global table, All addons have acess to it.
• Added to "namespace" table, the current addon has access in all its .lua files
• local at the root level of a .lua file - code below it in that .lua file has access
• local inside a code chunk (if, for, anything with an "end" statement) - only code inside the chunk after the local declaration has access.

This is also effected by load sequence (.toc order). Eg. you can't use a function added to the namespace table before the file it is declared in has been loaded.

.toc

file1.lua
file2.lua

file1.lua

local addon, ns = ...
ns:RunFunc()

file2.lua

local addon, ns = ...
function ns:RunFunc()
    print("Are we here yet?")
end

Errors because file1 is loaded before file2 has a chance to "create" the function.

Consider your .lua files as functions in their own right

BlizzardSpace["NameOfTheAddon"] = {}
function file1.lua("NameOfTheAddon", BlizzardSpace["NameOfTheAddon"])
    local addon, ns = ... -- your code goes here
    -- etc. etc.
end
function file2.lua("NameOfTheAddon", BlizzardSpace["NameOfTheAddon"])
    local addon, ns = ... -- your code goes here
    -- etc. etc.
end

(generalised representation)

[SDPhantom]

Originally Posted by Codger local frame1 = {} myAddon.frame1 = frame1 I'm guessing it's another way of setting up a namespace?

On the surface, this is just storing one table into another and keeping a local reference to it. Taking the rest of the message into account, I'm assuming the real question is, "What is the 'local reference' for?"

A local used in this way is acting as a cache as it's quicker to access than trying to grab it from the table again. Trying to grab anything from a table is known as an "index operation". Just like any other operation, this takes time, which can add up. In the grand scheme of things, doing this isn't going to cause a noticeable effect unless the affected code is running very frequently, like in loops, OnUpdate scripts, or combat log events.

Originally Posted by Codger What I am doing in an addon is: local addonName, addonTable = ... function addonTable:doSomething() which requires me to preface everywhere I use doSomething() with addonTable. Curious if this is a better way?

The equivalent to implementing it in this code would be either of the following.

local addonName, addonTable = ...
 
local function doSomething(self)
end
 
addonTable.doSomething = doSomething

-or-

local addonName, addonTable = ...
 
function addonTable:doSomething()
end
 
local doSomething = addonTable.doSomething

The first one may be used if you're defining a function that is also used in the same file, then have a chunk exporting your local definitions to your addon table.
The second one is more useful if the function was defined in another file and you want to create a local reference for speed.



Keep in mind:

A call v:name(args) is syntactic sugar for v.name(v,args), except that v is evaluated only once.

-Lua 5.1 Reference Manual - (§2.5.8) Function Calls

The colon syntax is used for defining methods, that is, functions that have an implicit extra parameter self. Thus, the statement function t.a.b.c:f (params) body end is syntactic sugar for t.a.b.c.f = function (self, params) body end

-Lua 5.1 Reference Manual - (§2.5.9) Function Definitions

The dot notation better reflects how the function exists in memory and the colon notation is a modifier on how to define or call it. There's no way to use the colon notation when calling from or defining as a local.