Array对象常用的方法_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);
1
2
3
4
5
6
7
8
9
10
11
12
13

输出结果：

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
1
2
3
4
5
6

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
1
2
3
4
5
6
7
8
9
10
11

3、slice()

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

输入值：

返回值：返回一个新的数组，包含从 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]'
1
2
3
4
5
6
7
8
9
10
11
12

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
2
3
4
5
6
7
8

改变原数组

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
1
2
3
4
5
6
7
8
9
10

2、push()

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

输入值：

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

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

栗子：

// 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
1
2
3
4
5
6
7
8
9
10

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
1
2
3
4
5
6
7
8
9
10

4、unshift()

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

输入值：

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

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

栗子：

// 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
1
2
3
4
5
6
7
8
9
10
11

5、splice()

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

输入值：

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

返回值：

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

栗子：

// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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
1
2
3
4
5
6
7
8
9
10

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 ]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42