الفرق بين المراجعتين لصفحة: «وحدة:TableTools»

--                                   TableTools                                   --

-- It is a meta-module, meant to be called from other Lua modules, and should not --

-- be called directly from #invoke.                                               --

return type(v) == 'number' and v >= 1 and floor(v) == v and v < infinity

-- This function returns true if the given number is a NaN value, and false if

-- not. Although it doesn't operate on tables, it is included here as it is useful

-- for determining whether a value can be a valid table key. Lua will generate an

-- error if a NaN is used as a table key.

for _, v in ipairs(t) do

end

end

for k in pairs(t) do

-- {a1 = 'foo', a3 = 'bar', a6 = 'baz'} and the prefix "a", affixNums will return

-- {1, 3, 6}.

for k in pairs(t) do

if type(k) == 'string' then

-- Given a table with keys like {"foo1", "bar1", "foo2", "baz2"}, returns a table

-- of subtables in the format

-- {[1] = {foo = 'text', bar = 'text'}, [2] = {foo = 'text', baz = 'text'}}.

-- Keys that don't end with an integer are stored in a subtable named "other". The

-- compress option compresses the table so that it can be iterated over with

for _ in pairs(t) do

elseif type1 == 'table' or type1 == 'boolean' or type1 == 'function' then

-- keysToList

-- Returns an array of the keys in a table, sorted using either a default

-- comparison function or a custom keySort function.

checkTypeMulti('keysToList', 2, keySort, {'function', 'boolean', 'nil'})

 

local arr = {}

for k in pairs(t) do

arr[index] = k

 

table.sort(arr, keySort)

 

return arr

------------------------------------------------------------------------------------

-- Iterates through a table, with the keys sorted using the keysToList function.

-- If there are only numerical keys, sparseIpairs is probably more efficient.

 

local arr = p.keysToList(t, keySort, true)

 

return function ()

local key = arr[i]

------------------------------------------------------------------------------------

-- Returns true if the given value is a table and all keys are consecutive

-- integers starting at 1.

------------------------------------------------------------------------------------

function p.isArray(v)

if type(v) ~= 'table' then

end

for _ in pairs(v) do

 

if not pcall(pairs, v) then

for _ in pairs(v) do

if v[i] == nil then

------------------------------------------------------------------------------------

-- Transposes the keys and values in an array. For example, {"a", "b", "c"} ->

-- {a = 1, b = 2, c = 3}.

function p.invert(arr)

checkType("invert", 1, arr, "table")

 

for i, v in ipairs(arr) do

 

------------------------------------------------------------------------------------

-- values of the array returns true. For example, {"a", "b", "c"} ->

-- {a = true, b = true, c = true}.

------------------------------------------------------------------------------------

 

 

------------------------------------------------------------------------------------

-- Recursive deep copy function. Preserves identities of subtables.

 

 

copy[_deepCopy(orig_key, includeMetatable, already_seen)] = _deepCopy(orig_value, includeMetatable, already_seen)

 

local mt_copy = _deepCopy(mt, includeMetatable, already_seen)

------------------------------------------------------------------------------------

-- Concatenates all values in the table that are indexed by a number, in order.

-- sparseConcat{a, nil, c, d}  =>  "acd"

-- sparseConcat{nil, b, c, d}  =>  "bcd"

local arr = {}

 

local arr_i = 0

arr_i = arr_i + 1

arr[arr_i] = v

 

return table.concat(arr, sep, i, j)

------------------------------------------------------------------------------------

-- Finds the length of an array, or of a quasi-array with keys such as "data1",

-- "data2", etc., using an exponential search algorithm. It is similar to the

-- operator #, but may return a different value when there are gaps in the array

-- portion of the table. Intended to be used on data loaded with mw.loadData. For

-- other tables, use #.

-- Note: #frame.args in frame object always be set to 0, regardless of the number

-- of unnamed template parameters, so use this function for frame.args.

------------------------------------------------------------------------------------

-- requiring module inline so that [[Module:Exponential search]] which is

-- only needed by this one function doesn't get millions of transclusions

return expSearch(function (i)