Module:TableTools/doc: Difference between revisions

== numKeys ==

TableTools.numKeys(t)

Takes a table <code>''t''</code> and returns an array containing the numbers of any positive integer keys that have non-nil values, sorted in numerical order. For example, for the table {{code|code={'foo', nil, 'bar', 'baz', a = 'b'}|lang=lua}}, <code>numKeys</code> will return {{code|code={1, 3, 4}|lang=lua}}.

== affixNums ==

TableTools.affixNums(t, prefix, suffix)

Takes a table <code>''t''</code> and returns an array containing the numbers of keys with the optional prefix <code>''prefix''</code> and the optional suffix <code>''suffix''</code>. For example, for the table {{code|code={a1 = 'foo', a3 = 'bar', a6 = 'baz'}|lang=lua}} and the prefix <code>'a'</code>, <code>affixNums</code> will return {{code|code={1, 3, 6}|lang=lua}}. All characters in <code>''prefix''</code> and <code>''suffix''</code> are interpreted literally.

== numData ==

TableTools.numData(t, compress)

Given a table with keys like <code>"foo1"</code>, <code>"bar1"</code>, <code>"foo2"</code>, and <code>"baz2"</code>, returns a table of subtables in the format {{code|code={ [1] = {foo = 'text', bar = 'text'}, [2] = {foo = 'text', baz = 'text'} }|lang=lua}}. Keys that don't end with an integer are stored in a subtable named <code>"other"</code>. The compress option compresses the table so that it can be iterated over with <code>ipairs</code>.

== compressSparseArray ==

TableTools.compressSparseArray(t)

Takes an array <code>''t''</code> with one or more nil values, and removes the nil values while preserving the order, so that the array can be safely traversed with <code>ipairs</code>. Any keys that are not positive integers are removed. For example, for the table {{code|code={1, nil, foo = 'bar', 3, 2}|lang=lua}}, <code>compressSparseArray</code> will return {{code|code={1, 3, 2}|lang=lua}}.

== sparseIpairs ==

TableTools.sparseIpairs(t)

This is an iterator function for traversing a sparse array <code>''t''</code>. It is similar to <code>[[mw:Extension:Scribunto/Lua reference manual#ipairs|ipairs]]</code>, but will continue to iterate until the highest numerical key, whereas <code>ipairs</code> may stop after the first <code>nil</code> value. Any keys that are not positive integers are ignored.

== size ==

TableTools.size(t)

Finds the size of a key/value pair table ([[associative array]]). For example, for {{code|code={foo = 'foo', bar = 'bar'}|lang=lua}}, <code>size</code> will return <code>2</code>. The function will also work on arrays, but for arrays it is more efficient to use the <code>#</code> operator. Note that to find the size, this function uses the <code>[[mw:Extension:Scribunto/Lua reference manual#pairs|pairs]]</code> function to iterate through all of the keys.

== sortedPairs ==

TableTools.sortedPairs(t, keySort)

Iterates through a table, with the keys sorted using the <code>keysToList</code> function. If there are only numerical keys, <code>sparseIpairs</code> is probably more efficient.

== isArray ==

TableTools.isArray(value)

Returns <code>true</code> if <code>''value''</code> is a table and all keys are consecutive integers starting at 1.

== isArrayLike ==

TableTools.isArrayLike(value)

Returns <code>true</code> if <code>''value''</code> is iterable and all keys are consecutive integers starting at 1.

== invert ==

TableTools.invert(arr)

Transposes the keys and values in an array. For example, {{code|invert{ "a", "b", "c" }|lua}} yields {{code|code={ a=1, b=2, c=3 }|lang=lua}}.

== listToSet ==

TableTools.listToSet(arr)

Creates a set from the array part of the table <code>''arr''</code>. Indexing the set by any of the values of the array returns <code>true</code>. For example, {{code|listToSet{ "a", "b", "c" }|lua}} yields {{code|code={ a=true, b=true, c=true }|lang=lua}}.

== deepCopy ==

TableTools.deepCopy(orig, noMetatable, alreadySeen)

Creates a copy of the table <code>''orig''</code>. As with <code>mw.clone</code>, all values that are not functions are duplicated and the identity of tables is preserved. If <code>''noMetatable''</code> is <code>true</code>, then the metatable (if any) is not copied. Can copy tables loaded with <code>mw.loadData</code>.

== sparseConcat ==

TableTools.sparseConcat(t, sep, i, j)

Concatenates all values in the table that are indexed by a positive integer, in order. For example, {{code|sparseConcat{ "a", nil, "c", "d" }|lua}} yields {{code|"acd"|lua}} and {{code|sparseConcat{ nil, "b", "c", "d" }|lua}} yields {{code|"bcd"|lua}}.

== length ==

TableTools.length(t, prefix)

Finds the length of an array or of a quasi-array with keys with an optional <code>''prefix''</code> such as "data1", "data2", etc. It uses an [[exponential search]] algorithm to find the length, so as to use as few table lookups as possible.

== inArray ==

Returns <code>true</code> if <code>''searchElement''</code> is a member of the array <code>''array''</code>, and <code>false</code> otherwise. Equivalent to the javascript [https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes Array.prototype.includes()] function, except fromIndex is 1-indexed instead of zero-indexed.

== merge ==

TableTools.merge(...)

Given the arrays, returns an array containing the elements of each input array in sequence.

== extend ==

TableTools.extend(arr1, arr2)

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