array.chunk(obj:table,size:number):table

Returns a new array-like table with elements splitted into groups of length of `size`

              array.chunk({ 'a', 'b', 'c', 'd', 'e', 'f', 'g' }, 3)
-- { { 'a', 'b', 'c' }, { 'd', 'e', 'f' }, { 'g' } }
            

array.concat(obj:table,obj2:table):table

Return a new table joining all values from the two tables passed by parameter

              array.concat({ 1, 2, 3 }, { 4, 5, 6 })
-- { 1, 2, 3, 4, 5, 6 }
            

array.counter(obj:table):table

and value represent the number of times the same item was found in the list

              array.counter({ 'a', 'b', 'a', 'a', 'c', 'b' })
-- { a = 3, b = 2, c = 1 }
            

array.deep_copy(value:*):table

Return a deep copy of the table passed as parameter

              local object = { { a = 1 }, { b = 2 } }
local deep = array.deep_copy(object)

print(deep[1] == object[1])
-- true
            

array.diff(obj:table,obj2:table):table

Return a new table with the items which exist only in the first table

              local diff = array.counter({ 'a', 'b', 'c'}, { 'a', 'c', 'e' })

print(diff)
-- { 'b', 'e' }
            

array.each(obj:table,callback:function):void

Executes callback once for each table element

              array.each({ 'a' = 1, 'b' = 2 }, function(value, key)
  print(key)
  print(value)
end)
            

array.every(obj:table,obj2:table):table

Run a predicate on each value. If the predicate evaluates to any false value, this function will immediately return false; otherwise, it returns true.

              array.every({ 10, 20 }, function(value)
  return value >= 10
end)

-- true
            

array.fill(value:*,start_or_finish:number,finish:number):table

Creates a table filling all the elements from a start index (default one) to an end index with a default value

              array.fill('a', 3)
-- { 'a', 'a', 'a' }
            

array.filter(obj:table,callback:function):*

Create a new table containing all elements that pass truth test

              local result = array.filter({ 15, 10, 5, 3, 20 }, function(value)
  return value >= 10
end

print(result)
-- { 15, 10, 20 }

            

array.first(obj:table):*

Return first element from the table

              array.first({ 'a', 'b', 'c', 'd' })
-- 'a'

            

array.flat(obj:table, depth: number):table

Create a new table with the sub-table elements concatenated into it up to the specific depth.

              local result = array.flat({ 'a', 'b', 'c', { 'd', 'e', 'f', { 'g', 'h' } }, { 'i' }, 'j' }, 1)

print(result)
-- { 'a', 'b', 'c', 'd', 'e', 'f', { 'g', 'h' }, 'i', 'j' }

            

array.flat_map(obj:table, callback: function):table

Returns a new array-like table by applying a given callback to each element of the table, and then flattening the result by one level.

              local result = array.flat_map({ 1, 2, 3 }, function(value)
  return { value, value * 2 }
end)

print(result)
-- { 1, 2, 2, 4, 3, 6 }

            

array.from_pairs(obj1:table,obj2:table):table

Return a table composed from key-value pairs

              local result = array.from_pairs({ {'a', 1}, {'b', 2} })

print(result)
-- { a = 1, b = 2 }

            

array.group_by(obj:table,callback:function):table

Returns a new table composed by keys created from the results of running each element through `callback`

              local result = array.group_by({ 6.1, 4.1, 6.3, 4.4, 5.1 }, function(item)
  return math.floor(item)
end)

print(result)
-- { [4] = { 4.1, 4.4 }, [6] = { 6.1, 6.3 }, [5] = { 5.1 } }

            

array.includes(obj:table,value:*):boolean

Return true whether table includes the values, otherwise it returns false

              array.includes({ 'a', 'b', 'c' }, 'a')
-- true

            

array.index_of(obj:table,value:*):number

Return the index at which value can be found or -1 in case value is not present

              array.index_of({ 'a', 'b', 'c' }, 'b')
-- 2

            

array.intersect(obj1:table,obj2:table):table

Return a new table with the values that exist in both tables

              array.intersect({ 1, 2, 3 }, { 2, 3 })
-- { 2, 3 }

            

array.is_array(obj:table):boolean

Verify if table object works as an array

              array.is_array({ 'a' = 1 })
-- false

            

array.is_empty(obj:table):boolean

Check if parameter is an empty table

              array.is_empty({})
-- true

            

array.key_by(obj:table, callback:function):table

Creates a new table composed of keys generated from the results of running each element of the given table through the given callback

              result = array.key_by({ { id = 1, name = 'Evandro' }, { id = 2, name = 'John' } }, function(item)
  return item.id
end)

print(result)
-- { [1] = { id = 1, name = 'Evandro' }, [2] = { id = 2, name = 'John' } }

            

array.last(obj:table):*

Return last element from the table

              array.last({ 'a', 'b', 'c', 'd' })
-- 'd'

            

array.map(obj:table,callback:function):*

Create a new table of values by mapping each value in table through a transformation function

              local result = array.map({ 1, 2, 3 }, function(value)
  return value * 2
end)

print(result)
-- { 2, 4, 6 }

            

array.max(obj:table):*

Return maximum value from the table

              array.max({ 20, 22, 1, 3, 42, 30 })
-- 42

            

array.min(obj:table):*

Return minimum value from the table

              array.min({ 20, 22, 1, 3, 42, 30 })
-- 1

            

array.permutation(obj:table):table

Creates a new table returning all permutations of the length of the elements of the given table

              array.permutation({ 'lua', 'javascript', 'ruby' })
--{
--  { 'lua', 'javascript', 'ruby' },
--  { 'javascript', 'lua', 'ruby' },
--  { 'javascript', 'ruby', 'lua' },
--  { 'lua', 'ruby', 'javascript' },
--  { 'ruby', 'lua', 'javascript' },
--  { 'ruby', 'javascript', 'lua' }
--}

            

array.random(obj:table):*

Returns a value from a random key of the given array

              array.random({ 20, 22, 1, 3, 42, 30 })
            

array.reduce(obj:table,callback:function,memo:table):*

Applies a function against an accumulator and each value of the table to reduce it to a single value

              local result = array.reduce({ 'a', 'b', 'c', 'd', 'e' }, function(memo, value)
  return memo .. value
end)

print(result)
-- 'abcde'

            

array.reduce_right(obj:table,callback:function,memo:table):*

This function is like reduce except that it interates over table's elements from right to left

              local result = array.reduce({ 'a', 'b', 'c', 'd', 'e' }, function(memo, value)
  return memo .. value
end)

print(result)
-- 'abcde'

            

array.remove(obj:table,callback:function):table

and return a new table with the removed items

array.reverse(obj:table):table

Create a new table with reverse values

array.reverse_each(obj:table,callback:function):void

Executes callback once for each table element in reverse order

array.shallow_copy(obj:table):table

return a shallow copy of the table passed as parameter

array.slice(obj:table,start:number,finish:number):boolean

Return a shallow copy of a portion of a table into a new table

array.some(obj:table,callback:function):boolean

Tests if at least one element in the table passes the test implemented by the callback

array.sum(obj:table,callback:function):number

Return the sum of the values in table

array.uniq(obj:table):table

Create a new table, removing duplicates values

array.without(obj:table,values:table):table

Return a copy of the table with all instances of the values removed

array.zip(obj:table,obj2:table):table

Return a table of the two supplied by pairing up equally-positioned elements from both tables