Module:TableTools/sandbox: Difference between revisions

Revision as of 15:03, 17 December 2021

Latest revision as of 20:03, 14 August 2024

(15 intermediate revisions by 4 users not shown)

Line 64:

-- removed, but otherwise the array order is unchanged.

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

function p.removeDuplicates(tarr)

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

local isNan = p.isNan

local ret, exists = {}, {}

for _, v in ipairs(tarr) do

if isNan(v) then

-- NaNs can't be table keys, and they are also unique, so we don't need to check existence.

ret[#ret + 1] = v

elseif not exists[v] then

else

ifret[#ret not+ exists[v1] then= v

retexists[#ret + 1v] = vtrue

exists[v] = true

end

end

end

Line 337 ⟶ 335:

--

-- 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 = {}

for i, v in ipairs(arr) do

if not isNan(v) then

map[v] = i

map[v] = i

end

end

Line 355 ⟶ 356:

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

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

local isNan = p.isNan

local set = {}

for _, itemv in ipairs(tarr) do

if not isNan(v) then

set[item] = true

set[v] = true

end

end

Line 374 ⟶ 378:

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

local function _deepCopy(orig, includeMetatable, already_seen)

if type(orig) ~= "table" then

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

return orig

already_seen = already_seen or {}

end

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

local copy = already_seen[orig]

if copy ~= nil then

return copy

end

copy = {}

if type(orig) == 'table' then

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

copy = {}

for orig_key, orig_value in pairs(orig) do

for orig_key, orig_value in pairs(orig) do
copy[_deepCopy(orig_key, includeMetatable, already_seen)] = _deepCopy(orig_value, includeMetatable, already_seen)

end

already_seen[orig] = copy

if includeMetatable then

local mt = getmetatable(orig)

if includeMetatable then

localif mt ~= getmetatable(orig)nil then

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

if mt ~= nil then

local mt_copy = _deepCopy(mt, includeMetatable, already_seen)

setmetatable(copy, mt_copy)

already_seen[mt] = mt_copy

end

end

else -- number, string, boolean, etc

copy = orig

end

return copy

end

Line 405 ⟶ 407:

function p.deepCopy(orig, noMetatable, already_seen)

checkType("deepCopy", 3, already_seen, "table", true)

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

end

Line 458 ⟶ 460:

-- inArray

--

-- Returns true if valueToFindsearchElement 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(arrarray, valueToFindsearchElement, fromIndex)

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

-- if valueToFindsearchElement is nil, error?

fromIndex = tonumber(fromIndex)

for _, v in ipairs(arr) do

if v == valueToFindfromIndex then

if (fromIndex < 0) then

return true

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

end

return false

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

end