Array对象常用的方法

￡神魔★判官ぃ 2022-05-29 06:47 130阅读 0赞

**Array对象常用的方法**

不改变原数组的方法

1、concat()

语法：arrayObject.concat(arrayX,arrayX,......,arrayX)

输入值： 输入值可以是单个元素（多个元素），也可以是单个数组（多个数组）

功能：连接两个或多个数组

返回值：返回被连接数组的一个副本

栗子：

// arrayObject.concat(arrayX,arrayX,......,arrayX)
    var arr = [1,2,3];
    var arr2 = arr.concat(4,5,6);
    console.log("arr: " + arr);
    console.log("arr2: " + arr2);
    
    var arr3 = arr.concat([7,8]);
    console.log("arr: " + arr);
    console.log("arr3: " + arr3);
    
    var arr4 = arr.concat([9,10],[11,12]);
    console.log("arr: " + arr);
    console.log("arr4: " + arr4);

输出结果：

arr: 1,2,3
    arr2: 1,2,3,4,5,6
    arr: 1,2,3
    arr3: 1,2,3,7,8
    arr: 1,2,3
    arr4: 1,2,3,9,10,11,12

2、join()

语法：arrayObject.join(separator)

输入值：分隔符

功能：把数组中的所有元素放入一个字符串中

返回值：返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串，然后把这些字符串连接起来，在两个元素之间插入 separator 字符串而生成的。

栗子：

// arrayObject.join(separator)
    var arr = new Array(3);
    arr[0] = "A";
    arr[1] = "B";
    arr[2] = "C";
    console.log('arr.join(): ' + arr.join());
    console.log('arr.join(-): ' + arr.join('-'));

输出结果：

arr.join(): A,B,C
    arr.join(-): A-B-C

3、slice()

语法：arrayObject.slice(start,end)---包括start但不包括end，没有找到元素，则返回空的数组

输入值：

![Image 1][]

返回值：返回一个新的数组，包含从 start 到 end （不包括该元素）的 arrayObject 中的元素

栗子：

// arrayObject.slice(start,end)
    var arr = [1,2,3,4,5];
    console.log('arr.slice(0): ' + arr.slice(0));  //arr.slice(0): 1,2,3,4,5
    console.log('arr.slice(0,5): ' + arr.slice(0,5));//超出数组最大的index值，则忽略超出部分arr.slice(0,5): 1,2,3,4,5
    console.log('arr.slice(0,1): ' + arr.slice(0,1)); //arr.slice(0,1): 1
    console.log('arr.slice(0,-1): ' + arr.slice(0,-1));//arr.slice(0,-1): 1,2,3,4
    console.log('arr.slice(-3,-1): ' + arr.slice(-3,-1));//arr.slice(-3,-1): 3,4
    console.log('arr.slice(-2,-3): ' + {}.toString.call(arr.slice(-2,-3)));//第一个下标要大于第二个下标，否则返回的是空的数组
    console.log('arr.slice(-1,-3): ' + arr.slice(-1,-3));  //slice()的第一个参数要小于第二个参数
    var arr = [1,2,3,4,5];
    let tmp =arr.slice(5);
    console.log({}.toString.call(tmp)); //没有找到元素，返回的是空的数组'[object Array]'

4、toString()

语法：booleanObject.toString()

输入值：无

功能：把一个逻辑值转换为字符串，并返回结果

返回值：根据原始布尔值或者booleanObject对象的值返回字符串"true"或“false”

栗子：

// booleanObject.toString()
    var boo = new Boolean(true)
    console.log(boo.toString());
    var arr = new Array();
    console.log(arr.toString());  //console显示的是空的

输出结果：

true

改变原数组

1、pop()

语法：arrayObject.pop()

输入值：无

功能：用于删除并返回数组的最后一个元素

返回值：被删除的元素；如果是空数组则不改变数组，返回undefined

栗子：

// arrayObject.pop()
    var arr = [1,2,3];
    console.log('arr: '+ arr);
    console.log('the pop element: '+ arr.pop());
    console.log('arr: '+ arr);

输出结果：

arr: 1,2,3
    the pop element: 3
    arr: 1,2

2、push()

语法：arrayObject.push(newelement1,newelement2,....,newelementX)

输入值：

![Image 1][]

功能：想数组的末尾添加一个或多个元素

返回值：把指定的值添加到数组之后的新长度

栗子：

// arrayObject.push(newelement1,newelement2,....,newelementX)
    var arr = [1,2,3];
    console.log('arr: '+ arr);
    console.log('the new length: '+ arr.push(4,5));
    console.log('arr: '+ arr);

输出结果：

arr: 1,2,3
    the new length: 5
    arr: 1,2,3,4,5

3、shift()

语法：arrayObject.shift()

输入值：无

功能：把数组的第一个元素从其中删除

返回值：数组原来的第一个元素的值

栗子：

// arrayObject.shift()
    var arr = [1,2,3];
    console.log('arr: '+ arr);
    console.log('the shift element: '+ arr.shift());
    console.log('arr: '+ arr);

输出结果：

arr: 1,2,3
    the shift element: 1
    arr: 2,3

4、unshift()

语法：arrayObject.unshift(newelement1,newelement2,....,newelementX)

输入值：

![Image 1][]

功能：向数组的开头添加一个或多个元素

返回值：返回数组的新长度

栗子：

// arrayObject.unshift(newelement1,newelement2,....,newelementX)
    var arr = [1,2,3];
    console.log('arr: '+ arr);
    console.log('the new length: '+ arr.unshift(14,5));
    console.log('arr: '+ arr);

输出结果：

arr: 1,2,3  
the new length: 5

arr: 14,5,1,2,3

5、splice()

语法：arrayObject.splice(index,howmany,item1,.....,itemX)

输入值：

![Image 1][]

功能：向数组添加项目或者从数组中删除项目

返回值：

![Image 1][]

向/从数组中添加/删除项目，然后返回被删除的项目

栗子：

// arrayObject.splice(index,howmany,item1,.....,itemX)
    var arr = [1,2,3];
    console.log('arr: '+ arr);
    console.log('delete element: '+ arr.splice(0,1));
    console.log('arr: '+ arr);
    console.log('do not delete element: '+ arr.splice(0,0,6));
    console.log('arr: '+ arr);

输出结果：

arr: 1,2,3
    delete element: 1
    arr: 2,3
    do not delete element: 
    arr: 6,2,3

6、reverse()

语法： arrayObject.reverse()

输入值：无

功能：用于颠倒数组中的元素的顺序

返回值：返回颠倒顺序之后的数组

栗子：

// arrayObject.reverse()
    var arr = [1,2,3];
    console.log('arr: ' + arr);
    console.log('reverse arr: ' + arr.reverse());
    console.log('arr: '+ arr);

输出结果：

arr: 1,2,3
    reverse arr: 3,2,1
    arr: 3,2,1

7、sort()

语法：arr.sort()   或者  arr.sort(compareFunction)

输入值；无  或者  函数（用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序）

功能：排序

返回值：排序之后的数组

栗子：

// arr.sort() 
    // arr.sort(compareFunction)
    var numbers = [4, 2, 5, 1, 3];
    numbers.sort(function(a, b) {
      return a - b;
    });
    console.log(numbers);

输出结果：

[ 1, 2, 3, 4, 5 ]

栗子2：

// arr.sort() 
    // arr.sort(compareFunction)
    var numbers = [4, 2, 5, 10, 3];
    numbers.sort();
    console.log(numbers);

输出结果：

[ 10, 2, 3, 4, 5 ]

在Array的prototype对象上有12个方法

Array.prototype.indexOf
     Array.prototype.lastIndexOf
     Array.prototype.every
     Array.prototype.some
     Array.prototype.forEach
     Array.prototype.map
     Array.prototype.filter
     Array.prototype.reduce
     Array.prototype.reduceRight
     Array.prototype.includes
     Array.prototype.find
     Array.prototype.findIndex

1）Array.prototype.indexOf：**stringObject.indexOf(searchvalue,fromindex)-**\-searchvalue要检索的值，fromindex开始检索的位置，从前向后检索，返回首次出现的位置，找不到返回-1

2）Array.prototype.lastIndexOf：**stringObject.lastIndexOf(searchvalue,fromindex)-**\-searchvalue要检索的值，fromindex开始检索的位置，**从后向前检索**，**返回最后出现的位置，**找不到返回-1

3）Array.prototype.map：**arr.map(function(currentValue,index,arr), thisValue)-**\-thisValue作为this的值，如果忽略则为undefined，**返回一个经过callback处理数组的每一个元素之后的结果组成的新数组**，不改变原数组

4）Array.prototype.reduce：**arr.reduce(function(total, currentValue, currentIndex, arr), initialValue)**\--total作为callback的返回值，initialValue是total的初始值，返回一个经过callback处理之后的结果数组，不改变原数组，对于空数组是不会执行回调函数的

5）Array.prototype.reduceRight：**arr.reduce(function(total, currentValue, currentIndex, arr), initialValue)**，同reduce一样，只不过是从数组末尾向前遍历，不改变原数组，对于空数组是不会执行回调函数的

6）Array.prototype.every：**arr.every(function(currentValue,index,arr), thisValue)**，检测数组所有元素是否都符合指定条件

如果数组中检测到**有一个元素不满足**，则整个表达式返回 false ，**且剩余的元素不会再进行检测**，否则为true

7）Array.prototype.forEach()：**array.forEach(function(currentValue, index, arr), thisValue)**，调用数组的每个元素，并将元素传递给回调函数，对于空数组是不会执行回调函数的，**没有返回值**

8）Array.prototype.some()：**arr.some(function(currentValue,index,arr),thisValue)**，依次执行数组的每个元素，如果**有一个元素满足条件**，则表达式**返回true** , **剩余的元素不会再执行检测**创建一个新的数组，不会对空数组进行检测，不会改变原始数组

9）Array.prototype.filter()：**arr.filter(function(currentValue,index,arr), thisValue)**，**创建一个新的数组**，新数组中的元素是通过检查指定数组中**符合条件的所有元素**，不会对空数组进行检测，不会改变原始数组

10）Array.prototype.find()：返回**通过测试**（函数内判断）的数组**的第一个元素的值**，之后的值不会再调用执行函数，如果没有符合条件的元素返回 undefined，对于空数组，函数是不会执行的,并没有改变数组的原始值  
11）Array.prototype.findIndex()：传入一个测试条件（函数）符合条件的数组第一个元素位置，当数组中的元素在测试条件时返回 true 时, findIndex() **返回符合条件的元素的索引位置**，之后的值不会再调用执行函数，**没有符合条件的元素返回 -1**，对于空数组，函数是不会执行的,并没有改变数组的原始值

**下面是在ES6中添加的**

12）Array.of()：将元素列表转为数组，避免new Array()带来的诡异行为（由传入参数的个数不同造成的问题）

// Array()只有一个参数的时候，参数的大小表示数组的长度
    // 有多于一个参数，则表示数组元素
    let arr1 = new Array(3);
    console.log( arr1 );   //[ <3 empty items> ]
    console.log( arr1.length ); //3
    
    let arr2 = new Array(3,2,1);  
    console.log( arr2 );   //[ 3, 2, 1 ]
    console.log( arr2.length ); //3
    
    // Array.of()函数里面只要有参数，都表示数组元素成员
    let arr3 = Array.of(1); 
    console.log( arr3 );  //[1]
    console.log( arr3.length );  //1
    
    let arr4 = Array.of(1,undefined);  
    console.log( arr4 );  //2
    console.log( arr4.length );  //[ 1, undefined ]

12）Array.from(iterator,fn,obj)：将具有Iterator接口的对象或类数组对象转成数组

其中iterator必须，表示要转换的对象，fn表示对对象的每个成员进行处理的映射函数，obj表示映射函数的this的值

// 例1，将函数中的arguments对象转换成数组对象
    Array.from(arguments);
    
    // 例2，对对象的每个成员进行处理
    function translate(){
    	return Array.from(arguments,val=>val+1);
    }
    console.log(translate(1,2,3)); // [2,3,4]
    
    // 例3，指定映射函数中的this的值
    let helper = {
    	diff:1,
    	add(val){
    		return val + this.diff;
    	}
    };
    function translate2(){
    	return Array.from(arguments,helper.add,helper);
    }
    console.log(translate2(3,4,5));//[ 4, 5, 6 ]

13）Array.keys()   Array,values()   Array.entries()

[Image 1]: