--- title: Array.prototype.reduceRight() slug: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight tags: - JavaScr - Mảng - Phương thức - Thuộc tính translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight ---

Phương thức reduceRight() đảo ngược các giá trị trong mảng (từ phải sang trái), xử lý và trả về một giá trị duy nhất.

var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) {
    return a.concat(b);
}, []);

// flattened is [4, 5, 2, 3, 0, 1]

Xem thêm {{jsxref("Array.prototype.reduce()")}} cho việc sắp xếp từ trái qua phải.

Cú pháp

arr.reduceRight(callback[, initialValue])

Tham số truyền vào

callback

Hàm gọi thực thi mỗi giá trị của mảng, truyền vào 4 tham số:

previousValue: Giá trí trả về của hàm callback sau khi xử lý phần tử trước nó hoặc là initialValue, nếu như nó là phần tử đầu tiên (Xem bên dưới.)
currentValue: Giá trị hiện tại đang được duyệt.
index: Chỉ số vị trí của phần tử trong mảng.
array: Mảng phần tử ban đầu.

initialValue

Giá trị không bắt buộc. Đối tượng sử dụng cho phần tử đầu tiền của mảng, khi mà chưa có kết quả nào từ hàm callback trả về.

Return value

Giá trị trả về từ việc rút gọn.

Mô tả

reduceRight xử lý từng phần tử trong mảng, trừ các phần tử vô giá trị (rỗng), truyền vào 4 tham số: giá trị ban đâu (or hoặc giá trị trả về sau khi xử lý một phần tử trước đó), giá trị phần tử hiện tại, vị trí phần tử hiện tại, và giá trị mảng ban đầu.

Việc xử lý phần tử hiện tại sẽ làm trong dấu (...) :

array.reduceRight(function(previousValue, currentValue, index, array) {
  // ... xử lý tại đây
});

Trong lần đầu xử lý, tham số previousValue và currentValue có thể là một trong hai.

Nếu tham sô initialValue được truyền vào reduceRight, thì tham số previousValue sẽ bằng giá trị tham số initialValue (nói cách khác nó chính là initialValue) and currentValue sẽ là giá trị cuối cùng của mảng.
Nếu tham số initialValue không được truyền vào, thì previousValue sẽ là giá trị cuối cùng của mảng và currentValue sẽ là giá trị cuối cùng thứ 2 của mảng ( giá trị thứ 2 tỉnh từ cuối mảng ).

Nếu mảng rỗng và không có tham số initialValue nào được truyền vào thì {{jsxref("TypeError")}} xảy ra. Nếu mảng chỉ có một phần tử (bất kể vị trí) à không có tham số initialValue nào được truyền vào, hoặc nếu initialValue được truyền vào nhưng mảng lại rỗng, giá trị duy nhất sẽ được trả lại mà không cần tới hàm callback.

Một số ví dụ mô tả luồng hoạt động của reduceRight, bạn có thể xem :

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

Bảng mô tả cách xử lý phần tử trong mảng ở ví dụ trên như sau:

(*Tên gọi các tham số giữ nguyên để tiện theo dõi)

`callback`	`previousValue`	`currentValue`	`index`	`array`	return value
lần 1	`4`	`3`	`3`	`[0, 1, 2, 3, 4]`	`7`
lần 2	`7`	`2`	`2`	`[0, 1, 2, 3, 4]`	`9`
lần 3	`9`	`1`	`1`	`[0, 1, 2, 3, 4]`	`10`
lần 4	`10`	`0`	`0`	`[0, 1, 2, 3, 4]`	`10`

Giá trị trả về của hàm reduceRight sẽ là giá trị của lần thực thi cuối cùng (10).

Và nếu bạn có đưa vào một giá trị initialValue, thì kết quả nó sẽ như thế này :

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

`callback`	`previousValue`	`currentValue`	`index`	`array`	return value
first call	`10`	`4`	`4`	`[0, 1, 2, 3, 4]`	`14`
second call	`14`	`3`	`3`	`[0, 1, 2, 3, 4]`	`17`
third call	`17`	`2`	`2`	`[0, 1, 2, 3, 4]`	`19`
fourth call	`19`	`1`	`1`	`[0, 1, 2, 3, 4]`	`20`
fifth call	`20`	`0`	`0`	`[0, 1, 2, 3, 4]`	`20`

Và tất nhiên giá trị trả về của hàm reduceRight sẽ là 20.

Ví dụ

Tính tổng các giá trị trong một mảng

var sum = [0, 1, 2, 3].reduceRight(function(a, b) {
  return a + b;
});
// sum is 6

Ghép nhiều mảng thành một mảng

var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) {
    return a.concat(b);
}, []);
// flattened is [4, 5, 2, 3, 0, 1]

Sự khác nhau giữa `reduce` và `reduceRight`

var a = ['1', '2', '3', '4', '5'];
var left  = a.reduce(function(prev, cur)      { return prev + cur; });
var right = a.reduceRight(function(prev, cur) { return prev + cur; });

console.log(left);  // "12345"
console.log(right); // "54321"

Polyfill

Đây là thuật ngữ dùng để chỉ các đoạn code được dùng để cung cấp một chức năng (hoặc công nghệ) của các trình duyệt hiện đại cho các trình duyệt cũ. Thông qua đó, các trang web sử dụng các công nghệ mới (như HTML5) có thể chạy ổn định trên các trình duyệt cũ chưa hỗ trợ.

reduceRight đã được thêm vào chuẩn ECMA-262 trong lần sửa đổi thứ 5; do đó có thể nó không xuất hiện trong các trình duyệt chưa hỗ trợ nó . Bạn có thể dùng reduceRight bằng việc thêm đoạn mã sau vào code của bạn với khi làm việc với các trình duyệt không hỗ trợ nó.

// Production steps of ECMA-262, Edition 5, 15.4.4.22
// Reference: http://es5.github.io/#x15.4.4.22
if ('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;
  };
}

Điều khoản

Specification	Status	Comment
{{SpecName('ES5.1', '#sec-15.4.4.22', 'Array.prototype.reduceRight')}}	{{Spec2('ES5.1')}}	Initial definition. Implemented in JavaScript 1.8.
{{SpecName('ES6', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}}	{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}}	{{Spec2('ESDraft')}}

Trình duyệt hỗ trợ

Feature	Chrome	Firefox (Gecko)	Internet Explorer	Opera	Safari
Basic support	{{CompatVersionUnknown}}	{{CompatGeckoDesktop("1.9")}}	{{CompatIE("9")}}	{{CompatOpera("10.5")}}	{{CompatSafari("4.0")}}

Feature	Android	Chrome for Android	Firefox Mobile (Gecko)	IE Mobile	Opera Mobile	Safari Mobile
Basic support	{{CompatVersionUnknown}}	{{CompatVersionUnknown}}	{{CompatVersionUnknown}}	{{CompatVersionUnknown}}	{{CompatVersionUnknown}}	{{CompatVersionUnknown}}

Xem thêm

{{jsxref("Array.prototype.reduce()")}}