Expanding tables with loops

[Hati-EK]

I have a simple question ... my current test code (tested in Wowlua and Omnibus, both times the same error) seems to have a bug - but i am unable to get it ...


Error Message: attempt to index field '?' ( a nil value )

Testcode:

local x = {}
local k = 1

while name~=nil do
   local name,rank,rankIndex,level,LOclass,zone,_,_,online,status,englishClass =GetGuildRosterInfo(k)
   x[k].n="Test"
   x[k].r=rank
   x[k].l=level
   x[k].c=LOclass
   x[k].z=zone
   x[k].on=online
   x[k].realClass=englishClass
   k=k+1
end

DEFAULT_CHAT_FRAME:AddMessage(x[1].n)

hope someone can enlight me

[DreamStorm]

I am kind of new to this lua game myself, so apologies if I am a little off the mark ....

I am assuming that you wish to create the data in the table from the returns from the GetGuildRosterInfo() method. Your while loop is set to test the name part of the return but you haven't got a value for that before you enter the loop; at least not the value you wish. As it is the while loop is essentially evaluating a global variable for nil value. I don't know if there is a global variable called name but if there isn't you're loop will never start as if will only do so if the value is not (~=) nil.

I think you would need to run that method outside the loop, then enter it, set the values and within the loop (at the end) rerun the method. I am not sure how lua handles reusing the varables in this way though. Something like ...

local x = {}
local k = 1

local name,rank,rankIndex,level,LOclass,zone,_,_,online,status,englishClass =GetGuildRosterInfo(k)
while name~=nil do
   x[k].n="Test"
   x[k].r=rank
   x[k].l=level
   x[k].c=LOclass
   x[k].z=zone
   x[k].on=online
   x[k].realClass=englishClass
   k=k+1   
   name,rank,rankIndex,level,LOclass,zone,_,_,online,status,englishClass =GetGuildRosterInfo(k)
end

DEFAULT_CHAT_FRAME:AddMessage(x[1].n)

You may have to give the returns from the method more specific global names rather than declare them local. Please someone correct me if I am wrong.

[Tuhljin]

DreamStorm is right about name using the global variable name instead of the local one you want, but the actual error message is due to your trying to index a non-existent table. Try something like this:

local x = {}
local k = 1

-- Get name before the while loop:
local name,rank,rankIndex,level,LOclass,zone,_,_,online,status,englishClass =GetGuildRosterInfo(k)

while name~=nil do
   x[k] = {}
   x[k].n="Test"
   x[k].r=rank
   x[k].l=level
   x[k].c=LOclass
   x[k].z=zone
   x[k].on=online
   x[k].realClass=englishClass
   k=k+1
   name,rank,rankIndex,level,LOclass,zone,_,_,online,status,englishClass =GetGuildRosterInfo(k)
end

DEFAULT_CHAT_FRAME:AddMessage(x[1].n)

[Hati-EK]

yea thanks :P - after i went to bed yesterday ... it was quite clear to me ... maybe it was just to late ...

x[k] = {}
-> creates the indicies ?

like
x = {
[1] = { }
}

?

[Mera]

yup in short you are using 2 tables without saying the second time the second is a table

[Hati-EK]

Question:
if i use 'break' like

for i=1,10 do
 while j<=x do
  if bla==1 then
   value1 = i
   value2 = j
   break
  end
 end
end

will the 'break'-command escape the for-loop too?

[Slakah]

Work it out for yourself.

Put this code

local t, i = {cat = 1, dog = 2}, 0
print("going")
for _, _ in pairs(t) do
   print("in for loop")
   while true do
      break
   end
   i = i + 1
   if i == 2 then
      print("Break does not break for loop")
   end
end

here http://www.lua.org/cgi-bin/demo

[tsadok]

Originally Posted by Hati-EK yea thanks :P - after i went to bed yesterday ... it was quite clear to me ... maybe it was just to late ... x[k] = {} -> creates the indicies ? like x = { [1] = { } } ?

Nearly... x[k] = {} requires x to be declared as a table, and x = { [1] = { } } declares both x and x[1] (using two sets of {} )

[Mera]

note that I did further test and creating multiple tables with loops in one table takes way much memory than creating multiple stable tables and just changing key and values without calling at other tables inside, I think it allocates way much memory and create a quite big garbarge for nothing helpful

[ZikO]

Originally Posted by Mera note that I did further test and creating multiple tables with loops in one table takes way much memory than creating multiple stable tables and just changing key and values without calling at other tables inside, I think it allocates way much memory and create a quite big garbarge for nothing helpful

That's too bad IMO. Tables in tables etc are great structures which help keeping the code tidy. I would like it but unfortunately it takes too much memory, sadly.

[Hati-EK]

Originally Posted by Mera note that I did further test and creating multiple tables with loops in one table takes way much memory than creating multiple stable tables and just changing key and values without calling at other tables inside, I think it allocates way much memory and create a quite big garbarge for nothing helpful

to say it simple:

Using 1dim tables is more efficient in speaking of memory usage than 2dim tables? dim = dimension
^ Ydim
|
|
-------> Xdim

?

and what about 1 stable 2dim-table - which is created once - required the whole time ... and just values are changed in?

[ZikO]

Originally Posted by Hati-EK to say it simple: Using 1dim tables is more efficient in speaking of memory usage than 2dim tables? dim = dimension ^ Ydim | | -------> Xdim ? and what about 1 stable 2dim-table - which is created once - required the whole time ... and just values are changed in?

Honestly I thought LUA could use some kind of efficient implementation like this:

table:                               <container>
    table1: **********               10 elements
    table2: *****                    5 elements
    table3:                          <sub-container>
        table31: ********            8 elements
        table32:                     <sub-sub-container>
            table321: *******        7 elements

    table4: ***
    table5:                          <sub-container>
        table51: ****                5 elements
        table52: **                  2 elements

where number of particular elements are simply added + little memory for storing tables in tables. If it looks like as you said, it means any kind of table more than 1 dimension is populating empty cells like this:

table:
    table1: ****--------
    table2: **----------
    table3: ************

18 elements waisted. etc. Cannot believe it :P

[Tuhljin]

I'm not an expert on this, but I don't think that's how it works. Tables can point to other tables, which can in turn point back to the a previous table (creating a "loop")... and then we've got the global table (_G).... I just don't see it working how you've described it. I saw an article about memory footprints in Lua that I wanted to link here, but of course now that I want it, I don't see it any more.

[ZikO]

I am just guessing that's all.

Anyway, I do not believe three single tables would take much more memory than one table containing all of them. Of course it would be a little more memory taken as there would be 4 tables not 3 as fourth would have to store 3 other tables

I would like someone to explain me that tables in tables is not a good idea.

Regards.

[Sythalin]

Just force garbage collection at the end of your function. Problem solved.

[spiel2001]

Originally Posted by ZikO 18 elements waisted. etc. Cannot believe it :P

The key to understanding Lua is that it is designed and built for runtime efficiency, not for memory conservation. Compacting tables is computationally expensive. It's easier and faster to use memory blocks and that's what Lua is all about is speed.

PS: Running the garbage collector at the end of a function call is a bad idea. It will cause the user display to hiccup (tear) every time the garbage collector fires. Better to let the background garbage collection deal with it when it's most efficient to do so.