WoW:API getn: Difference between revisions

From AddOn Studio
Jump to navigation Jump to search
mNo edit summary
No edit summary
Line 26: Line 26:


   > print( #{1,2,3} )
   > print( #{1,2,3} )
  3
However, it does not always behave as one might expect. Consider the following sequence:
> t = { 1, 2, 3 }
> dump (#t)
   3
   3


getn and the # operator start at index [1] and count up, ceasing when they reach a nil value. This means that if you have a table
> t[1] = nil
> dump (#t)
3


  t = { [0]      = "zero",   --will not be counted
  > dump (t)
      [1]      = "one",    --will be counted; 1
{
      [2]     = "two",    --will be counted; 2
   [2] = 2
      [3]     = "three",  --will be counted; 3
  [3] = 3
      ["four"] = "four",  --will not be counted; returns 3
} -- table: 0x807ff70
      [5]      = "five" } --will never be reached


running getn(t) or #t will return 3, not the expected 4. Although there are 4 indices, it will count to three, see that t[4] is a blank spot, and return with a count of three. It will never reach 5. Furthermore, keys such as t["four"] and array values less than 1 such as t[0] are not counted at all.
> dump (#{ [2] = 2, [3] = 3 })
0
As you can see, the # operator is unpredictable in that it can return different values for tables with identical contents. The Lua 5.1 reference manual has this to say about it [http://www.lua.org/manual/5.1/]:
The length of a table t is defined to be any integer index such that t[n] is not nil and t[n+1] is nil.
In other words, be careful with this operator if you are using tables with holes in them. If your table has all its values between [1] and [n] for some n, with no nils in that range, the # operator will return n. Otherwise its result may be unclear.


== See Also ==
== See Also ==

Revision as of 00:18, 31 July 2008

Lua/Libshortcut From TableLibraryTutorial of lua-users.org.

table.getn(table)


This is used to determine the size of a table. The size of a table is discussed at the top of this page.

> = table.getn({1,2,3})         -- Lua will count the elements if no size is specified
3
> = table.getn({1,2,3; n=10})   -- note, n overrides counting the elements
10
> t = {1,2,3}
> table.setn(t, 10)              -- set our own size with setn()
> = table.getn(t)
10
> = table.getn({1,2,3,nil,5,6}) -- sequence ends at element 3 due to nil value at 4
3

Note that Lua 5.1 has switched to the # operator. #t is the replacement for table.getn(t)

 > print( #{1,2,3} )
 3

However, it does not always behave as one might expect. Consider the following sequence:

> t = { 1, 2, 3 }
> dump (#t)
3
> t[1] = nil
> dump (#t)
3
> dump (t)
{
 [2] = 2
 [3] = 3
} -- table: 0x807ff70
> dump (#{ [2] = 2, [3] = 3 })
0

As you can see, the # operator is unpredictable in that it can return different values for tables with identical contents. The Lua 5.1 reference manual has this to say about it [1]:

The length of a table t is defined to be any integer index such that t[n] is not nil and t[n+1] is nil.

In other words, be careful with this operator if you are using tables with holes in them. If your table has all its values between [1] and [n] for some n, with no nils in that range, the # operator will return n. Otherwise its result may be unclear.

See Also

Template:LUA