Replacing a for loop that iterates over an array with the functional programming equivalent

Question

How would I accomplish the same thing in a functional paradigm?

Player.prototype.d2 = function(ratingList, rdList) {
    var tempSum = 0;
    for (var i = 0; i < ratingList.length; i++) {
        var tempE = this.e(ratingList[i], rdList[i]);
        tempSum += Math.pow(this.g(rdList[i]), 2) * tempE * (1 - tempE);
    }
    return 1 / Math.pow(q, 2) * tempSum;
};

Answer 1

I think something like this will work for you.

Array.prototype.zip = function(other) {
    if (!Array.prototype.isPrototypeOf(other)) {
            throw new TypeError('Expecting an array dummy!');
    }
    if (this.length !== other.length) {
            throw new Error('Must be the same length!');
    }
    var r = [];
    for (var i = 0, length = this.length; i < length; i++) {
        r.push([this[i], other[i]]);    
    }
    return r;
};

Player.prototype.d2 = function (ratingList, rdList) {
    var self = this;
    return 1 / Math.pow(q, 2) *
        ratingList
        .zip(rdList)
        .map(function (elem) {
            var tempE = self.e(elem[0], elem[1]);
            return Math.pow(self.g(elem[1]), 2) * tempE * (1 - tempE);
        })
        .reduce(function (acc, value) {
            return acc + value;
        });
};

Answer 2

I think this is essentially what you're looking for, if I'm not mistaken:

Player.prototype.d2 = function(ratingList, rdList) {
    return  Math.pow(q, -2) * ( 
        ratingList.reduce( ( sum, val, idx ) => {
            let tempE = this.e( val, rdList[idx] );
            return sum + Math.pow( this.g(rdList[idx]), 2 ) * tempE * ( 1 - tempE ); 
        }, 0)
    );
};

We start out with an anonymous function for d2, whose body is simply a return of the entire functional expression, which uses the Array.prototype.reduce function to compose a sum.

I've chosen to use ES6 so I can maintain scope this throughout my entire function.

Reduce explained on MDN and you should checkout Arrow functions.

One thing to note: a for loop is more performant than functional equivalents.