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 -- | ||
-- be called directly from #invoke. | -- not be called directly from #invoke. -- | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
--]] | |||
local libraryUtil = require('libraryUtil') | local libraryUtil = require('libraryUtil') | ||
Line 15: | Line 17: | ||
local infinity = math.huge | local infinity = math.huge | ||
local checkType = libraryUtil.checkType | local checkType = libraryUtil.checkType | ||
--[[ | |||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- isPositiveInteger | -- isPositiveInteger | ||
Line 25: | Line 27: | ||
-- hash part of a table. | -- hash part of a table. | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
--]] | |||
function p.isPositiveInteger(v) | function p.isPositiveInteger(v) | ||
if type(v) == 'number' and v >= 1 and floor(v) == v and v < infinity then | |||
return true | |||
else | |||
return false | |||
end | |||
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 | ||
-- not. Although it doesn't operate on tables, it is included here as it is | -- if not. Although it doesn't operate on tables, it is included here as it is | ||
-- for determining whether a value can be a valid table key. Lua will | -- useful for determining whether a value can be a valid table key. Lua will | ||
-- error if a NaN is used as a table key. | -- generate an error if a NaN is used as a table key. | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
--]] | |||
function p.isNan(v) | function p.isNan(v) | ||
if type(v) == 'number' and tostring(v) == '-nan' then | |||
return true | |||
else | |||
return false | |||
end | |||
end | end | ||
--[[ | |||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- shallowClone | -- shallowClone | ||
Line 48: | Line 62: | ||
-- table will have no metatable of its own. | -- table will have no metatable of its own. | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
--]] | |||
function p.shallowClone(t) | function p.shallowClone(t) | ||
local ret = {} | local ret = {} | ||
for k, v in pairs(t) do | for k, v in pairs(t) do | ||
Line 57: | Line 71: | ||
end | end | ||
--[[ | |||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- removeDuplicates | -- removeDuplicates | ||
Line 64: | Line 79: | ||
-- removed, but otherwise the array order is unchanged. | -- removed, but otherwise the array order is unchanged. | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
function p.removeDuplicates( | --]] | ||
checkType('removeDuplicates', 1, | function p.removeDuplicates(t) | ||
checkType('removeDuplicates', 1, t, 'table') | |||
local isNan = p.isNan | local isNan = p.isNan | ||
local ret, exists = {}, {} | local ret, exists = {}, {} | ||
for | for i, v in ipairs(t) 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 77: | Line 93: | ||
exists[v] = true | exists[v] = true | ||
end | end | ||
end | end | ||
end | end | ||
return ret | return ret | ||
end | end | ||
--[[ | |||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- numKeys | -- numKeys | ||
Line 88: | Line 105: | ||
-- 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 in pairs(t) do | for k, v in pairs(t) do | ||
if isPositiveInteger(k) then | if isPositiveInteger(k) then | ||
nums[#nums + 1] = k | nums[#nums + 1] = k | ||
Line 101: | Line 119: | ||
end | end | ||
--[[ | |||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- affixNums | -- affixNums | ||
Line 106: | Line 125: | ||
-- 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 | ||
-- {1, 3, 6}. | -- 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 116: | Line 136: | ||
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. | ||
s = s:gsub('([%(%)%%%.%[%]%*%+%-%?%^%$])', '%%%1') | |||
return s | |||
end | end | ||
Line 126: | Line 147: | ||
local nums = {} | local nums = {} | ||
for k in pairs(t) do | for k, v 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 138: | Line 159: | ||
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". | ||
-- compress option compresses the table so that it can be iterated over with | -- 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 177: | Line 200: | ||
end | end | ||
--[[ | |||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- compressSparseArray | -- compressSparseArray | ||
Line 184: | Line 208: | ||
-- ipairs. | -- ipairs. | ||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
--]] | |||
function p.compressSparseArray(t) | function p.compressSparseArray(t) | ||
checkType('compressSparseArray', 1, t, 'table') | checkType('compressSparseArray', 1, t, 'table') | ||
Line 194: | Line 219: | ||
end | end | ||
--[[ | |||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- sparseIpairs | -- sparseIpairs | ||
Line 200: | Line 226: | ||
-- 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 216: | Line 243: | ||
end | end | ||
--[[ | |||
------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | ||
-- size | -- size | ||
Line 222: | Line 250: | ||
-- 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 k in pairs(t) do | ||
i = i + 1 | i = i + 1 | ||
end | end | ||
return i | return i | ||
end | end | ||
return p | return p |