Module:TableTools：修订间差异

--                               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 not rawequal(v,v)

-- 浅复制一个表。

 

-- 浅复制一个表，但是忽略元表。

function p.rawShallowClone(t)

for _, v in next, t do

 

-- 往数组追加另一个数组的值。

function p.appendAll(t, another)

for _, v in ipairs(another) do

t[#t + 1] = v

 

function p.removeDuplicates(t)

for i, v in ipairs(t) do

if not rawequal(v, v) then

else

if not exists[v] then

ret[#ret + 1] = v

exists[v] = true

end

-- 返回有非nil值的数字键的表。

for k, v in pairs(t) do

-- 返回含有所有数字键的表，包括小数、负数。

function p.allNumKeys(t)

local nums = {}

for k, v in pairs(t) do

if type(k)=='number' then

nums[#nums + 1] = k

for k, v in pairs(t) do

if type(k) == 'string' then

--搜索指定前后缀的所有数字键，不限于整数。

local pattern = string.format('^%s(.-)%s$', prefix, suffix)

 

-- 将有("foo1", "bar1", "foo2", "baz2")这样键的表转换成

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

-- compress函数用来压实表以便用ipairs迭代。

-- 将像{a1='a1',b1='b1',a2='a2'}这样的表转换成

-- {a = {'a1', 'a2'}, b = {'b1'}}

-- 注意可能是稀疏数组。

-- pattern是正则表达式，匹配前缀和数字。

function p.allPrefixedNumKeys(t, pattern)

for k, v in pairs(t) do

local prefix, num = mw.ustring.match(tostring(k), pattern or '^([^0-9]*)([1-9][0-9]*)$')

 

-- 将稀疏数组压实，移除nil值。

-- 将所有键为数字的字段转化成按数字大小排序的数组。

local nums = p.allNumKeys(t)

for _, num in ipairs(nums) do

 

return key, t[key]

 

-- 返回表中字段的数量。

for k in pairs(t) do

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

 

-- 返回表中的键的列表，并使用默认比较函数或者自定义keySort函数比较。

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

-- 排序后迭代。

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

return function()

local key = list[i]

-- 排序后迭代，但是忽略元表。

function p.rawSortedPairs(t, keySort)

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

return function()

local key = list[i]

if key ~= nil then

return key, t[key]

-- 判断一个表是否为严格的数组。

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

-- 递归深度拷贝，保护标识和子表。

-- Stores copies of tables indexed by the original table.

already_seen = already_seen or {}

if type(orig) == 'table' then

copy = {}

for orig_key, orig_value in pairs(orig) do

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

return _deepCopy(orig, not noMetatable, already_seen)

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

 

table.insert(keys,k)

    notNum(k,v,keys,t)

return function()

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