“モジュール:TableTools” のwerson間の差分

--                               TableTools                                       --

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

-- not be called directly from #invoke.                                           --

-- 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.

return type(v) == 'number' and tostring(v) == '-nan'

function p.removeDuplicates(t)

checkType('removeDuplicates', 1, t, 'table')

for i, v in ipairs(t) do

end

end

for k, v in pairs(t) do

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

-- return {1, 3, 6}.

for k, v 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 k in pairs(t) do

else -- This will fail with table, boolean, function.

 

--[[

Returns a list 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 list = {}

for key, value in pairs(t) do

list[index] = key

table.sort(list, keySort)

return list

--[[

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

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

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

return function()

local key = list[i]

--[[

Returns true if all keys in the table are consecutive integers starting at 1.

--]]

function p.isArray(t)

checkType("isArray", 1, t, "table")

for k, v in pairs(t) do

if t[i] == nil then

-- { "a", "b", "c" } -> { a = 1, b = 2, c = 3 }

function p.invert(array)

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

for i, v in ipairs(array) do

map[v] = i

--[[

{ "a", "b", "c" } -> { ["a"] = true, ["b"] = true, ["c"] = true }

--]]

function p.listToSet(t)

checkType("listToSet", 1, t, "table")

for _, item in ipairs(t) do

set[item] = 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 list = {}

local list_i = 0

list_i = list_i + 1

list[list_i] = v

return table.concat(list, 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)