JavaScript数据结构01 - 数组

一、建立数组

1.1 运用Array组织函数

var arr1 = new Array(); // 建立一个空数组
var arr2 = new Array(10);   // 建立一个包括20项的数组
var arr3 = new Array('liu', 'wang', 'li');  // 建立一个包括3个字符串的数组

1.2 运用数组字面量示意法

var arr1 = [];  // 建立一个空数组
var arr2 = [10];    // 建立一个包括1项的数组
var arr3 = ['liu', 'wang', 'li'];   // 建立一个包括3个字符串的数组

二、经常使用数组要领

要领名 形貌
join 把数组的一切元素放入一个字符串,元素经由过程指定的分开符举行分开
pop 删除并返回数组的末了一个元素
push 向数组的末端增加一个或更多元素,并返回新的长度
shift 删除并返回数组的第一个元素
unshift 向数组的开首增加一个或更多元素,并返回新的长度
slice 从某个已有的数组返回指定的元素
indexOf 返回第一个与给定参数相称的数组元素的索引,没有找到则返回-1
lastIndexOf 返回在数组中搜刮到的与给定参数相称的元素的索引里的最大的值,没有找到则返回-1
sort 对数组的元素举行排序
splice 删除元素,并向数组增加新元素
toString 把数组转换为字符串,并返回效果
toLocaleString 把数组转换为当地字符串,并返回效果
valueOf 返回数组对象的原始值
forEach 对数组中的每一项运转指定函数,这个要领没有返回值
concat 衔接2个或更多数组,并返回效果
every 对数组中的每一项运转指定函数,假如该函数对每一项都返回true,则返回true
some 对数组中的每一项运转指定函数,假如任一项返回true,则返回true
filter 对数组中的每一项运转指定函数,返回该函数会返回true的项构成的数组
reverse 倒置数组中元素的递次
map 对数组中的每一项运转指定函数,返回每次函数挪用的效果构成的数组
reduce 吸收一个函数作为累加器,数组中的每一个值(从左到右)最先缩减,终究盘算为一个值
reduceRight 吸收一个函数作为累加器,数组中的每一个值(从右到左)最先缩减,终究盘算为一个值

PS:原始值是指牢固而简朴的值,存放在栈中的简朴数据段,它们的值直接存储在变量接见的位置。

JavaScript中有五种原始范例,也叫基础范例:

Number、String、Boolean、Undefined、Null

三、演示实例

3.1 join

定义和用法

join()要领用于把数组中的一切元素放入一个字符串。

元素是经由过程指定的分开符举行分开的。

语法

arrayObject.join(separator)

参数 形貌
seperator 可选。指定要运用的分开符,假如省略该参数,则运用逗号作为分开符

返回值

返回一个字符串。该字符串是经由过程把 arrayObject 的每一个元素转换为字符串,然后把这些字符串衔接起来,在两个元素之间插进去 separator 字符串而天生的。

var arr = new Array(3);
arr[0] = "Geroge";
arr[1] = "John";
arr[2] = "Thomas";

var str1 = arr.join();
var str2 = arr.join('');
var str3 = arr.join(' ');
var str4 = arr.join('-');

console.log(str1);  // "Geroge,John,Thomas"
console.log(str2);  // "GerogeJohnThomas"
console.log(str3);  // "Geroge John Thomas"
console.log(str4);  // "Geroge-John-Thomas"

3.2 pop

定义和用法

pop()要领用于删除并返回数组的末了一个元素。

语法

arrayObject.pop()

返回值

arrayObject 的末了一个元素。

申明

pop() 要领将删除 arrayObject 的末了一个元素,把数组长度减 1,而且返回它删除的元素的值。假如数组已为空,则 pop() 不转变数组,并返回 undefined 值。

var arr = new Array(3);
arr[0] = "Geroge";
arr[1] = "John";
arr[2] = "Thomas";

console.log(arr);           // ["Geroge", "John", "Thomas"]
console.log(arr.pop());     // "Thomas"
console.log(arr);           // ["Geroge", "Thomas"]

3.3 push

定义和用法

push()要领可向数组的末端增加一个或多个元素,并返回新的长度。

语法

arrayObject.push(newElement1, newElement2, …, newElementX)

参数 形貌
newElement1 必需。要增加到数组末端的第一个元素
newElement2 可选。要增加到数组末端的第二个元素
newElementX 可选。可增加多个元素

返回值

把指定的值增加到数组后的新长度。

申明

push() 要领可把它的参数递次增加到 arrayObject 的尾部。它直接修正 arrayObject,而不是建立一个新的数组。push() 要领和 pop() 要领运用数组供应的先进后出栈的功用。

var arr = new Array(3);
arr[0] = "Geroge";
arr[1] = "John";
arr[2] = "Thomas";

console.log(arr);                           // ["Geroge", "John", "Thomas"]
console.log(arr.push("James"));             // 4
console.log(arr);                           // ["Geroge", "John", "Thomas", "James"]
console.log(arr.push("Peter", "Sara"));     // 6
console.log(arr);                           // ["Geroge", "John", "Thomas", "James", "Peter", "Sara"]

3.4 shift

定义和用法

shift()要领用于把数组的第一个元素从个中删除,并返回第一个元素的值。

语法

arrayObject.shift()

返回值

数组本来的第一个元素的值。

申明

假如数组是空的,那末 shift() 要领将不举行任何操纵,返回 undefined 值。请注重,该要领不建立新数组,而是直接修正原有的 arrayObject。

var arr = new Array(3);
arr[0] = "Geroge";
arr[1] = "John";
arr[2] = "Thomas";

console.log(arr);           // ["Geroge", "John", "Thomas"]
console.log(arr.shift());   // "Geroge"
console.log(arr);           // ["John", "Thomas"]

3.5 unshift

定义和用法

unshift()要领可向数组的开首增加一个或多个元素,并返回新的长度。

语法

arrayObject.unshift(newElement1, newElement2, …, newElementX)

参数 形貌
newElement1 必需。要增加到数组开首的第一个元素
newElement2 可选。要增加到数组开首的第二个元素
newElementX 可选。可增加多个元素

返回值

arrayObject 的新长度。

申明

unshift() 要领将把它的参数插进去 arrayObject 的头部,并将已存在的元素顺次地移到较高的下标处,以便留出空间。该要领的第一个参数将成为数组的新元素 0,假如另有第二个参数,它将成为新的元素 1,以此类推。

请注重,unshift() 要领不建立新的建立,而是直接修正原有的数组。

var arr = new Array(3);
arr[0] = "Geroge";
arr[1] = "John";
arr[2] = "Thomas";

console.log(arr);                               // ["Geroge", "John", "Thomas"]
console.log(arr.unshift("James"));              // 4
console.log(arr);                               // ["James", "Geroge", "John", "Thomas"]
console.log(arr.unshift("Peter", "Sara"));      // 6
console.log(arr);                               // ["Peter", "Sara", "James", "Geroge", "John", "Thomas"]

3.6 slice

定义和用法

slice()要领可从已有的数组中返回选定的元素。slice()要领不转变原数组。

语法

arrayObject.slice(start, end)

参数 形貌
start 必需。划定从那边最先拔取。
假如是负数,那末它划定从数组尾部最先算起的位置。
也就是说,-1指末了一个元素,-2指倒数第二个元素,以此类推。
end 可选。划定从那边完毕拔取。
该参数是数组片段完毕处的数组下标。
假如没有指定该参数,那末切分的数组包括从start到数组完毕的一切元素。
假如这个参数是负数,那末它划定的是从数组尾部最先算起的元素。

返回值

返回一个新的数组,包括从 start 到 end (不包括该元素)的 arrayObject 中的元素。

申明

请注重,该要领并不会修正数组,而是返回一个子数组。假如想删除数组中的一段元素,应当运用要领 Array.splice()。

var arr = new Array(6);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
arr[3] = "James";
arr[4] = "Adrew";
arr[5] = "Martin";

console.log(arr);                   // ["Geroge", "John", "Thomas", "James", "Adrew", "Martin"]
console.log(arr.slice(0));          // ["Geroge", "John", "Thomas", "James", "Adrew", "Martin"]
console.log(arr.slice(1));          // ["John", "Thomas", "James", "Adrew", "Martin"]
console.log(arr.slice(1, 3));       // ["John", "Thomas"]
console.log(arr.slice(1, -2));      // ["John", "Thomas", "James"]
console.log(arr.slice(-1, -2));     // []
console.log(arr.slice(-2, -1));     // ["Adrew"]
console.log(arr);                   // ["Geroge", "John", "Thomas", "James", "Adrew", "Martin"]

3.7 indexOf

定义和用法

indexOf()要领可返回某个指定的值在数组中初次涌现的位置。从左往右找,找不到返回-1。

语法

arrayObject.indexOf(searchValue, fromIndex)

参数 形貌
searchValue 必需。划定需检索的值。
fromIndex 可选的整数参数,最先查找的位置。
假如该索引值大于或即是数组长度,意味着不会在数组里查找,返回-1。
假如参数中供应的索引值是一个负值,则将其作为数组末端的一个抵消,
即-1示意从末了一个元素最先查找,-2示意从倒数第二个元素最先查找 ,以此类推。
注重:假如参数中供应的索引值是一个负值,并不转变其查找递次,
查找递次依然是夙昔向后查询数组。假如抵消后的索引值仍小于0,
则全部数组都将会被查询。其默认值为0
var arr = new Array(6);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
arr[3] = "James";
arr[4] = "Adrew";
arr[5] = "Martin";

console.log(arr.indexOf('Thomas'));             // 2
console.log(arr.indexOf('Thomas', 2));          // 2
console.log(arr.indexOf('Thomas', 3));          // -1
console.log(arr.indexOf('Thomas', -4));         // 2
console.log(arr.indexOf('Thomas', -3));         // -1
console.log(arr.indexOf('Peter'));              // -1

3.8 lastIndexOf

定义和用法

lastIndexOf()要领可返回某个指定的值在数组中初次涌现的位置。从右往左找,找不到返回-1。

语法

arrayObject.indexOf(searchValue, fromIndex)

参数 形貌
searchValue 必需。划定需检索的值。
fromIndex 可选的整数参数,今后位置最先逆向查找。
默以为数组的长度减 1,即全部数组都被查找。
假如该值大于或即是数组的长度,则全部数组会被查找。
假如为负值,将其视为从数组末端向前的偏移。
纵然该值为负,数组依然会被从后向前查找。
假如该值为负时,其绝对值大于数组长度,则要领返回 -1,即数组不会被查找
var arr = new Array(6);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
arr[3] = "James";
arr[4] = "Adrew";
arr[5] = "Martin";

console.log(arr.lastIndexOf('Thomas'));             // 2
console.log(arr.lastIndexOf('Thomas', 2));          // 2
console.log(arr.lastIndexOf('Thomas', 3));          // 2
console.log(arr.lastIndexOf('Thomas', 1));          // -1
console.log(arr.lastIndexOf('Thomas', -4));         // 2
console.log(arr.lastIndexOf('Thomas', -3));         // 2
console.log(arr.lastIndexOf('Peter'));              // -1

3.9 sort

定义和用法

sort()要领用于对数组的元素举行排序。

语法

arrayObject.sort(sortby)

参数 形貌
sortby 可选。划定排序递次。必需是函数。

返回值

对数组的援用。请注重,数组在原数组上举行排序,不天生副本。

申明

假如挪用该要领时没有运用参数,将按字母递次对数组中的元素举行排序,说的更准确点,是根据字符编码的递次举行排序。要完成这一点,起首应把数组的元素都转换成字符串(若有必要),以轻易比较。

假如想根据其他规范举行排序,就须要供应比较函数,该函数要比较两个值,然后返回一个用于申明这两个值的相对递次的数字。比较函数应当具有两个参数a和b,其返回值以下:

  • 若a小于b,在排序后的数组中a应当涌现在b之前,则返回一个小于0的值。
  • 若a即是b,则返回0。
  • 若a大于b,则返回一个大于0的值。

即递次 return a – b; 倒序 return b – a;

a在b前返回负数,a在b后返回正数

var arr = new Array(6);
arr[0] = "10";
arr[1] = "5";
arr[2] = "40";
arr[3] = "25";
arr[4] = "1000";
arr[5] = "1";

console.log(arr);           // ["10", "5", "40", "25", "1000", "1"]
console.log(arr.sort());    // ["1", "10", "1000", "25", "40", "5"]
console.log(arr);           // ["1", "10", "1000", "25", "40", "5"]
var arr = new Array(6);
arr[0] = "10";
arr[1] = "5";
arr[2] = "40";
arr[3] = "25";
arr[4] = "1000";
arr[5] = "1";

function orderNumber (a, b) {
    return a - b;
}

function descOrderNumber (a, b) {
    return b - a;
}

console.log(arr);                           // ["10", "5", "40", "25", "1000", "1"]
console.log(arr.sort(orderNumber));         // ["1", "5", "10", "25", "40", "1000"]
console.log(arr.sort(descOrderNumber));     // ["1000", "40", "25", "10", "5", "1"]
console.log(arr);                           // ["1000", "40", "25", "10", "5", "1"]

3.10 splice

定义和用法

splice()要领向/从数组中增加/删除项目,然后返回被删除的项目。该要领会转变原始数组。

语法

arrayObject.splice(index, howmany, item1, ……, itemX)

参数 形貌
index 必需。整数,划定增加/删除项目的位置,运用负数可从数组结尾处划定位置。
howmany 必需。要删除的项目数目。假如设置为0,则不会删除项目。
item1,……,itemX 可选。向数组增加的新项目。

返回值

范例 形貌
Array 包括被删除项目的新数组,假若有的话。

申明

splice()要领可删除从index处最先的0个或多个元素,而且用参数列表中声明的一个或多个值来替代那些被删除的元素。假如从arrayObject中删除了元素,则返回的是含有被删除的元素的数组。

var arr = new Array(6);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
arr[3] = "James";
arr[4] = "Adrew";
arr[5] = "Martin";

console.log(arr);                                   // ["Geroge", "John", "Thomas", "James", "Adrew", "Martin"]  
console.log(arr.splice(1, 1, 'Peter', 'Sara'));     // ["John"]
console.log(arr);                                   // ["Geroge", "Peter", "Sara", "Thomas", "James", "Adrew", "Martin"]
console.log(arr.splice(1, 0, 'Ella'));              // []
console.log(arr);                                   // ["Geroge", "Ella", "Peter", "Sara", "Thomas", "James", "Adrew", "Martin"]

3.11 toString

定义和用法

toString()要领可把数组转换为字符串,并返回效果。

语法

arrayObject.toString()

返回值

arrayObject的字符串示意。返回值与没有参数的join()要领返回的字符串雷同。

申明

当数组用于字符串环境时,JavaScript会挪用这一要领将数组自动转换成字符串。但是在某些情况下,须要显式地挪用该要领。

var arr = new Array(4);
arr[0] = "Geroge";
arr[1] = "John";
arr[2] = "Thomas";
arr[3] = 20;

console.log(arr.toString());    // "Geroge,John,Thomas,20"

3.12 toLocaleString

定义和用法

toLocaleString()要领可把数组转换为当地字符串,并返回效果。

语法

arrayObject.toLocaleString()

返回值

arrayObject的当地字符串示意。

申明

起首挪用每一个数组元素的 toLocaleString() 要领,然后运用区域特定的分开符把天生的字符串衔接起来,构成一个字符串。

var arr = new Array(4);
arr[0] = "Geroge";
arr[1] = "John";
arr[2] = "Thomas";
arr[3] = 20;

console.log(arr.toLocaleString());    // "Geroge,John,Thomas,20"

3.13 valueOf

定义和用法

valueOf()要领返回Array对象的原始值。该原始值由Array对象派生的一切对象继续。valueOf()要领平常由JavaScript在背景自动挪用,并不显式地涌现在代码中。

语法

arrayObject.valueOf()

var arr = new Array(4);
arr[0] = "Geroge";
arr[1] = "John";
arr[2] = "Thomas";
arr[3] = 20;

console.log(arr.valueOf());    // ["Geroge", "John", "Thomas", 20]

3.14 forEach

定义和用法

forEach()要领用于挪用数组的每一个元素,并将元素传递给回调函数。forEach()关于空数组是不会实行回调函数的。

语法

arrayObject.forEach(function (value, index, arr) {}, thisValue)

参数 形貌
function(currentValue, index, arr) 必需。数组中每一个元素须要挪用的函数。
currentValue: 必需。当前元素。
index: 可选。当前元素的索引值。
arr: 可选。当前元素所属的数组对象。
thisValue 可选。传递给函数的值平常用’this’值。
假如这个参数为空,严厉形式下把’undefined’会传递给’this’值,一般形式下传入’window’。
var arr = new Array(3);
arr[0] = "Geroge";
arr[1] = "John";
arr[2] = "Thomas";

arr.forEach(function (value, index, arr) {
    console.log(value);     // "Geroge" "John" "Thomas"
    console.log(index);     // 0        1      2
    console.log(arr);       // ["Geroge", "John", "Thomas"]
    console.log(this);      // window
});

arr.forEach(function (value, index, arr) {
    console.log(value);     // "Geroge" "John" "Thomas"
    console.log(index);     // 0        1      2
    console.log(arr);       // ["Geroge", "John", "Thomas"]
    console.log(this);      // ["Geroge", "John", "Thomas"]
}, arr);

3.15 concat

定义和用法

concat()要领用于衔接两个或多个数组。该要领不会转变现有的数组,而仅仅会返回被衔接数组的一个副本。

语法

arrayObject.concat(arrayX,arrayX,……,arrayX)

参数 形貌
arrayX 必需。该参数可所以详细的值,也可所以数组对象。可所以恣意多个。

返回值

返回一个新的数组。该数组是经由过程把一切arrayX参数增加到arrayObject中天生的。假如要举行concat()操纵的参数是数组,那末增加的是数组中的元素,而不是数组。

var a = [1, 2, 3];

console.log(a.concat(4, 5, [6, 7], 8, 9));  // [1, 2, 3, 4, 5, 6, 7, 8, 9]

3.16 every

定义和用法

every()要领用于检测数组一切元素是不是都相符指定前提(经由过程函数供应)。
every()要领运用指定函数检测数组中的一切元素:

  • 假如数组中检测到有一个元素不满足,则全部表达式返回false,且盈余的元素不会再举行检测。
  • 假如一切元素都满足前提,则返回true。

注重:every()不会对空数组举行检测。
注重:every()不会转变原始数组。

语法

arrayObject.every(function (currentValue, index, arr) {}, thisValue)

参数 形貌
function (currentValue, index, arr) 必需。函数,数组中的每一个元素都邑实行这个函数。
currentValue: 必需。当前元素。
index: 可选。当前元素的索引值。
arr: 可选。当前元素所属的数组对象。
thisValue 可选。对象作为该实行回调时运用,传递给函数。

申明

有一个返回false,则全部every()返回值为false,而且不会实行后续其他项的回调函数。
空数组的every()直接返回true。

var ages = [10, 20, 24, 32, 40];

var result = ages.every(function (value, index, arr) {
    return value > 25;
});

console.log(result);    // false

ages = [];
result = ages.every(function (value, index, arr) {
    return value > 25;
});

console.log(result);    // true

3.17 some

定义和用法

some()要领用于检测数组一切元素是不是满足指定前提(经由过程函数供应)。
every()要领会顺次实行数组的每一个元素:

  • 假若有一个元素满足前提,则表达式返回true,盈余的元素不会再实行检测。
  • 假如没有满足前提的元素,则返回false。

注重:some()不会对空数组举行检测。
注重:some()不会转变原始数组。

语法

arrayObject.some(function (currentValue, index, arr) {}, thisValue)

参数 形貌
function (currentValue, index, arr) 必需。函数,数组中的每一个元素都邑实行这个函数。
currentValue: 必需。当前元素。
index: 可选。当前元素的索引值。
arr: 可选。当前元素所属的数组对象。
thisValue 可选。对象作为该实行回调时运用,传递给函数。

申明

有一个返回true,则全部some()返回值为true,而且不会实行后续其他项的回调函数。
空数组的some()直接返回false。

var ages = [10, 20, 24, 32, 40];

var result = ages.some(function (value, index, arr) {
    return value > 25;
});

console.log(result);    // true

ages = [];
result = ages.some(function (value, index, arr) {
    return value > 25;
});

console.log(result);    // false

3.18 filter

定义和用法

filter()要领建立一个新的数组,新数组中的元素是经由过程搜检指定数组中相符前提的一切元素。

注重:filter()不会对空数组举行检测。
注重:filter()不会转变原始数组。

语法

arrayObject.filter(function (currentValue, index, arr) {}, thisValue)

参数 形貌
function (currentValue, index, arr) 必需。函数,数组中的每一个元素都邑实行这个函数。
currentValue: 必需。当前元素。
index: 可选。当前元素的索引值。
arr: 可选。当前元素所属的数组对象。
thisValue 可选。对象作为该实行回调时运用,传递给函数。

申明

将一切返回true的数组项取出来构成一个新的数组。

var ages = [10, 20, 24, 32, 40];

var result = ages.filter(function (value, index, arr) {
    return value > 25;
});

console.log(result);    // [32, 40]
console.log(ages);      // [10, 20, 24, 32, 40]

ages = [];
result = ages.filter(function (value, index, arr) {
    return value > 25;
});

console.log(result);    // []

3.19 reverse

定义和用法

reverse()要领用于倒置数组中元素的递次。会转变原数组。

语法

arrayObject.reverse()

var arr = new Array(3);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";

console.log(arr);               // ["Geroge", "John", "Thomas"]
console.log(arr.reverse());     // ["Thomas", "John", "Geroge"]
console.log(arr);               // ["Thomas", "John", "Geroge"]

3.20 map

定义和用法

map()要领返回一个新数组,数组中的元素为原始数组元素挪用函数处置惩罚后的值。map()要领根据原始数组元素递次顺次处置惩罚元素。

注重:map()不会对空数组举行检测。
注重:map()不会转变原始数组。

语法

arrayObject.map(function (currentValue, index, arr) {}, thisValue)

参数 形貌
function (currentValue, index, arr) 必需。函数,数组中的每一个元素都邑实行这个函数。
currentValue: 必需。当前元素。
index: 可选。当前元素的索引值。
arr: 可选。当前元素所属的数组对象。
thisValue 可选。对象作为该实行回调时运用,传递给函数。
var numbers = [65, 20, 11, 5];

var arr = numbers.map(function (value, index, arr) {
    return value * 2;
})

console.log(numbers);   // [65, 20, 11, 5]
console.log(arr);       // [130, 40, 22, 10]

3.21 reduce

定义和用法

reduce()要领吸收一个函数作为累加器,数组中的每一个值(从左到右)最先缩减,终究盘算为一个值。

注重:reduce()关于空数组是不会实行回调函数的。

语法

arrayObject.reduce(function (total, currentValue, currentIndex, arr) {}, initialValue)

参数 形貌
function (total, currentValue, currentIndex, arr) 必需。函数,数组中的每一个元素都邑实行这个函数。
total: 必需。初始值,或许盘算完毕后的返回值。
currentValue: 必需。当前元素。
currentIndex: 可选。当前元素的索引。
arr: 可选。当前元素所属的数组对象。
initialValue 可选。传递给函数的初始值。
var numbers = [15, 2, 1, 7];

var total = numbers.reduce(function (total, currentValue) {
    console.log(total);             // 15 17 18 25
    console.log(currentValue);      // 2  1  7
    return total + currentValue;
});

console.log(total);                 // 25
console.log(numbers);               // [15, 2, 1, 7]

total = numbers.reduce(function (total, currentValue) {
    console.log(total);             // 20 35 37 38 45
    console.log(currentValue);      // 15 2  1  7
    return total + currentValue;
}, 20);

console.log(total);                 // 45
console.log(numbers);               // [15, 2, 1, 7]

3.22 reduceRight

定义和用法

reduceRight()要领的功用和reduce()功用是一样的,差别的是reduceRight()从数组的末端向前将数组中的数组项做累加。

注重:reduceRight()关于空数组是不会实行回调函数的。

语法

arrayObject.reduceRight(function (total, currentValue, currentIndex, arr) {}, initialValue)

参数 形貌
function (total, currentValue, currentIndex, arr) 必需。函数,数组中的每一个元素都邑实行这个函数。
total: 必需。初始值,或许盘算完毕后的返回值。
currentValue: 必需。当前元素。
currentIndex: 可选。当前元素的索引。
arr: 可选。当前元素所属的数组对象。
initialValue 可选。传递给函数的初始值。
var numbers = [15, 2, 1, 7];

var total = numbers.reduceRight(function (total, currentValue) {
    console.log(total);             // 7 8 10 25
    console.log(currentValue);      // 1 2 15
    return total + currentValue;
});

console.log(total);                 // 25
console.log(numbers);               // [15, 2, 1, 7]

total = numbers.reduceRight(function (total, currentValue) {
    console.log(total);             // 20 27 28 30 45
    console.log(currentValue);      // 7  1  2  15
    return total + currentValue;
}, 20);

console.log(total);                 // 45
console.log(numbers);               // [15, 2, 1, 7]

完毕

本文会同步到我的个人博客,完全代码能够到我的github堆栈检察,假如对你有协助的话迎接点一个Star~~

迎接关注我的民众号

《JavaScript数据结构01 - 数组》

    原文作者:liuxuan
    原文地址: https://segmentfault.com/a/1190000015765638
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞