JAVASCRIPT引用类型之Array类型（四）

最新推荐文章于 2024-06-30 22:19:51 发布

xzp_forever

最新推荐文章于 2024-06-30 22:19:51 发布

阅读量217

点赞数

分类专栏： Javascript 文章标签： JavaScript Array 迭代方法缩小方法

本文链接：https://blog.csdn.net/xzp_forever/article/details/88883144

版权

Javascript 专栏收录该内容

27 篇文章 1 订阅

订阅专栏

Array类型

indexOf() 和 lastIndexOf() ：

ECMAScript为数组实例添加了两个位置方法： indexOf() 和 lastIndexOf() 。这两个方法都接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中, indexOf() 方法从数组的开头（位置0）开始向后查找，lastIndexOf() 方法则从数组的末尾开始向前查找。

这两个方法都返回要查找的项在数组中的位置，或者在没有找到的情况下返回-1。在比较第一个参数与数据中的每一项时，会使用全等操作符；也就是说，要求查找的项必须样相等（就像使用===一样）。如下：

var numbers = [1,2, 3, 4, 5, 4, 3, 2, 1];

alert(numbers.indexOf(4));              //3
alert(numbers.lastIndexOf(4));          //5

alert(numbers.indexOf(4, 4));           //5
alert(numbers.lastIndexOf(4, 4));       //3

var person = {name : "Nicholas"};
var people = [{name : "NIcholas"}];

var morePeople = [person];

alert(people.indexOf(person));          //-1
alert(morePeople.indexOf(person));      //0

var strs = ["a", "b", "c"];

alert(strs.indexOf("a"));               //0
alert(strs.indexOf(new String("a")));   //-1

迭代方法：

ECMAScript为数组定义了5个迭代方法。每个方法都接收两个参数：在每一项上运行的函数和（可选的）运行该函数的作用域对象--影响this的值。传入这些方法中的函数会接收三个参数：参数项的值，该项在数组中的位置和数组对象本身，三个参数都是可选参数。根据使用方法的不同，这个函数之后的返回值可能会也可能不会影响访问的返回值。以下是这5个迭代方法的作用：

every(): 对数组中的每一项运行给定函数，如果该函数对每一项都返回true, 则返回true。

filter(): 对数组中的每一项运行给定函数，返回该函数会返回true的项组成的数组。

forEach(): 对数组中每一项运行给定函数。这个方法没有返回值。

map(): 对数组中的每一项运行给定的函数，返回每次这个函数调用的结果组成的数组。

some(): 对数组中的每一项运行给定的函数，如果该函数对任一项返回true, 则返回true。

以上方法都不会修改数组中的包含的值。

every() 方法的调用及执行结果如下：

var numbers = [1, 2, 3, 4, 5];

var bol = numbers.every(function(ele, index, arr) {
    return ele > 3;
});

alert(bol);                 //false

bol = numbers.every(function(ele) {
    return ele > 0;
});

alert(bol);                 //true

bol = numbers.every(function() {
    return true;
});

alert(bol);                 //true

filter() 方法的调用及执行结果如下：

var numbers = [1, 2, 3, 4, 5];

var nums = numbers.filter(function(ele, index, arr) {
    return ele > 3;
});

alert(nums);                 //4,5

nums = numbers.filter(function(ele) {
    return ele > 0;
});

alert(nums);                 //1,2,3,4,5

nums = numbers.filter(function() {
    return true;
});

alert(nums);                 //1,2,3,4,5

forEach() 方法的调用及执行结果如下：

var numbers = [1, 2, 3, 4, 5];

 var v = numbers.forEach(function(ele, index, arr) {
    alert("ele : " + ele + "    index : " + index + "   arr : " + arr);
});

alert(v);               //undefined

nums = numbers.forEach(function(ele) {
    alert("ele : " + ele);
});


nums = numbers.forEach(function() {
    alert("ele :  1");
});

map() 方法的调用及执行结果如下：

var numbers = [1, 2, 3, 4, 5];

 var v = numbers.map(function(ele, index, arr) {
    return ele + index;
});

alert(v);               //1,3,5,7,9

v = numbers.map(function(ele) {
    return ele * 2;
});

alert(v);               //2,4,6,8,10

v = numbers.map(function() {
    return 9;
});

alert(v);               //9,9,9,9,9

some() 方法的调用及执行结果如下：

var numbers = [1, 2, 3, 4, 5];

var bol = numbers.some(function(ele, index, arr) {
    return ele > 3;
});

alert(bol);                 //true

bol = numbers.some(function(ele) {
    return ele > 0;
});

alert(bol);                 //true

bol = numbers.some(function() {
    return true;
});

alert(bol);                 //true

缩小方法：

ECMAScript还新增了两个缩小数组的方法： reduce() 和 reduceRight()。这两个方法都会迭代数组的所有项，然后构建一个最终的返回值。其中， reduce() 方法从数组的第一项开始，逐个遍历到最后。而reduceRight()则从数组的最后一项开始，向前遍历到第一项。

这两个方法都接收两个参数：一个在每一项上调用的函数和作为缩小基础的初始值。传给reduce() 和 reduceRight() 的函数接收4个函数：前一个值，当前值，项的索引和数组对象。这个函数返回的任何值都会作为第一个参数自动传递给下一项。第一次迭代发生在数组的第二项上，因此第一个参数是数组的第一项，第二个参数是数组的第二项。

使用reduce()方法可以执行数组中所有值之和的操作，如下：

var values = [1, 2, 3, 4, 5];

var sum = values.reduce(function(prev, cur, index, array) {    
    console.log("prev : " + prev + "  cur : " + cur + "   array[" + index + "] : " + array[index]);
    return prev + cur;
});

alert(sum);         //15  (1 + 2 + 3 + 4 + 5)

console.log()方法的输出：

// prev : 1  cur : 2   array[1] : 2
// prev : 3  cur : 3   array[2] : 3
// prev : 6  cur : 4   array[3] : 4
// prev : 10  cur : 5   array[4] : 5

第一次执行的时候prev的值为1， cur是2，第二次， prev是3（1 + 2 的结果）， cur是3 (数组的第三项)。这个过程会持续到把数组中的每一项都访问一遍，最后返回结果。

var values = [1, 2, 3, 4, 5];

var sum = values.reduce(function(prev, cur, index, array) {
    console.log("prev : " + prev + "  cur : " + cur + "   array[" + index + "] : " + array[index]);
    return prev + cur;
}, 20);

alert(sum);         //35  (20 + 1 + 2 + 3 + 4 + 5)

console.log()方法的输出：

//prev : 20  cur : 1   array[0] : 1
//prev : 21  cur : 2   array[1] : 2
//prev : 23  cur : 3   array[2] : 3
//prev : 26  cur : 4   array[3] : 4
//prev : 30  cur : 5   array[4] : 5

第一次执行的时候prev的值为20， cur是1，第二次， prev是21（1 + 2 的结果）， cur是2(数组的第二项)。

使用reduceRight()方法可以执行数组中所有值之和的操作，如下：

var values = [1, 2, 3, 4, 5];

var sum = values.reduceRight(function(prev, cur, index, array) {
    console.log("prev : " + prev + "  cur : " + cur + "   array[" + index + "] : " + array[index]);
    return prev + cur;
});

alert(sum);         //15  (5 + 4 + 3 + 2 + 1)

console.log()方法的输出：

//prev : 5  cur : 4   array[3] : 4
//prev : 9  cur : 3   array[2] : 3
//prev : 12  cur : 2   array[1] : 2
//prev : 14  cur : 1   array[0] : 1

第一次执行的时候prev的值为5， cur是4，第二次， prev是9（1 + 2 的结果）， cur是3(从右往左数组的第三项)。

var values = [1, 2, 3, 4, 5];

var sum = values.reduceRight(function(prev, cur, index, array) {
    console.log("prev : " + prev + "  cur : " + cur + "   array[" + index + "] : " + array[index]);
    return prev + cur;
}, 20);

alert(sum);         //35  (20 + 5 + 4 + 3 + 2 + 1)

console.log()方法的输出：

//prev : 20  cur : 5   array[4] : 5
//prev : 25  cur : 4   array[3] : 4
//prev : 29  cur : 3   array[2] : 3
//prev : 32  cur : 2   array[1] : 2
//prev : 34  cur : 1   array[0] : 1

第一次执行的时候prev的值为20， cur是5，第二次， prev是25（1 + 2 的结果）， cur是4(从右往左数组的第二项)。

备注：摘取自《JAVASCRIPT高级程序设计：第3版》