How do I make this average function better/more elegant?

Question

I have this function that calculates average. I don't want it to look like this. I am hoping for a less cliche average function. Because I see that most people's look like this. Can anyone help?

function mean(array) {
    var num=0;
    for (var i=1;i<=array.length;i++) num=num+array[i];
    var divide=num/array.length;
    alert(divide);
}​

Can anyone change this up to be better than before? It doesn't have to be more efficient but just look better. Thanks! (By the way I'm new to JavaScript so if you can explain your code that'd be great).

Answer 1

First of all, your code is incorrect. Arrays have a starting index of 0, not 1. Furthermore, array.length is one more than the last filled index (because the length is 1 based, and the array is 0 based. Yes, this is confusing.) So you're starting by not including the first item, and then also adding up an undefined item.

And what happens if you get an empty array? You divide by zero, which is MADNESS!! MADNESS I TELL YOU!

Second, there's a reason the code looks the same as everywhere: You have followed the definition of the average; the sum of components divided by the number of components. There's no shame in this, you should actually be proud that you've managed to conform to the standard.

If you really want, you can make the loop implicit. ES5 (ECMAScript 5, the latest js standard) defined an Array.prototype.reduce function (click link for the reference.) It's a perfect fit for your needs, but doesn't change the core algorithm.

Third, your mean function is doing something unexpected: Instead of just calculating the mean, it displays it as well. This does not follow expectations (or at least my expectation), as a function which calculates the mean should do that, and just that. That translates to a very important design aspect, which says that a function should do one thing, one thing only, and do it well. Because imagine if Math.sqrt, for instance, starts displaying the square roots instead of giving you them. Like division by zero, it's madness all over again!

Answer 2

Zirak's answer is all the advice you need, but since he didn't actually write any code, here's how I might re-write it.

function mean(arr) { // it's ok to use short variable names in short, simple functions
    // set all variables at the top, because of variable hoisting
    var i,
        sum = 0, // try to use informative names, not "num"
        len = arr.length; // cache arr.length because accessing it is usually expensive
    for (i = 0; i < len; i++) { // arrays start at 0 and go to array.length - 1
        sum += arr[i]; // short for "sum = sum + arr[i];"
    } // always use brackets. It'll save you headaches in the long run
    // don't mash your computation and presentation together; return the result.
    return sum / len;
}

Note that this code is optimized for arrays with at least 1 element; if the majority of its uses are on 0-length arrays, you'd see a performance boost if you added a short return.

Alternatively you can use Array.prototype.reduce. I highly recommend that you not use this method - while it is more "unique", it is also much harder to understand and much less efficient. And good code strives to be readable and efficient (and robust), not unique.

var mean = (function () { // Use an IIFE to get private storage
    // cache this function - it's very expensive to re-create it every time you call mean()
    function addLast(prev, current) {
        return prev + current;
    }
    // return an anonymous function. When we call mean(), this is what is called. The reason
    // we can't set it directly is because we need something with access to addLast, and we
    // don't want addLast in the global scope.
    return function (arr) {
        return arr.reduce(addLast, 0) / arr.length;
    };
})(); // end of IIFE. executes the function and sets mean to the return value.

Answer 3

More efficient: No; More readable: Yes

function mean( list, more ) {

    if ( more ) {

        list = [].slice.call( arguments );

    } else if ( !list || list[0] === undefined ) return;

    var a = list,
        b = list.length;


    return (function execute() {

        if ( !a.length ) return 0;

        return ( a.pop() / b ) + execute();

    })();

}

What this function basically does is use recursion to divide each number in the array by the length of the array. Since this is true...

I use that logic in the function and it works just fine.