Editing Module:TableTools
Jump to navigation
Jump to search
The edit can be undone. Please check the comparison below to verify that this is what you want to do, and then publish the changes below to finish undoing the edit.
Latest revision | Your text | ||
Line 1: | Line 1: | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- | -- TableTools -- | ||
-- -- | -- -- | ||
-- This module includes a number of functions for dealing with Lua tables. -- | -- This module includes a number of functions for dealing with Lua tables. -- | ||
-- It is a meta-module, meant to be called from other Lua modules, and should | -- It is a meta-module, meant to be called from other Lua modules, and should not -- | ||
-- | -- be called directly from #invoke. -- | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
local libraryUtil = require('libraryUtil') | local libraryUtil = require('libraryUtil') | ||
Line 19: | Line 17: | ||
local checkTypeMulti = libraryUtil.checkTypeMulti | local checkTypeMulti = libraryUtil.checkTypeMulti | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- isPositiveInteger | -- isPositiveInteger | ||
Line 28: | Line 25: | ||
-- hash part of a table. | -- hash part of a table. | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
function p.isPositiveInteger(v) | function p.isPositiveInteger(v) | ||
return type(v) == 'number' and v >= 1 and floor(v) == v and v < infinity | |||
end | end | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- isNan | -- isNan | ||
-- | -- | ||
-- This function returns true if the given number is a NaN value, and false | -- 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. | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
function p.isNan(v) | function p.isNan(v) | ||
return type(v) == 'number' and v ~= v | |||
end | end | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- shallowClone | -- shallowClone | ||
Line 63: | Line 48: | ||
-- table will have no metatable of its own. | -- table will have no metatable of its own. | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
function p.shallowClone(t) | function p.shallowClone(t) | ||
checkType('shallowClone', 1, t, 'table') | |||
local ret = {} | local ret = {} | ||
for k, v in pairs(t) do | for k, v in pairs(t) do | ||
Line 72: | Line 57: | ||
end | end | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- removeDuplicates | -- removeDuplicates | ||
Line 80: | Line 64: | ||
-- removed, but otherwise the array order is unchanged. | -- removed, but otherwise the array order is unchanged. | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
function p.removeDuplicates(arr) | |||
function p.removeDuplicates( | checkType('removeDuplicates', 1, arr, 'table') | ||
checkType('removeDuplicates', 1, | |||
local isNan = p.isNan | local isNan = p.isNan | ||
local ret, exists = {}, {} | local ret, exists = {}, {} | ||
for | for _, v in ipairs(arr) do | ||
if isNan(v) then | if isNan(v) then | ||
-- NaNs can't be table keys, and they are also unique, so we don't need to check existence. | -- NaNs can't be table keys, and they are also unique, so we don't need to check existence. | ||
Line 94: | Line 77: | ||
exists[v] = true | exists[v] = true | ||
end | end | ||
end | end | ||
end | end | ||
return ret | return ret | ||
end | end | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- numKeys | -- numKeys | ||
Line 106: | Line 88: | ||
-- keys that have non-nil values, sorted in numerical order. | -- keys that have non-nil values, sorted in numerical order. | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
function p.numKeys(t) | function p.numKeys(t) | ||
checkType('numKeys', 1, t, 'table') | checkType('numKeys', 1, t, 'table') | ||
local isPositiveInteger = p.isPositiveInteger | local isPositiveInteger = p.isPositiveInteger | ||
local nums = {} | local nums = {} | ||
for k | for k in pairs(t) do | ||
if isPositiveInteger(k) then | if isPositiveInteger(k) then | ||
nums[#nums + 1] = k | nums[#nums + 1] = k | ||
Line 120: | Line 101: | ||
end | end | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- affixNums | -- affixNums | ||
Line 126: | Line 106: | ||
-- This takes a table and returns an array containing the numbers of keys with the | -- This takes a table and returns an array containing the numbers of keys with the | ||
-- specified prefix and suffix. For example, for the table | -- specified prefix and suffix. For example, for the table | ||
-- {a1 = 'foo', a3 = 'bar', a6 = 'baz'} and the prefix "a", affixNums will | -- {a1 = 'foo', a3 = 'bar', a6 = 'baz'} and the prefix "a", affixNums will return | ||
-- | -- {1, 3, 6}. | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
function p.affixNums(t, prefix, suffix) | function p.affixNums(t, prefix, suffix) | ||
checkType('affixNums', 1, t, 'table') | checkType('affixNums', 1, t, 'table') | ||
Line 137: | Line 116: | ||
local function cleanPattern(s) | local function cleanPattern(s) | ||
-- Cleans a pattern so that the magic characters ()%.[]*+-?^$ are interpreted literally. | -- Cleans a pattern so that the magic characters ()%.[]*+-?^$ are interpreted literally. | ||
return s:gsub('([%(%)%%%.%[%]%*%+%-%?%^%$])', '%%%1') | |||
end | end | ||
Line 148: | Line 126: | ||
local nums = {} | local nums = {} | ||
for k | for k in pairs(t) do | ||
if type(k) == 'string' then | if type(k) == 'string' then | ||
local num = mw.ustring.match(k, pattern) | local num = mw.ustring.match(k, pattern) | ||
if num then | if num then | ||
Line 160: | Line 138: | ||
end | end | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- numData | -- numData | ||
-- | -- | ||
-- Given a table with keys like | -- Given a table with keys like {"foo1", "bar1", "foo2", "baz2"}, returns a table | ||
-- of subtables in the format | -- of subtables in the format | ||
-- { [1] = {foo = 'text', bar = 'text'}, [2] = {foo = 'text', baz = 'text'} } | -- {[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". | -- 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 | ||
-- ipairs. | -- ipairs. | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
function p.numData(t, compress) | function p.numData(t, compress) | ||
checkType('numData', 1, t, 'table') | checkType('numData', 1, t, 'table') | ||
Line 201: | Line 177: | ||
end | end | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- compressSparseArray | -- compressSparseArray | ||
Line 209: | Line 184: | ||
-- ipairs. | -- ipairs. | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
function p.compressSparseArray(t) | function p.compressSparseArray(t) | ||
checkType('compressSparseArray', 1, t, 'table') | checkType('compressSparseArray', 1, t, 'table') | ||
Line 220: | Line 194: | ||
end | end | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- sparseIpairs | -- sparseIpairs | ||
Line 227: | Line 200: | ||
-- handle nil values. | -- handle nil values. | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
function p.sparseIpairs(t) | function p.sparseIpairs(t) | ||
checkType('sparseIpairs', 1, t, 'table') | checkType('sparseIpairs', 1, t, 'table') | ||
Line 244: | Line 216: | ||
end | end | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- size | -- size | ||
Line 251: | Line 222: | ||
-- but for arrays it is more efficient to use the # operator. | -- but for arrays it is more efficient to use the # operator. | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
function p.size(t) | function p.size(t) | ||
checkType('size', 1, t, 'table') | checkType('size', 1, t, 'table') | ||
local i = 0 | local i = 0 | ||
for | for _ in pairs(t) do | ||
i = i + 1 | i = i + 1 | ||
end | end | ||
return i | return i | ||
end | end | ||
local function defaultKeySort(item1, item2) | local function defaultKeySort(item1, item2) | ||
Line 268: | Line 236: | ||
if type1 ~= type2 then | if type1 ~= type2 then | ||
return type1 < type2 | return type1 < type2 | ||
elseif type1 == 'table' or type1 == 'boolean' or type1 == 'function' then | |||
return tostring(item1) < tostring(item2) | |||
else | |||
return item1 < item2 | return item1 < item2 | ||
end | end | ||
end | end | ||
------------------------------------------------------------------------------------ | |||
-- | -- keysToList | ||
-- | |||
-- Returns an array of the keys in a table, sorted using either a default | |||
-- comparison function or a custom keySort function. | |||
------------------------------------------------------------------------------------ | |||
function p.keysToList(t, keySort, checked) | function p.keysToList(t, keySort, checked) | ||
if not checked then | if not checked then | ||
checkType('keysToList', 1, t, 'table') | checkType('keysToList', 1, t, 'table') | ||
checkTypeMulti('keysToList', 2, keySort, { 'function', 'boolean', 'nil' }) | checkTypeMulti('keysToList', 2, keySort, {'function', 'boolean', 'nil'}) | ||
end | end | ||
local | local arr = {} | ||
local index = 1 | local index = 1 | ||
for | for k in pairs(t) do | ||
arr[index] = k | |||
index = index + 1 | index = index + 1 | ||
end | end | ||
if keySort ~= false then | if keySort ~= false then | ||
keySort = type(keySort) == 'function' and keySort or defaultKeySort | keySort = type(keySort) == 'function' and keySort or defaultKeySort | ||
table.sort(arr, keySort) | |||
table.sort( | |||
end | end | ||
return | return arr | ||
end | end | ||
-- | ------------------------------------------------------------------------------------ | ||
-- sortedPairs | |||
-- | |||
-- Iterates through a table, with the keys sorted using the keysToList function. | |||
-- If there are only numerical keys, sparseIpairs is probably more efficient. | |||
------------------------------------------------------------------------------------ | |||
function p.sortedPairs(t, keySort) | function p.sortedPairs(t, keySort) | ||
checkType('sortedPairs', 1, t, 'table') | checkType('sortedPairs', 1, t, 'table') | ||
checkType('sortedPairs', 2, keySort, 'function', true) | checkType('sortedPairs', 2, keySort, 'function', true) | ||
local | local arr = p.keysToList(t, keySort, true) | ||
local i = 0 | local i = 0 | ||
return function() | return function () | ||
i = i + 1 | i = i + 1 | ||
local key = | local key = arr[i] | ||
if key ~= nil then | if key ~= nil then | ||
return key, t[key] | return key, t[key] | ||
Line 321: | Line 293: | ||
end | end | ||
--[ | ------------------------------------------------------------------------------------ | ||
Returns true if all keys | -- isArray | ||
-- | -- | ||
function p. | -- 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 | |||
local i = 0 | |||
for _ in pairs(v) do | |||
i = i + 1 | |||
if v[i] == nil then | |||
return false | |||
end | |||
end | |||
return true | |||
end | |||
------------------------------------------------------------------------------------ | |||
-- 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 | local i = 0 | ||
for | for _ in pairs(v) do | ||
i = i + 1 | i = i + 1 | ||
if | if v[i] == nil then | ||
return false | return false | ||
end | end | ||
Line 337: | Line 333: | ||
end | end | ||
-- { "a", "b", "c" } -> { a = 1, b = 2, c = 3 } | ------------------------------------------------------------------------------------ | ||
function p.invert( | -- invert | ||
checkType("invert", 1, | -- | ||
-- 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 | |||
local map = {} | local map = {} | ||
for i, v in ipairs( | for i, v in ipairs(arr) do | ||
map[v] = i | if not isNan(v) then | ||
map[v] = i | |||
end | |||
end | end | ||
return map | return map | ||
end | end | ||
-- | ------------------------------------------------------------------------------------ | ||
-- listToSet | |||
-- | -- | ||
function p.listToSet( | -- Creates a set from the array part of the table. Indexing the set by any of the | ||
checkType("listToSet", 1, | -- 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 | |||
local set = {} | local set = {} | ||
for _, | for _, v in ipairs(arr) do | ||
set[ | if not isNan(v) then | ||
set[v] = true | |||
end | |||
end | end | ||
return set | return set | ||
end | end | ||
-- | ------------------------------------------------------------------------------------ | ||
-- deepCopy | |||
-- | |||
-- Recursive deep copy function. Preserves identities of subtables. | |||
------------------------------------------------------------------------------------ | |||
local function _deepCopy(orig, includeMetatable, already_seen) | local function _deepCopy(orig, includeMetatable, already_seen) | ||
-- Stores copies of tables indexed by the original table. | -- Stores copies of tables indexed by the original table. | ||
already_seen = already_seen or {} | already_seen = already_seen or {} | ||
local copy = already_seen[orig] | local copy = already_seen[orig] | ||
if copy ~= nil then | if copy ~= nil then | ||
return copy | return copy | ||
end | end | ||
if type(orig) == 'table' then | if type(orig) == 'table' then | ||
copy = {} | copy = {} | ||
for orig_key, orig_value in pairs(orig) do | for orig_key, orig_value in pairs(orig) do | ||
copy[ | copy[_deepCopy(orig_key, includeMetatable, already_seen)] = _deepCopy(orig_value, includeMetatable, already_seen) | ||
end | end | ||
already_seen[orig] = copy | already_seen[orig] = copy | ||
if includeMetatable then | if includeMetatable then | ||
local mt = getmetatable(orig) | local mt = getmetatable(orig) | ||
if mt ~= nil then | if mt ~= nil then | ||
local mt_copy = | local mt_copy = _deepCopy(mt, includeMetatable, already_seen) | ||
setmetatable(copy, mt_copy) | setmetatable(copy, mt_copy) | ||
already_seen[mt] = mt_copy | already_seen[mt] = mt_copy | ||
Line 400: | Line 411: | ||
function p.deepCopy(orig, noMetatable, already_seen) | function p.deepCopy(orig, noMetatable, already_seen) | ||
checkType("deepCopy", 3, already_seen, "table", true) | checkType("deepCopy", 3, already_seen, "table", true) | ||
return _deepCopy(orig, not noMetatable, already_seen) | return _deepCopy(orig, not noMetatable, already_seen) | ||
end | end | ||
-- | ------------------------------------------------------------------------------------ | ||
-- 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" | |||
------------------------------------------------------------------------------------ | |||
function p.sparseConcat(t, sep, i, j) | function p.sparseConcat(t, sep, i, j) | ||
local | local arr = {} | ||
local | local arr_i = 0 | ||
for _, v in p.sparseIpairs(t) do | for _, v in p.sparseIpairs(t) do | ||
arr_i = arr_i + 1 | |||
arr[arr_i] = v | |||
end | end | ||
return table.concat( | return table.concat(arr, sep, i, j) | ||
end | end | ||
-- | ------------------------------------------------------------------------------------ | ||
-- | -- 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 | |||
-- Note: #frame.args in frame object always be set to 0, regardless of | -- 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 | ||
function p.length(t) | -- of unnamed template parameters, so use this function for frame.args. | ||
local | ------------------------------------------------------------------------------------ | ||
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 | |||
end | end | ||
------------------------------------------------------------------------------------ | |||
-- inArray | |||
-- | |||
-- Returns true if valueToFind is a member of the array, and false otherwise. | |||
------------------------------------------------------------------------------------ | |||
function p.inArray(arr, valueToFind) | function p.inArray(arr, valueToFind) | ||
checkType("inArray", 1, arr, "table") | checkType("inArray", 1, arr, "table") | ||
-- if valueToFind is nil, error? | -- if valueToFind is nil, error? | ||
for _, v in ipairs(arr) do | for _, v in ipairs(arr) do | ||
if v == valueToFind then | if v == valueToFind then | ||
Line 448: | Line 475: | ||
end | end | ||
end | end | ||
return false | return false | ||
end | end | ||
return p | return p |