Array reduce — JavaScript Challenge | FineFrontend

Practice workspaceSign in

JavaScript/Array reduceeasy

00:00

Read here. Code on desktop. The coding workspace opens on screens 1024px and wider.

JavaScript interview question

Array reduce

easy10 min

Implement arrayReduce to recreate the core behavior of Array.prototype.reduce using a loop. Work with a standalone function that receives the array as its first argument.

Requirements

Accept an actual JavaScript array and a callback. Array-like objects, Array subclasses/species, and prototype installation are outside this beginner exercise.
Do not use native map, filter, reduce, reduceRight, flatMap, or forEach to implement the function. Do not modify Array.prototype.
Visit existing indexes in ascending order, skip sparse holes, and capture the initial length so appended items are not visited. Check each index when it is reached so deleted future entries are skipped.
Pass the value, index, and original array to the callback, preceded by the accumulator.
Do not mutate the input array yourself. Callback side effects are permitted; propagate callback exceptions.
Throw TypeError when the callback is not a function, even when the array is empty.
When initialValue is supplied, use it even if it is undefined, null, false, or zero. Otherwise use the first existing element and start callbacks at the next existing index.
Return the initial value for an empty array when supplied; otherwise throw TypeError for an empty or all-hole array.
The accumulator may have a different type from array elements when an initial value is supplied.

Examples

Example 1

Input: arrayReduce([1, 2, 3], (sum, value) => sum + value, 0)
Output: 6

Example 2

Input: arrayReduce([], (sum, value) => sum + value, 10)
Output: 10

Example 3

Input: arrayReduce([], (sum, value) => sum + value)
Output: Throws TypeError

arrayReduce(array, callback, initialValue?) — standalone equivalent for arrays.

What the tests check

Reduces with an initial accumulator
Uses the first element when initial value is omitted
Supports a different accumulator type
Handles empty arrays with an initial value
Throws TypeError for empty or all-hole arrays without an initial value
Distinguishes explicit undefined from an omitted initial value
Skips holes when selecting and reducing values
Returns a single element without calling the callback
Passes the current value, index, and original array
Leaves a frozen input unchanged
Ignores appended items and skips deleted future entries
Propagates callback failures
Rejects a non-function callback even for an empty array

References

Array.prototype.reduce

ArraysFunctionsCallbacksIterationSparse arrays

Back

Preparing your workspace…