js数组的方法

数组的基础方法

1、toString()

toString() :把数组转换为（逗号分隔）的字符串。

		var fruits = ["Banana", "Orange", "Apple", "Mango"];
        console.log(fruits.toString());
        //Banana,Orange,Apple,Mango

2、jion()

join() :将数组元素结合为一个字符串。( 按照( )内指定的符号来连接，不写按照逗号连接 )

		var fruits = ["Banana", "Orange", "Apple", "Mango"];
        console.log(fruits.join(""));
        //BananaOrangeAppleMango

		var fruits = ["Banana", "Orange", "Apple", "Mango"];
        console.log(fruits.join("-"));
        //Banana-Orange-Apple-Mango

3、pop( ) 和 push( )

pop()

从数组中删除最后一个元素( 返回被删除的元素 )

		let fruits = ["Banana", "Orange", "Apple", "Mango"];
        let pop=fruits.pop()
        console.log(pop);//Mango
        console.log(fruits);//["Banana", "Orange", "Apple"]

push()

（在数组结尾处）向数组添加一个新的元素（返回新数组的长度。）

		let fruits = ["Banana", "Orange", "Apple", "Mango"];
        fruits.push("aaa")
        console.log(fruits);//["Banana", "Orange", "Apple","aaa"]

4、shift()和unshift()

shift()

删除首个数组元素，并把所有其他元素“位移”到更低的索引，返回被“位移出”的字符串

		let fruits = ["Banana", "Orange", "Apple", "Mango"];
        let shift=fruits.shift()
        console.log(shift);//Banana
        console.log(fruits);//["Orange", "Apple", "Mango"]

unshift()

（在开头）向数组添加新元素，并“反向位移”旧元素，返回新数组的长度。

		let fruits = ["Banana", "Orange", "Apple", "Mango"];
        let unshift=fruits.unshift("aaa")
        console.log(unshift);//5
        console.log(fruits);//["aaa","Orange", "Apple", "Mango"]

5、splice()

参数顺序：起始位置、 要删除的项数（0表示不删除）、要在删除位置插入的项。

splice()方法始终会返回一个数组，该数组中包含从原始数组中删除的项，如果没有删除任何项，则返回一个空数组。

		var fruits = ["Banana", "Orange", "Apple", "Mango"];
		fruits.splice(0, 1);        // 删除 fruits 中的第一个元素

		let fruits = ["a", "b", "c", "d"];
        let newfruits=fruits.splice(2, 2, "x", "y");
        console.log(newfruits);//["c", "d"]
        console.log(fruits);//["a", "b", "x", "y"]

6、concat()

通过合并（连接）现有数组来创建一个新数组

concat() 方法不会更改现有数组。它总是返回一个新数组

		let arr1=[1,1,1]
        let arr2=[2,2,2]
        let arr3=[3,3,3]
        let newarr=arr1.concat(arr2,arr3)
        console.log(arr1);//([1, 1, 1]
        console.log(newarr);//[1, 1, 1, 2, 2, 2, 3, 3, 3]

7、slice()

用数组的某个片段切出新数组,该方法会从开始参数选取元素，直到结束参数（不包括）为止

如果不写第二个参数，就是从开始位置，切到数组结尾。

//切除数组[1,3)的数组，不影响原数组
		var fruits = ["a", "b", "c", "d", "e"];
        var citrus = fruits.slice(1,3); 
        console.log(citrus);//["b", "c"]
        console.log(fruits);//["a", "b", "c", "d", "e"]

8、sort()

（1）字母排序

		let arr=['a','c','d','e','g']
        console.log(arr.sort());//["a", "c", "d", "e", "g"]

（2）数字排序

如果数字按照字符串来排序，则 “25” 大于 “100”，因为 “2” 大于 “1”。

正因如此，sort() 方法在对数值排序时会产生不正确的结果。

通过一个比值函数来修正此问题

a.升序排列：

 		var arr = [40, 100, 1, 5, 25, 10];
        let newarr=arr.sort(function (a, b) {
            return a - b
        });
        console.log(newarr);//[1, 5, 10, 25, 40, 100]

b.降序排序：

		var arr = [40, 100, 1, 5, 25, 10];
        let newarr=arr.sort(function (a, b) {
            return b - a
        });
        console.log(newarr);//[100, 40, 25, 10, 5, 1]

c.随机顺序排序数组

		var arr = [40, 100, 1, 5, 25, 10];
        let newarr=arr.sort(function (a, b) {
            return 0.5 - Math.random()
        });
        console.log(newarr);//[1, 25, 10, 100, 40, 5]

d.排序对象数组

		var cars = [
            { type: "Volvo", year: 2016 },
            { type: "Saab", year: 2001 },
            { type: "BMW", year: 2010 }];
        var arr = cars.sort(function (a, b) {
            return a.year - b.year
        });
        console.log(arr);
        // [ {type: "Saab", year: 2001},{type: "BMW", year: 2010},
              {type: "Volvo", year: 2016}]

9、reverse()

反转数组中的元素

		let arr=[1,2,3,4,5]
        console.log(arr.reverse());//[5, 4, 3, 2, 1]

数组的迭代方法

1、Array.forEach()

该函数接受 3 个参数：项目值、项目索引、数组本身

2、Array.map()

通过对每个数组元素执行map()小括号中的函数，该函数return新值，因此创建了新数组。

（该 方法返回一个新数组，新数组中的元素为 原始数组元素 调用函数 处理后的值（return 的值））

该方法不会更改原始数组。

var numbers1 = [45, 4, 9, 16, 25];
var numbers2 = numbers1.map(myFunction);

function myFunction(value, index, array) {
  return value * 2;
}

3、Array.filter()

创建一个通过测试的数组元素的新数组

（filter()方法会创建一个新数组，原数组的每个元素传入回调函数中，回调函数中有return返回值，
若返回值为true，这个元素保存到新数组中；若返回值为false，则该元素不保存到新数组中；）

var numbers = [45, 4, 9, 16, 25];
var over18 = numbers.filter(myFunction);

function myFunction(value, index, array) {
  return value > 18;
}

4、Array.reduce()

4 个参数：总数、项目值、项目索引、数组本身

reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。

//确定数组中所有数字的总和
var arr = [1, 2, 3, 4, 5];
        var sum = arr.reduce(fn);
        function fn(total, value) {
            return total + value;
        }
        console.log(sum);//15

该方法可以接受一个起始值

 		var arr = [1, 2, 3, 4, 5];
        var sum = arr.reduce(fn,10);
        function fn(total, value) {
            return total + value;
        }
        console.log(sum);//25

5、Array.every()

检查所有数组值是否通过测试

三个参数：项目值、项目索引、数组本身

		var arr = [45, 4, 9, 16, 25];
        var allOver18 = arr.every(fn);
        function fn(value) {
            return value > 18;
        }
        console.log(allOver18);//false

6、Array.some()

检查某些数组值是否通过了测试

		var arr = [45, 4, 9, 16, 25];
        var allOver18 = arr.some(fn);
        function fn(value) {
            return value > 18;
        }
        console.log(allOver18);//true

7、Array.indexOf()和 Array.lastIndexOf()

在数组中搜索元素值并返回其位置

		var fruits = ["Apple", "Orange", "Apple", "Mango"];
        var a = fruits.indexOf("Orange");
        console.log(a);//1

Array.lastIndexOf() 与 Array.indexOf() 类似，但是从数组结尾开始搜索。

8、Array.find()

返回通过测试函数的第一个数组元素的值

		var numbers = [4, 9, 16, 25, 29];
        var first = numbers.find(fn);

        function fn(value) {
            return value > 18;
        }
        console.log(first);//25

9、Array.findIndex()

返回通过测试函数的第一个数组元素的索引

		var numbers = [4, 9, 16, 25, 29];
        var first = numbers.findIndex(fn);

        function fn(value) {
            return value > 18;
        }
        console.log(first);//3