JavaScript —— 数组

Array方法

1、查找元素

　　indexOf()用来查找传进来的参数在目标数组中是否存在。如果目标数组包含该参数，就返回该元素在数组中的索引；如果不包含，就返回-1。

　　如果数组中包含多个相同的元素，indexOf()函数总是返回第一个与参数相同的元素的所有。有另外一个功能与之相似的函数：lastIndexOf()，该函数返回相同元素中最后一个元素的索引，如果没找到相同元素，则返回-1。

1.    var names = ["David", "Cynthia", "Raymond", "Clayton", "Jennifer"];  
2.      
3.    var pos = names.indexOf("Raymond");  
4.    if (pos >= 0) {  
5.        console.log("Found Raymond at position " + pos);  
6.    } else {  
7.        console.log("Raymond not found in array.");  
8.    }  
9.    
10.    // >>> 输出 Found Raymond at position 2  

2、数组的字符串表示

　　有两个方法可以将数组转化为字符串：join()和toString()。这两个方法都返回一个包含数组所有元素的字符串，各元素之间用逗号分隔开。

1.    var names = ["David", "Cynthia", "Raymond", "Clayton", "Jennifer"];  
2.      
3.    var namestr = names.join();  
4.    console.log(namestr);   // David,Cynthia,Raymond,Clayton,Jennifer   
5.      
6.    namestr = names.toString();  
7.    console.log(namestr);   // David,Cynthia,Raymond,Clayton,Jennifer 

3、由已有数组创建新数组

　　concat()和splice()方法允许通过已有数组创建新数组。Concat方法可以合并多个数组创建一个新数组，splice()方法截取一个数组的子集创建一个新数组。

　　concat()方法的工作原理：该方法的发起者是一个数组，参数是另一个数组。作为参数的素组，其中的所有元素都被连接到调用concat()方法的数组后面。

1.    var cisDept = ["Mike", "Clayton", "Terrill", "Danny", "Jennifer"];  
2.    var dmpDept = ["Raymond", "Cynthia", "Bryan"];  
3.      
4.    var itDiv = cis.concat(dmpDept);  
5.    console.log(itDiv);     // ["Mike", "Clayton", "Terrill", "Danny", "Jennifer", "Raymond", "Cynthia", "Bryan"]  
6.      
7.    itDiv = dmpDept.concat(cisDept);  
8.    console.log(itDiv);     // ["Raymond", "Cynthia", "Bryan", "Mike", "Clayton", "Terrill", "Danny", "Jennifer"]  

　　splice()方法从现有数组里截取一个新数组。该方法的第一个参数是截取的起始索引，第二个参数是截取的长度。

1.    var itDiv = ["Mike", "Clayton", "Terrill", "Raymond", "Cynthia", "Danny", "Jennifer"];  
2.    var dmpDept = itDiv.splice(3, 3);  
3.      
4.    console.log(dmpDept); // ["Raymond", "Cynthia", "Danny"]  
5.    console.log(cisDept); // ["Mike", "Clayton", "Terrill", "Jennifer"]  

4、为数组添加元素

　　有两个方法可以为数组添加元素：push() 和unshift()。push()方法会将一个元素添加到数组末尾。

1.    var nums = [1, 2, 3, 4, 5];  
2.    console.log(nums);      // 1, 2, 3, 4, 5  
3.      
4.    nums.push(6);  
5.    console.log(nums);      // 1, 2, 3, 4, 5, 6 

　　和在数组的末尾添加元素比起来，在数组的开头添加元素更难。如果不利用数组提供的可变函数，则新的元素添加进来后，需要把后面的每个元素都相应地向后移一个位置。unshift()方法可以将元素添加在数组的开头。

1.    var nums = [2, 3, 4, 5];  
2.    console.log(nums);      // 2, 3, 4, 5  
3.      
4.    nums.unshift(1);  
5.    console.log(nums);      // 1, 2, 3, 4, 5  

5、从数组中删除元素

　　使用pop()方法可以删除数组末尾的元素。使用shift() 方法可以删除数组的第一个元素。

1.    var nums = [1, 2, 3, 4, 5];  
2.    console.log(nums);      // 1, 2, 3, 4, 5  
3.      
4.    nums.pop();  
5.    console.log(nums);      // 1, 2, 3, 4  
6.      
7.    nums.shift();  
8.    console.log(nums);      // 2, 3, 4  

6、从数组中间位置添加和删除元素

　　删除数组中的第一个元素和在数组开头添加一个元素存在同样的问题——两种操作都需要将数组中的剩余元素向前或向后移，然而splice()方法可以帮助我们执行其中任何一种操作。使用splice() 方法为数组添加元素，需提供如下参数：

• · 起始索引（也就是你希望开始添加元素的地方）；
• · 需要删除的元素个数（添加元素时该参数设为0）；
• · 想要添加进数组的元素。

9.    var nums = [1, 2, 3, 7, 8, 9];  
10.    var newElements= [4, 5, 6];  
11.      
12.    nums.splice(3, 0, newElements);  
13.    console.log(nums);  // 1, 2, 3, 4, 5, 6, 7, 8, 9  
14.      
15.    // 要插入数组的元素不必组织成一个数组，它可以是任意的元素序列  
16.    var nums1 = [1, 2, 3, 7, 8, 9];  
17.    nums1.splice(3, 0, 4, 5, 6);  
18.    console.log(nums);  // 1, 2, 3, 4, 5, 6, 7, 8, 9  
19.      
20.    // 使用splice()方法从数组中删除元素  
21.    var nums2 = [1, 2, 3, 100, 200, 300, 400, 4, 5];  
22.    nums2.splice(3, 4);  
23.    console.log(nums2);     // 1, 2, 3, 4, 5  

7、为数组排序

　　reverse() 方法将数组中元素的顺序进行翻转。sort()方法时按照字典顺序对元素进行排序的，因此它嘉定元素都是字符串类型，即使元素时数字类型，也被认为是字符串类型。为了让sort()方法也能排序数字类型的元素，可以在调用方法时传入一个大小比较函数，排序时，sort()方法将会根据该函数比较数组中两个元素的大小，从而决定整个数组的顺序。

1.    // reverse()方法  
2.    var nums = [1, 2, 3, 4, 5];  
3.    nums.reverse();  
4.      
5.    console.log(nums);  // 5, 4, 3, 2, 1  
6.      
7.    // sort()方法  
8.    var names = ["David", "Mike", "Cynthia", "Clayton", "Bryan", "Raymond"];  
9.    names.sort();  
10.    console.log(names);     // Bryan, Clayton, Cynthia, David, Mike, Raymond   
11.      
12.    var nums1 = [3, 1, 2, 100, 4, 200];  
13.    nums1.sort();  
14.    console.log(nums1);     // 1, 100, 2, 200, 3, 4  
15.      
16.    nums1.sort(function(num1, num2) {  
17.        return num1 - num2;  
18.    });  
19.      
20.    console.log(nums1);     // 1, 2, 3, 4, 100, 200  

8、迭代器方法（不产生任何新数组）

　　迭代器方法对数组中的每一个元素应用一个函数，可以返回一个值、一组值或者一个新数组。

1.    function square(num) {  
2.        console.log(num + '-' + num * num);  
3.    }  
4.      
5.    var nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];  
6.    nums.forEach(square);  

　　另一个迭代器方法是every()，该方法接收一个返回值为布尔类型的函数，对数组中的每个元素使用该函数。如果对于所有的元素，该函数均返回true，则该方法返回true。

1.    function isEven(num) {  
2.        return num % 2 == 0;  
3.    }  
4.      
5.    var nums = [2, 4, 6, 8, 10];  
6.    var even = nums.every(isEven);  
7.      
8.    if (even) {  
9.        console.log("all numbers are even.");  
10.    } else {  
11.        console.log("not all numbers are even.");  
12.    }  
13.      
14.    // >>> 输出 all numbers are even.  

　　some()方法也接受一个返回值为布尔类型的函数，只要有一个元素使得该函数返回true，该方法就返回true。

1.    function isEven(num) {  
2.        return num % 2 == 0;  
3.    }  
4.      
5.    var nums = [1, 3,  5, 9];  
6.    var even = nums.some(isEven);  
7.      
8.    if (even) {  
9.        console.log("all numbers are even.");  
10.    } else {  
11.        console.log("no numbers are even.");  
12.    }  
13.      
14.    // >>> 输出 no numbers are even.  

　　reduce()方法接收一个函数，返回一个值。该方法会从一个累加值开始，不断对累加值和数组中的后续元素调用该函数，直到数组中的最后一个元素，最后返回得到的累加值。

1.    function add(runningTotal, currentValue) {  
2.        return runningTotal + currentValue;  
3.    }  
4.      
5.    var nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];  
6.    var sum = nums.reduce(add);  
7.    console.log(sum);   // 55  

9、迭代器方法（生成新数组）

　　有两个迭代器方法可以产生新数组：map()和filter()。map()和forEach()有点儿像，对数组中的每个元素使用某个函数。两者的区别是map()返回一个新的数组，该数组的元素是对原有元素应用某个函数得到的结果。

1.    var grades = [77, 65, 81, 92, 83];  
2.    var newGrades = grades.map(function(grade) {  
3.        return grade += 5;  
4.    });  
5.      
6.    console.log(newGrades);     // [82, 70, 86, 97, 88]  

　　filter()和every()类似，传入一个返回值为布尔类型的函数。和every()方法不同的是，当对数组中的所有元素应用该函数，结果均为true时，该方法并不返回true，而是返回一个新数组，该数组包含应用该函数后结果为true的元素。

1.    function isEven(num) {  
2.        return num % 2 == 0;  
3.    }  
4.      
5.    function isOdd(num) {  
6.        return num % 2 != 0;  
7.    }  
8.      
9.    var nums = [];  
10.    for (var i = 0; i < 20; i++) {  
11.        nums[i] = i + 1;  
12.    }  
13.      
14.    var evens = nums.filter(isEven);  
15.    console.log("even numbers:");  
16.    console.log(evens);             // [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]  
17.      
18.    var odds = nums.filter(isOdd);  
19.    console.log("odd numbers:");  
20.    console.log(odds);              // [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]