In Lua, there seem to be two ways of appending an element to an array:
table.insert(t, i)
and
t[#t+1] = i
Whi
insert
can insert arbitrarily (as its name states), it only defaults to #t + 1
, where as t[#t + 1] = i
will always append to the (end of the) table. see section 5.5 in the lua manual.
The following is slightly on the amusing side but possibly with a grain of aesthetics. Even though there are obvious reasons that mytable:operation()
is not supplied like mystring:operation()
, one can easily roll one's own variant, and get a third notation if desired.
Table = {}
Table.__index = table
function Table.new()
local t = {}
setmetatable(t, Table)
return t
end
mytable = Table.new()
mytable:insert('Hello')
mytable:insert('World')
for _, s in ipairs(mytable) do
print(s)
end
Which to use is a matter of preference and circumstance: as the #
length operator was introduced in version 5.1, t[#t+1] = i
will not work in Lua 5.0, whereas table.insert
has been present since 5.0 and will work in both. On the other hand, t[#t+1] = i
uses exclusively language-level operators, wheras table.insert
involves a function (which has a slight amount of overhead to look up and call and depends on the table
module in the environment).
In the second edition of Programming in Lua (an update of the Lua 5.0-oriented first edition), Roberto Ierusalimschy (the designer of Lua) states that he prefers t[#t+1] = i
, as it's more visible.
Also, depending on your use case, the answer may be "neither". See the manual entry on the behavior of the length operator:
If the array has "holes" (that is, nil values between other non-nil values), then #t can be any of the indices that directly precedes a nil value (that is, it may consider any such nil value as the end of the array).
As such, if you're dealing with an array with holes, using either one (table.insert uses the length operator) may "append" your value to a lower index in the array than you want. How you define the size of your array in this scenario is up to you, and, again, depends on preference and circumstance: you can use table.maxn
(disappearing in 5.2 but trivial to write), you can keep an n
field in the table and update it when necessary, you can wrap the table in a metatable, or you could use another solution that better fits your situation (in a loop, a local tsize
in the scope immediately outside the loop will often suffice).
'#' operator only use indexed key table.
t = {1, 2 ,3 ,4, 5, x=1, y=2}
at above code
print(#t) --> print 5 not 7
'#' operator whenever not using.
If you want to '#' operator, then check it to table elements type.
Insert function can using any type use.But element count to work slow than '#'