Clone an array
Create a new array without copying the objects inside it.
function clone(values) { return [...values]; }arrayCollection · 50 utilities
Array utilities
Start with copies and equality, then move to grouping and aggregation. Notice where object identity differs from deep equality.
Remove duplicate values
Keep the first occurrence of each value, in its original order.
function unique(values) { return [...new Set(values)]; }arrayFlatten a nested array
Turn a nested array into one sequence of values.
function flatten(values) { return values.flat(Infinity); }arraySplit an array into chunks
Build consecutive chunks without changing the original array.
function chunk({ values, size }) { return Array.from({ length: Math.ceil(values.length / size) …arrayFind the intersection of arrays
Return the distinct values that occur in both arrays.
function intersection({ left, right }) { const other = new Set(right); return [...new Set(left)…arraySort numbers in ascending order
Sort a numeric copy instead of using JavaScript’s default string ordering.
function sortNumbers(values) { return [...values].sort((a, b) => a - b); }arraySum an array of numbers
Add numeric values with an explicit result for an empty array.
function sum(values) { return values.reduce((total, value) => total + value, 0); }arrayGroup objects by a key
Collect records by a string or numeric field without prototype-key collisions.
function groupBy({ values, key }) { const groups = new Map(); for (const value of values) { con…arrayCast a value as an array
Wrap a single value in an array and return arrays unchanged.
function castArray(value) { return Array.isArray(value) ? value : [value]; }arrayConvert an array of strings to numbers
Map every string with Number.
function toNumbers(values) { return values.map(Number); }arrayGet all subsets of an array
Build the power set, smallest subsets first.
function getSubsets(values) { return values.reduce((subsets, value) => subsets.concat(subsets.m…arrayGet union of arrays
Merge arrays and keep each value once, in first-seen order.
function union(arrays) { return [...new Set(arrays.flat())]; }arraySwap the rows and columns of a matrix
Transpose a rectangular matrix.
function transpose(matrix) { return matrix[0].map((_, column) => matrix.map(row => row[column])…arraySwap two array items
Return a copy with the items at i and j exchanged.
function swapItems({ values, i, j }) { const copy = [...values]; [copy[i], copy[j]] = [copy[j],…arrayUnzip an array of arrays
Regroup the n-th item of every array into the n-th output array.
function unzip(arrays) { return Array.from({ length: Math.max(0, ...arrays.map(array => array.l…arrayCompare two arrays
Check the same length and the same items in the same order.
function isEqual({ a, b }) { return a.length === b.length && a.every((value, i) => Object.is(va…arrayConvert an array of objects to a single object
Index records by a key field.
function toObject({ values, key }) { return Object.fromEntries(values.map(item => [item[key], i…arrayCount the occurrences of a value in an array
Count items strictly equal to a value.
function countOccurrences({ values, value }) { return values.filter(item => item === value).len…arrayCount the occurrences of array elements
Tally every distinct value into an object.
function countEach(values) { return { ...values.reduce((counts, value) => ((counts[value] = (co…arrayCreate an array of numbers in the given range
List the integers from min to max inclusive.
function range({ min, max }) { return Array.from({ length: max - min + 1 }, (_, i) => min + i);…arrayCreate cartesian product
Combine one item from each set in every possible way.
function cartesian(sets) { return sets.reduce((product, set) => product.flatMap(prefix => set.m…arrayFind the minimum item of an array
Spread the numbers into Math.min.
function min(values) { return Math.min(...values); }arrayGet the rank of an array of numbers
Rank each number by how many values are larger, starting at 1.
function ranking(values) { return values.map(value => values.filter(other => other > value).len…arrayRemove falsy values from array
Filter with Boolean.
function removeFalsy(values) { return values.filter(Boolean); }arrayZip multiple arrays
Pair the n-th items of several arrays.
function zip(arrays) { return Array.from({ length: Math.max(0, ...arrays.map(array => array.len…arrayCompare two arrays regardless of order
Compare the sorted sets of distinct values.
function isEqualIgnoringOrder({ a, b }) { const normalize = values => JSON.stringify([...new Se…arrayCount by the properties of an array of objects
Tally records by the value of one field.
function countBy({ values, key }) { return { ...values.reduce((counts, item) => ((counts[item[k…arrayCreate an array of cumulative sum
Replace each number with the running total up to it.
function accumulate(values) { let total = 0; return values.map(value => (total += value)); }arrayFind the index of the maximum item of an array
Return the index of the first largest number.
function indexOfMax(values) { return values.reduce((best, value, i) => (value > values[best] ? …arrayFind the maximum item of an array by given key
Return the record with the largest value in a field.
function maxBy({ values, key }) { return values.reduce((best, item) => (best === null || item[k…arrayFind the maximum item of an array
Spread the numbers into Math.max.
function max(values) { return Math.max(...values); }arrayGenerate an array of alphabet characters
List the first count lowercase ASCII letters.
function alphabet(count) { return Array.from({ length: count }, (_, i) => String.fromCharCode(9…arrayGet all arrays of consecutive elements
Slide a window of a given size across an array.
function windows({ values, size }) { return size > values.length ? [] : values.slice(size - 1).…arrayGet indices of a value in an array
Collect every index where a value appears.
function indices({ values, value }) { return values.flatMap((item, i) => (item === value ? [i] …arrayGet the average of an array
Divide the sum by the count.
function average(values) { return values.reduce((sum, value) => sum + value, 0) / values.length…arrayGet the unique values of an array
Keep the first occurrence of each value with a Set.
function uniqueValues(values) { return [...new Set(values)]; }arrayIntersperse element between elements
Insert a separator between every pair of items.
function intersperse({ values, separator }) { return values.flatMap((value, i) => (i === 0 ? [v…arraySort an array of items by given key
Return a copy sorted by one field, ascending.
function sortBy({ values, key }) { return [...values].sort((a, b) => (a[key] > b[key] ? 1 : a[k…arrayCheck if an array is empty
Return true for an array without items.
function isEmptyArray(value) { return Array.isArray(value) && !value.length; }arrayFind the closest number from an array
Return the item nearest to a target.
function closest({ values, target }) { return values.reduce((best, value) => (Math.abs(value - …arrayFind the index of the minimum item of an array
Return the index of the first smallest number.
function indexOfMin(values) { return values.reduce((best, value, i) => (value < values[best] ? …arrayFind the length of the longest string in an array
Map strings to lengths and take the maximum.
function longestLength(words) { return Math.max(0, ...words.map(word => word.length)); }arrayFind the minimum item of an array by given key
Return the record with the smallest value in a field.
function minBy({ values, key }) { return values.reduce((best, item) => (best === null || item[k…arrayGet all nth items of an array
Keep every nth item, starting with the nth.
function getNthItems({ values, nth }) { return values.filter((_, i) => i % nth === nth - 1); }arrayMerge two arrays
Concatenate two arrays, optionally dropping duplicates.
function merge({ a, b, unique = false }) { return unique ? [...new Set([...a, ...b])] : [...a, …arrayRepeat an array
Concatenate an array with itself n times.
function repeatArray({ values, times }) { return Array(times).fill(values).flat(); }arrayEmpty an array
Remove every item in place, so all references see an empty array.
function empty(values) { values.length = 0; return values; }arrayFind the index of the last matching item of an array
Scan from the end and return the first index whose item matches.
function lastIndex(values, predicate) { return values.findLastIndex(predicate); }arrayPartition an array based on a condition
Split items into [matching, not matching] in one pass.
function partition(values, predicate) { return values.reduce((groups, value) => (groups[predica…arrayShuffle an array
Return a new array in random order, every order equally likely.
function shuffle(values) { const result = [...values]; for (let i = result.length - 1; i > 0; i…arrayTry a function in the local code lab, then read its limits before using it in an application.