myReduce.html

<script src="..\my-jsArrayMethods\simpletest.js"></script>
<script>
    // The reduce() method applies a function against an accumulator and each element in the array (from left to right).
    // Result is reduced to a single value.

    // Parameters
    // originalArray.
    // callback: Function to execute on each element in the array, taking four arguments:
        // accumulator
            // The accumulator accumulates the callback's return values; 
            // it is the accumulated value previously returned in the last invocation of the callback, or initialValue, if supplied (see below).
        // currentValue
            // The current element being processed in the array.
        // currentIndexOptional
            // The index of the current element being processed in the array. 
            // Starts at index 0, if an initialValue is provided, and at index 1 otherwise.
        // arrayOptional
            // The array reduce() was called upon.
    // initialValueOptional
        // Value passed into callback on first iteration. 
            // If no initial value is supplied, the 1st element in the array will be used; iteration starts with 2nd el. 
        // Calling reduce() on an empty array without an initial value is an error.
    // Return value
        // The value that results from the reduction.
        
    // Notes: 
        // If initialValue isn't provided, reduce() will execute the callback function starting at index 1, using the first index as initialValue. 
        // If initialValue is provided, it will start at index 0.
        // If the array is empty and no initialValue is provided, TypeError will be thrown. 
        // If the array has only one element (regardless of position) and no initialValue is provided... 
            // or if initialValue is provided but the array is empty, ...
                // ...the solo value will be returned without calling callback.

    function myReduce(originalArray, callback, initialValue) {
        var startingIndex = 0;
        var reducedValue;
        // if no initialValue
        if (arguments.length < 3) {
            // If originalArray is empty, throw TypeError.
            if (Object.keys(originalArray).length === 0) {
                throw new TypeError ('Reduce of empty array with no initial value');
            }
            // If originalArray has only one element, just return it.
            if (Object.keys(originalArray).length === 1) {
                return originalArray[0];
            }
            while (startingIndex in originalArray === false && startingIndex < originalArray.length) {
                startingIndex ++;
            }
            reducedValue = originalArray[startingIndex];
            startingIndex++;
        } else { 
            // has initialValue
            if (Object.keys(originalArray).length === 0) {
                return initialValue;
            }
            reducedValue = initialValue;
        }
        for (var i = startingIndex; i < originalArray.length; i ++) {
            if (i in originalArray) {
                reducedValue = callback(reducedValue, originalArray[i], i, originalArray);   
            }
        }
        return reducedValue;
    }

    tests({
        'It should accept an optional initialValue to be used as the accumulator.' : function() {
            var testInitialValue = myReduce([], function() {}, 36);
            eq(testInitialValue, 36);
        },
        'If initialValue, callback should run originalArray.length times.': function() {
            callbackCounter = 0;
            myReduce([1, 2, 3], function(){
                callbackCounter ++;
            }, 1);
            eq(callbackCounter, 3);
        },
        'If no initialValue, callback should run (originalArray.length - 1) times.': function() {
            callbackCounter = 0;
            myReduce([1, 2, 3], function() {
                callbackCounter ++;
            });
            eq(callbackCounter, 2);
        },
        'If no initialValue, reducedValue should start as originalArray[0].' : function() {
            var testNoInitialValue = myReduce([1], function(acc, currentValue) {});
            eq(testNoInitialValue, 1);
        },
        'It should pass callback the current value of the element being evaluated.' : function() {
            var originalArray = [2];
            myReduce(originalArray, function(acc, currentValue) {
                for (i = 0; i < originalArray.length; i ++) {
                    eq(originalArray[i], 2);
                }
            });
        },
        'It should pass callback an optional index of the el being evaluated.' : function() {
            var originalArray = [3];
            myReduce(originalArray, function(acc, currentValue, index) {
                for (var i = 0; i < originalArray.length; i ++) {
                    eq(index, 0);
                }
            });
        },
        'It should pass callback the array being evaluated.' : function() {
            var originalArray = [1, 2, 3];
            myReduce(originalArray, function(acc, currentValue, index, testArray) {
                eq(testArray, originalArray);
            });
        },
        'It should reduce originalArray to single value based on callback.' : function() {
            var originalArray = [1, 2, 3];
            var reducedArrayValue = myReduce(originalArray, function(acc, num) {
                return acc + num;
            });
            eq(reducedArrayValue, 6)
        },
        'If initialValue, callback should not run on holes in the originalArray.' : function() {
            var originalArray = [, 2, , 4, ,];
            var reducedArrayValue = myReduce(originalArray, function(acc, num) {
                return acc + num;
            }, 0);
            eq(reducedArrayValue, 6);
        },
        'If no initialValue, callback should not run on holes at beginning of originalArray.' : function() {
            var originalArray = [, 2, , 4, ,];
            var reducedArrayValue = myReduce(originalArray, function(acc, num) {
                return acc + num;
            });
            eq(reducedArrayValue, 6);
        },
        'If array is empty, and no initialValue, throw TypeError.' : function() {
            var isTypeError = false;
            try {
                myReduce([], function() {});
            } catch(e) {
                isTypeError = (e instanceof TypeError);
            }
            eq(isTypeError, true);
        },
        'If array is empty, and initialValue, it should return initialValue without calling callback.': function() {
            var numberOfTimesCallbackHasRun = 0;
            var initialValue = 0;
            var reducedValue = myReduce([,,], function() {
                numberOfTimesCallbackHasRun++;
            }, initialValue);
            eq(reducedValue, initialValue);
            eq(numberOfTimesCallbackHasRun, 0);
        },
        'If array has one element, and no initialValue, it should return only element.' : function() {
            var reducedValue = myReduce([5], function() {});
            eq(reducedValue, 5);
        }
    });
</script>