Module:TableTools: Difference between revisions

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

return type(v) == 'number' and v ~= v

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

function p.removeDuplicates(arr)

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

for _, v in ipairs(arr) do

elseif not exists[v] then

ret[#ret + 1] = v

exists[v] = true

end

end

for k in pairs(t) do

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

-- {1, 3, 6}.

return s:gsub('([%(%)%%%.%[%]%*%+%-%?%^%$])', '%%%1')

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

return tostring(item1) < tostring(item2)

else

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

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

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

-- sortedPairs

--

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

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

-- isArray

--

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

return false

end

for _ in pairs(v) do

if v[i] == nil then

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

-- isArrayLike

--

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

-- integers starting at 1.

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

function p.isArrayLike(v)

if not pcall(pairs, v) then

return false

end

local i = 0

for _ in pairs(v) do

i = i + 1

if v[i] == nil then

return false

end

end

return true

end

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

-- invert

--

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

-- {a = 1, b = 2, c = 3}. Duplicates are not supported (result values refer to

-- the index of the last duplicate) and NaN values are ignored.

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

function p.invert(arr)

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

local isNan = p.isNan

for i, v in ipairs(arr) do

if not isNan(v) then

map[v] = i

end

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

-- listToSet

--

-- Creates a set from the array part of the table. Indexing the set by any of the

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

-- {a = true, b = true, c = true}. NaN values are ignored as Lua considers them

-- never equal to any value (including other NaNs or even themselves).

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

function p.listToSet(arr)

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

local isNan = p.isNan

for _, v in ipairs(arr) do

if not isNan(v) then

set[v] = true

end

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

-- deepCopy

--

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

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

if type(orig) ~= "table" then

return orig

end

-- already_seen stores copies of tables indexed by the original table.

copy = {}

already_seen[orig] = copy -- memoize before any recursion, to avoid infinite loops

for orig_key, orig_value in pairs(orig) do

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

end

if includeMetatable then

local mt = getmetatable(orig)

if mt ~= nil then

setmetatable(copy, _deepCopy(mt, true, already_seen))

return _deepCopy(orig, not noMetatable, already_seen or {})

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

-- sparseConcat

--

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

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

-- length

--

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

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

function p.length(t, prefix)

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

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

local expSearch = require("Module:Exponential search")

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

checkType('length', 2, prefix, 'string', true)

return expSearch(function (i)

local key

if prefix then

key = prefix .. tostring(i)

else

key = i

end

return t[key] ~= nil

end) or 0

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

-- inArray

--

-- Returns true if searchElement is a member of the array, and false otherwise.

-- Equivalent to JavaScript array.includes(searchElement) or

-- array.includes(searchElement, fromIndex), except fromIndex is 1 indexed

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

function p.inArray(array, searchElement, fromIndex)

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

-- if searchElement is nil, error?

fromIndex = tonumber(fromIndex)

if fromIndex then

if (fromIndex < 0) then

fromIndex = #array + fromIndex + 1

end

if fromIndex < 1 then fromIndex = 1 end

for _, v in ipairs({unpack(array, fromIndex)}) do

if v == searchElement then

return true

end

end

else

for _, v in pairs(array) do

if v == searchElement then

return true

end

end

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

-- merge

--

-- Given the arrays, returns an array containing the elements of each input array

-- in sequence.

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

function p.merge(...)

local arrays = {...}

local ret = {}

for i, arr in ipairs(arrays) do

checkType('merge', i, arr, 'table')

for _, v in ipairs(arr) do

ret[#ret + 1] = v

end

end

return ret

end

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

-- extend

--

-- Extends the first array in place by appending all elements from the second

-- array.

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

function p.extend(arr1, arr2)

checkType('extend', 1, arr1, 'table')

checkType('extend', 2, arr2, 'table')

for _, v in ipairs(arr2) do

arr1[#arr1 + 1] = v

end