Multi Theft Auto: Wiki - User contributions [en]

Talk:Table.size

2009-07-13T19:58:46Z

Subenji99:

What about using the builtin lua function:

table.getn(table)

--[[User:Subenji99|Subenji99]] 06:54, 13 July 2009 (CEST)
----
table.getn was replaced by the #-operator, which returns the number of table elements with a numerical (!) index. 
table.size counts all elements regardless of which type their index is. 
Of course it's a bad idea to use this function for a table with only numerical indices. 
[[User:NeonBlack|NeonBlack]] 16:19, 13 July 2009 (CEST)
----
Indded, I actually just attempted it with non-numerical indices and found it didn't work. I stand corrected. :D

I shall leave my humiliation (lol) here so anyone else wondering what the point of this function would be can see that it is for non-numerical indices.

Oh, reading up, I'd like to point out that if you structure your table, planning for this, you can still use the # operator.
you have to count the additions you make to your table then use table.setn like so:

table.setn(table, <number of values>)

if you are using a loop to create your table, it would be a simple matter to add it after:

table = {}
local count = 0
for _,v in pairs(results) do
table[v] = someFunction(v)
count = count + 1
end
table.setn(table, count)

[http://www.lua.org/pil/19.1.html Array Size]

In my case though, this function was still required as the table I was checking against was a returned table from an exported function of mapmanager.

--[[User:Subenji99|Subenji99]] 20:43, 13 July 2009 (CEST)

Talk:Table.size

2009-07-13T19:57:21Z

Subenji99:

What about using the builtin lua function:

table.getn(table)

--[[User:Subenji99|Subenji99]] 06:54, 13 July 2009 (CEST)
----
table.getn was replaced by the #-operator, which returns the number of table elements with a numerical (!) index. 
table.size counts all elements regardless of which type their index is. 
Of course it's a bad idea to use this function for a table with only numerical indices. 
[[User:NeonBlack|NeonBlack]] 16:19, 13 July 2009 (CEST)
----
Indded, I actually just attempted it with non-numerical indices and found it didn't work. I stand corrected. :D

I shall leave my humiliation (lol) here so anyone else wondering what the point of this function would be can see that it is for non-numerical indices.

Oh, reading up, I'd like to point out that if you structure your table, planning for this, you can still use the # operator.
you have to count the additions you make to your table then use table.setn like so:

table.setn(table, <number of values>)

if you are using a loop to create your table, it would be a simple matter to add it after:
<source>
table = {}
local count = 0
for _,v in pairs(results) do
table[v] = someFunction(v)
count = count + 1
end
table.setn(table, count)
</source>
[http://www.lua.org/pil/19.1.html Array Size]

In my case though, this function was still required as the table I was checking against was a returned table from an exported function of mapmanager.

--[[User:Subenji99|Subenji99]] 20:43, 13 July 2009 (CEST)

Talk:Table.size

2009-07-13T19:57:04Z

Subenji99:

What about using the builtin lua function:

table.getn(table)

--[[User:Subenji99|Subenji99]] 06:54, 13 July 2009 (CEST)
----
table.getn was replaced by the #-operator, which returns the number of table elements with a numerical (!) index. 
table.size counts all elements regardless of which type their index is. 
Of course it's a bad idea to use this function for a table with only numerical indices. 
[[User:NeonBlack|NeonBlack]] 16:19, 13 July 2009 (CEST)
----
Indded, I actually just attempted it with non-numerical indices and found it didn't work. I stand corrected. :D

I shall leave my humiliation (lol) here so anyone else wondering what the point of this function would be can see that it is for non-numerical indices.

Oh, reading up, I'd like to point out that if you structure your table, planning for this, you can still use the # operator.
you have to count the additions you make to your table then use table.setn like so:

table.setn(table, <number of values>)

if you are using a loop to create your table, it would be a simple matter to add it after:
<source lang=lua>
table = {}
local count = 0
for _,v in pairs(results) do
table[v] = someFunction(v)
count = count + 1
end
table.setn(table, count)
</source>
[http://www.lua.org/pil/19.1.html Array Size]

In my case though, this function was still required as the table I was checking against was a returned table from an exported function of mapmanager.

--[[User:Subenji99|Subenji99]] 20:43, 13 July 2009 (CEST)

Talk:Table.size

2009-07-13T19:55:09Z

Subenji99:

What about using the builtin lua function:

table.getn(table)

--[[User:Subenji99|Subenji99]] 06:54, 13 July 2009 (CEST)
----
table.getn was replaced by the #-operator, which returns the number of table elements with a numerical (!) index. 
table.size counts all elements regardless of which type their index is. 
Of course it's a bad idea to use this function for a table with only numerical indices. 
[[User:NeonBlack|NeonBlack]] 16:19, 13 July 2009 (CEST)
----
Indded, I actually just attempted it with non-numerical indices and found it didn't work. I stand corrected. :D

I shall leave my humiliation (lol) here so anyone else wondering what the point of this function would be can see that it is for non-numerical indices.

Oh, reading up, I'd like to point out that if you structure your table, planning for this, you can still use the # operator.
you have to count the additions you make to your table then use table.setn like so:

table.setn(table, <number of values>)

if you are using a loop to create your table, it would be a simple matter to add it after:
for _
table = {}
local count = 0
for _,v in pairs(results) do
table[v] = someFunction(v)
count = count + 1
end
table.setn(table, count)
end

[http://www.lua.org/pil/19.1.html Array Size]

In my case though, this function was still required as the table I was checking against was a returned table from an exported function of mapmanager.

--[[User:Subenji99|Subenji99]] 20:43, 13 July 2009 (CEST)

Talk:Table.size

2009-07-13T19:54:55Z

Subenji99:

What about using the builtin lua function:

table.getn(table)

--[[User:Subenji99|Subenji99]] 06:54, 13 July 2009 (CEST)
----
table.getn was replaced by the #-operator, which returns the number of table elements with a numerical (!) index. 
table.size counts all elements regardless of which type their index is. 
Of course it's a bad idea to use this function for a table with only numerical indices. 
[[User:NeonBlack|NeonBlack]] 16:19, 13 July 2009 (CEST)
----
Indded, I actually just attempted it with non-numerical indices and found it didn't work. I stand corrected. :D

I shall leave my humiliation (lol) here so anyone else wondering what the point of this function would be can see that it is for non-numerical indices.

Oh, reading up, I'd like to point out that if you structure your table, planning for this, you can still use the # operator.
you have to count the additions you make to your table then use table.setn like so:

table.setn(table, <number of values>)

if you are using a loop to create your table, it would be a simple matter to add it after:
for
table = {}
local count = 0
for _,v in pairs(results) do
table[v] = someFunction(v)
count = count + 1
end
table.setn(table, count)
end

[http://www.lua.org/pil/19.1.html Array Size]

In my case though, this function was still required as the table I was checking against was a returned table from an exported function of mapmanager.

--[[User:Subenji99|Subenji99]] 20:43, 13 July 2009 (CEST)

Talk:Table.size

2009-07-13T19:54:34Z

Subenji99:

Talk:Table.size

2009-07-13T19:53:46Z

Subenji99:

What about using the builtin lua function:

table.getn(table)

--[[User:Subenji99|Subenji99]] 06:54, 13 July 2009 (CEST)
----
table.getn was replaced by the #-operator, which returns the number of table elements with a numerical (!) index. 
table.size counts all elements regardless of which type their index is. 
Of course it's a bad idea to use this function for a table with only numerical indices. 
[[User:NeonBlack|NeonBlack]] 16:19, 13 July 2009 (CEST)
----
Indded, I actually just attempted it with non-numerical indices and found it didn't work. I stand corrected. :D

I shall leave my humiliation (lol) here so anyone else wondering what the point of this function would be can see that it is for non-numerical indices.

Oh, reading up, I'd like to point out that if you structure your table, planning for this, you can still use the # operator.
you have to count the additions you make to your table then use table.setn like so:

table.setn(table, <number of values>)

if you are using a loop to create your table, it would be a simple matter to add it after:

<nowiki>table = {}
local count = 0
for _,v in pairs(results) do
table[v] = someFunction(v)
count = count + 1
end
table.setn(table, count)</nowiki>

[http://www.lua.org/pil/19.1.html Array Size]

In my case though, this function was still required as the table I was checking against was a returned table from an exported function of mapmanager.

--[[User:Subenji99|Subenji99]] 20:43, 13 July 2009 (CEST)

Talk:Table.size

2009-07-13T18:43:20Z

Subenji99:

Talk:Table.size

2009-07-13T04:56:41Z

Subenji99:

What about using the builtin lua function:

table.getn(table)

--[[User:Subenji99|Subenji99]] 06:54, 13 July 2009 (CEST)

Talk:Table.size

2009-07-13T04:54:47Z

Subenji99:

What about using the builtin lua function:

table.getn(table)

or the length operator:

<nowiki>#table</nowiki>

--[[User:Subenji99|Subenji99]] 06:54, 13 July 2009 (CEST)

Talk:Table.size

2009-07-13T04:53:33Z

Subenji99: Feel this function is unnecessary.

What about using the builtin lua function:
table.getn(table)

or the length operator:
#table