O métodoreduceRight() aplica à uma função um acumulador e cada valor do array (da direita para esquerda) é reduzido para um valor único.

arr.reduceRight(callback[, initialValue])

callback

Função para executar em cada valor do array, recebendo quatro argumentos:

previousValue

O valor anteriormente retornado na ultima invocação do callback, ou oinitialValue, se este for o recebido. (Ver abaixo.)

currentValue

O valor atualmente sendo processado no array.

index

O índice do valor atualmente sendo processado no array.

array

O array que foi chamado para ser reduzido.

initialValue

Opcional. Objeto para ser usado como argumento inicial da primeria chamada do callback.

reduceRight executa a função callback uma vez para cada elemento presente no array, excluindo buracos no array, recebendo quatro argumentos: o valor inicial (ou o valor da chamada anterior do callback), o valor do elemento atual, o índice do elemento atual, e o array onde a operação está acontecendo.

A chamada ao callback reduceRight irá parecer com uma chamada assim:

array.reduceRight(function (previousValue, currentValue, index, array) {  // ...});

A primeira vez que a função é chamada, opreviousValue e ocurrentValue podem ser um de dois valores. Se uminitialValue foi recebido na chamada doreduceRight, então opreviousValue sera iqual aoinitialValue e ocurrentValue será igual ao ultimo valor no array. Se oinitialValue não foi recebido, então opreviousValue será igual ao ultimo valor no array e ocurrentValue será igual ao penultimo valor no array.

Se o array é vazio e nenhuminitialValue foi recebido,TypeError será lançado. Se o array somente tem um elemento (independentemente da posição dele) e oinitialValue não foi recebido, ou se oinitialValue foi recebido mas o array é vazio, o valor em si será retornado sem chamar ocallback.

Alguns exemplos de execuções da função e como será parecida a chamada:

[0, 1, 2, 3, 4].reduceRight(  function (previousValue, currentValue, index, array) {    return previousValue + currentValue;  },);

O callback será invocado quatro vezes, com os argumentos e valores de retornos em cada chamada será como o seguinte:

O valor retornado peloreduceRight será o valor retornado pela ultima chamada ao callback(10).

E se você também passou uminitialValue, o resultado irá ser como a seguir:

[0, 1, 2, 3, 4].reduceRight(function (  previousValue,  currentValue,  index,  array,) {  return previousValue + currentValue;}, 10);

O valor retornado peloreduceRight desta vez será, obviamente,20.

reduceRight foi adicionado no padrão ECMA-262 em sua Quinta edição; sendo assim pode não estar presente em todas as implementações deste padrão. Você pode contornar isso adicionando o seguinte codigo ao inicio do seu script, adicionando a possibilidade de uso doreduceRight em implementações que não o suportam nativamente.

// Production steps of ECMA-262, Edition 5, 15.4.4.22// Reference: http://es5.github.io/#x15.4.4.22if ("function" !== typeof Array.prototype.reduceRight) {  Array.prototype.reduceRight = function (callback /*, initialValue*/) {    "use strict";    if (null === this || "undefined" === typeof this) {      throw new TypeError("Array.prototype.reduce called on null or undefined");    }    if ("function" !== typeof callback) {      throw new TypeError(callback + " is not a function");    }    var t = Object(this),      len = t.length >>> 0,      k = len - 1,      value;    if (arguments.length >= 2) {      value = arguments[1];    } else {      while (k >= 0 && !(k in t)) {        k--;      }      if (k < 0) {        throw new TypeError("Reduce of empty array with no initial value");      }      value = t[k--];    }    for (; k >= 0; k--) {      if (k in t) {        value = callback(value, t[k], k, t);      }    }    return value;  };}

• Array.prototype.reduce()