Scripting Helpers is winding down operations and is now read-only. More info→

What is the use of a weak table and strong table?

Asked by

saSlol2436 716

6 years ago

Edited 6 years ago

My Understanding

I came across the words, weak tables and strong tables. I have done some research; this is what I understood from the terms:

Weak tables can have weak keys. Weak tables can have weak values. Weak tables can have weak keys and weak values. The garbage collector can return the memory of weak references.

I am assuming that strong tables are the opposite.

To make a table have weak keys, you can use the metamethod __mode.

1local t
2t = {}
3setmetatable(t, {__mode = "k"})

To make a table have weak values, you type in "v".

1local t
2t = {}
3setmetatable(t, {__mode = "v"})

So, what is really the question?

The question is, what is the use of weak tables and strong tables. Please connect this with some type of everyday coding life. If I did miss anything about these types of tables, please put them in your answer.

Sources: Lua.org source Roblox Developer Wiki

Nobody really says "strong table", a table merely has weak keys and/or values or doesn't. Avigant 2374 — 6y

1 answer

Answered by

EgoMoose 802

6 years ago

I can't say I've ever heard of strong tables before so I can't provide much insight for that. Weak tables however I understand a bit better.

The first thing I'll say is that weak tables have limited uses. If you find yourself trying to use them when there's a another solution you're probably just making life more difficult for yourself. That being said, when using them correctly they're extremely useful.

I think the most important line from the wiki in regards to weak tables is the following: "If a reference to an object is only held inside weak tables, Lua will collect the object eventually."

What this means is that depending on our mode if the keys or values or one of the two (both) aren't referenced anywhere else in the active code their entry will be removed from the table.

Let's look at some examples:

Note: the garbage may not collect in the 1 second interval so if having difficulties either run again or change the wait time.

01local t = setmetatable({}, {__mode = "k"});
02local k = game.Workspace.Part; -- say this exists
03t[k] = "Value";
04 
05for k, v in next, t do print(k, v); end -- Part, Value
06wait(1);
07k = nil; -- no longer any reference to the key other than in the weak table
08-- the key and value still print though b/c garbage has not collected yet
09for k, v in next, t do print(k, v); end -- Part, Value
10wait(1); -- wait for garbage to collect
11for k, v in next, t do print(k, v); end -- nothing...
12print("Done.")

Now looking at values:

01local t = setmetatable({}, {__mode = "v"});
02local v = game.Workspace.Part; -- say this exists
03t["Key"] = v;
04 
05for k, v in next, t do print(k, v); end -- Key, Part
06wait(1);
07v = nil; -- no longer any reference to the value other than in the weak table
08-- the key and value still print though b/c garbage has not collected yet
09for k, v in next, t do print(k, v); end -- Key, Part
10wait(1); -- wait for garbage to collect
11for k, v in next, t do print(k, v); end -- nothing...
12print("Done.")

Finally keys and values:

01local t = setmetatable({}, {__mode = "kv"});
02local k = game.Workspace.Part1;
03local v = game.Workspace.Part2;
04t[k] = v;
05 
06for k, v in next, t do print(k, v); end -- Part1, Part2
07wait(1);
08v = nil; -- no longer any reference to the value other than in the weak table
09-- the key and value still print though b/c garbage has not collected yet
10for k, v in next, t do print(k, v); end -- Part1, Part2
11wait(1); -- wait for garbage to collect
12for k, v in next, t do print(k, v); end -- nothing...
13print("Done.")
14 
15-- OR
16 
17local t = setmetatable({}, {__mode = "kv"});
18local k = game.Workspace.Part1;
19local v = game.Workspace.Part2;
20t[k] = v;
21 
22for k, v in next, t do print(k, v); end -- Part1, Part2
23wait(1);
24k = nil; -- no longer any reference to the key other than in the weak table
25-- the key and value still print though b/c garbage has not collected yet
26for k, v in next, t do print(k, v); end -- Part1, Part2
27wait(1); -- wait for garbage to collect
28for k, v in next, t do print(k, v); end -- nothing...
29print("Done.")
 View all 29 lines...

I think the main thing you need to be wary other than setting variables to nil explicitly is scope. If you create entries in a table using variables that are local in scope they will become nil when you leave that scope. Here's what I mean:

01local t = setmetatable({}, {__mode = "k"});
02 
03do
04    -- new scope
05    local k = game.Workspace.Part;
06    t[k] = "Value";
07end
08 
09-- prints eb/c garbage not collected yet
10for k, v in next, t do print(k, v); end
11 
12wait(3); -- collect garbage
13 
14-- nothing prints
15for k, v in next, t do print(k, v); end

So when is this useful? I personally have found this most useful for OOP (object oriented programming). We can use weak-tables to store private-values that we don't want the user to mess with in the class.

Here's an example:

01local class = {};
02local class_mt = {__index = class};
03local class_ref = setmetatable({}, {__mode = "k"});
04 
05function class.new(x, y)
06    local self = {};
07    self.x = x;
08    self.y = y;
09    self = setmetatable(self, class_mt);
10    class_ref[self] = {};
11    class_ref[self].magnitude = math.sqrt(x*x + y*y);
12    return self;
13end
14 
15function class:getMagnitude()
16    return class_ref[self].magnitude;
17end
18 
19local a = class.new(1, 2, 3);
20local b = class.new(-3, 7, 32/4*(-8));
21 
22print(a.x, b.y);
23print(a:getMagnitude());
24 
25-- both entries class_ref[a] and class_ref[b] exist
26for k, v in next, class_ref do print(k, v); end
27 
28b = nil; 
29-- note: b was the only reference to this object outside a weak table
30 
31wait(1); -- garbage collection
32 
33-- only entry class_ref[a] exists
34for k, v in next, class_ref do print(k, v); end
 View all 34 lines...

Of course these "private" values could be accessed as long as the programmer has access to the class_ref table, but if you're writing your class in a module then it's as simple as not returning said table. I use this exact technique to store cframe components in my lua cframe class.

Hope this helped clear some stuff up.

What is the use of a weak table and strong table?

My Understanding

So, what is really the question?

1 answer

Answer this question