JS数组中常用的方法总结

Array.isArray() 用于确定传递的值是否是一个 Array

Array.isArray([1, 2, 3]);  
// true
Array.isArray({foo: 123}); 
// false
Array.isArray("foobar");   
// false
Array.isArray(undefined);  
// false

Array.of() 返回一个由参数组成的数组

let arr = Array.of(1, 2, 3)
console.log(arr)//[ 1, 2, 3 ]

Array.from() 将数组对象转换为数组 不改变原对象 返回新数组

let a = { 0: '1', 1: '2', 2: '3', 'length': 3 };//对象
let arr = Array.from(a)
console.log(arr)//[ '1', '2', '3' ]

let b = Array.from('hello')//字符串
console.log(b)//[ 'h', 'e', 'l', 'l', 'o' ]

let arrset = Array.from(new Set('func'))
console.log(arrset)//[ 'f', 'u', 'n', 'c' ]

let arrMap = Array.from(new Map().set([1, 2], [3, 4], [5, 6]))
console.log(arrMap)//[ [ [ 1, 2 ], [ 3, 4 ] ] ]
//类似map方法
let thearr = Array.from([1, 2, 3], x => x * 2)
console.log(thearr)//[ 2, 4, 6 ]

push(item1,item2,…)
作用：在数组的末尾添加一个或多个元素
返回值：添加数据后数组的长度
注意：改变原数组
代码示例：

//push(item1,item2,...)
 var array=[1,2,3,4,5];
 var returnArray=array.push(6,7,8);
 console.log(array); //[1,2,3,4,5,6,7,8]
 console.log(returnArray);//8

unshift(item1,item2,…)
作用：在数组的开头添加一个或多个元素
返回值：添加数据后数组的长度
注意：改变原数组
代码示例：

//unshift(item1,item2,...)
var array=[1,2,3,4,5];
var returnArray=array.unshift(6,7,8);
console.log(array); //[6,7,8,1,2,3,4,5]
console.log(returnArray);//8

pop()
作用：删除数组末尾的一个元素
返回值：被删除的元素
注意：改变原数组
代码示例：

//pop()
var array=[1,2,3,4,5];
var returnArray=array.pop();
console.log(array); //[1,2,3,4]
console.log(returnArray);//5

shift()
作用：删除数组开头的一个元素
返回值：被删除的元素
注意：改变原数组
代码示例：

 //shift()
var array=[1,2,3,4,5];
var returnArray=array.shift();
console.log(array); //[2,3,4,5]
console.log(returnArray);//1

reverse()
作用：倒置数组元素
返回值：倒置以后的数组
注意：改变原数组
代码示例：

//reverse()
var array=[1,2,3,4,5];
var returnArray=array.reverse();
console.log(array); //[5,4,3,2,1]
console.log(returnArray);//[5,4,3,2,1]

slice(startIndex,endIndex)
作用：从startIndex下标开始一直截取到endIndex下标之前，不包含endIndex下标元素
返回值：截取的数据数组
注意：不改变原数组
代码示例：

//slice(startIndex,endIndex)
var array=[1,2,3,4,5,6];
var returnArray=array.slice(1,4);
console.log(array); //[1,2,3,4,5,6]
console.log(returnArray);//[2,3,4]

splice(index,num,item1,item2,…)
作用：在数组的中间添加或者删除一下元素
返回值：含有被删除的元素数组
注意：改变原数组
代码示例：

//splice(index,num,item1,item2,...)
var array=[1,2,3,4,5,6];
var returnArray=array.splice(1,2,8,9);
console.log(array); //[1,8,9,4,5,6]
console.log(returnArray);//[2,3]

//从下标为i的位置删除0个元素，并添加两个元素
var returnArray=array.splice(1,0,10,11);
console.log(array); //[1,10,11,8,9,4,5,6]
console.log(returnArray);//[]

//如果下标大于原数组最大下标，则在数组最后添加元素
var returnArray=array.splice(10,2,8,9);
console.log(array); //[1,10,11,8,9,4,5,6,8,9]
console.log(returnArray);//[]

//如果省略可选参数，则删除对应元素个数
var returnArray=array.splice(1,2);
console.log(array); //[1,8,9,4,5,6,8,9]
console.log(returnArray);//[10,11]

concat()
作用：将多个数组拼接成一个数组
返回值：拼接之后的数组，拼接后的元素将按照传入参数的顺序排列
注意：不改变原数组
代码示例：

//concat() 不改变原数组
var array=[1,2,3];
var newArray=array.concat([4,5,6],'feifei',false);
console.log(array); //[1, 2, 3]
console.log(newArray);//[1, 2, 3, 4, 5, 6, "feifei", false]

toString()
作用：将数组的元素转换为字符串
返回值：转换的结果
注意：不改变原数组

//toString()
var array=[1,2,3,4,5];
var returnArray=array.toString();
console.log(array); //[ 1, 2, 3, 4, 5 ]
console.log(returnArray);//1,2,3,4,5

join(str)
作用：将数组的元素用参数字符串拼接成一个新的字符串
返回值：拼接的结果
注意：不改变原数组
代码示例：

//join(str)
var array=[1,2,3,4,5];
var returnArray=array.join("->");
console.log(array); //[ 1, 2, 3, 4, 5 ]
console.log(returnArray);//1->2->3->4->5

indexOf(item)
作用：从数组的左侧开始查找对应第一次出现的参数元素的下标
返回值：如果找到对应元素则返回下标值，否则返回-1
代码示例：

//indexOf(item)
var array=[1,2,3,4,5];
var returnArray=array.indexOf(3);
console.log(array); //[1, 2, 3, 4, 5]
console.log(returnArray);//2

lastIndexOf(item)
作用：从数组的右侧开始查找对应第一次出现的参数元素的下标
返回值：如果找到对应元素则返回下标值，否则返回-1
代码示例：

 //lastIndexOf(item)
 var array=[1,2,3,4,5];
 var returnArray=array.lastIndexOf(3);
 console.log(array); //[1, 2, 3, 4, 5]
 console.log(returnArray);//2

map()
作用：将数组中的每个元素调用一个提供的函数，结果作为一个新的数组返回，并没有改变原来的数组
返回值：执行完函数后的新数组
注意：不改变原数组

 //map()
 var array=[1,2,3,4,5];
 var returnArray=array.map(x => x*2);
 console.log(array); //[1, 2, 3, 4, 5]
 console.log(returnArray);//[ 2, 4, 6, 8, 10 ]

forEach()
作用：将数组中的每个元素执行传进提供的函数，没有返回值
返回值：没有返回值
注意：不改变原数组

 //forEach()
 var array=[1,2,3,4,5];
 var returnArray=array.forEach(x => x*2);
 console.log(array); //[1, 2, 3, 4, 5]
 console.log(returnArray);//undefined

filter()
作用：将所有元素进行判断，将满足条件的元素作为一个新的数组返回
返回值：满足条件的元素
注意：不改变原数组

 //filter()
 var array=[1,2,3,4,5];
 var returnArray=array.filter(item=>item>2);
 console.log(array); //[1, 2, 3, 4, 5]
 console.log(returnArray);//[ 3, 4, 5 ]

every()
作用：将所有元素进行判断返回一个布尔值，如果所有元素都满足判断条件，则返回true，否则为false
注意：不改变原数组

 //every()
 var array=[1,2,3,4,5];
 var returnArray=array.every(item=>item>2);
 console.log(array); //[1, 2, 3, 4, 5]
 console.log(returnArray);//false

some()
作用：将所有元素进行判断返回一个布尔值，如果存在元素都满足判断条件，则返回true，若所有元素都不满足判断条件，则返回false
注意：不改变原数组

 //some()
 var array=[1,2,3,4,5];
 var returnArray=array.some(item=>item>2);
 console.log(array); //[1, 2, 3, 4, 5]
 console.log(returnArray);//true

reduce()
作用：所有元素调用返回函数，返回值为最后结果,传入的值必须是函数类型
返回值：最后结果
注意：不改变原数组

 //reduce()
 var array=[1,2,3,4,5];
 var returnArray=array.reduce((a, b) => a + b);
 console.log(array); //[1, 2, 3, 4, 5]
 console.log(returnArray);//15

sort() 数组排序 (改变原数组) 参数为规定排序的比较函数(非必填)

{
  // 默认情况下，不传参数的话，默认按字母升序，若为非字符串,则先调用toString()将元素转化为字符串的 Unicode ,再进行字符串比较
  let arr = ["A", "C", "B", "E", "D"];
  arr.sort();
  console.log(arr); //["A","B","C","E","D"]
}
{   //数组的升序与降序排序
  let arr = [1, 0, 5, 4, 9, 45, 78, 6, 14, 2];
  arr.sort((a, b) => a - b)
  console.log(arr)//[0, 1, 2, 4, 5, 6, 9, 14, 45, 78]
}
{ //按年龄排序，若年龄相同，就女士(sex属性为0) 排在男士(sex属性为1)之前
  let arr = [{ age: 18, sex: 0 }, { age: 19, sex: 0 }, { age: 20, sex: 0 }, { age: 18, sex: 1 }, { age: 19, sex: 1 }];
  arr.sort((a, b) => {
      if (a.age === b.age) { //若年龄相同就按性别排，女士优先
          return a.sex - b.sex;
      } else { //年龄不相同就默认按年龄排升序
          return a.age - b.age;
      }
  })
  console.log(arr)
  // [ { age: 18, sex: 0 },
  //   { age: 18, sex: 1 },
  //   { age: 19, sex: 0 },
  //   { age: 19, sex: 1 },
  //   { age: 20, sex: 0 } ]
}

copyWithin() 数组的指定位置复制[改变原数组、ES6]
语法：arr.copyWithin(index, start, end)
第一个参数：复制到指定目标索引位置。
第二个参数：元素复制的起始位置 (可选)
第三个参数：停止复制的索引位置 (默认为 array.length)。如果为负值，表示倒数。(可选)

{
  let arr = [1, 2, 3, 4, 5, 6];
  let a = arr.copyWithin(2, 0, 3);
  console.log(arr)// [1, 2, 1, 2, 3, 6]
}

fill()数组的填充 [改变原数组、ES6]

{
        let arr = new Array(3)
        arr.fill('填充')
        console.log(arr)//["填充", "填充", "填充"]
        arr.fill('位置', 0, 1)
        console.log(arr)// ["位置", "填充", "填充"]
    }

find() / findIndex() 根据条件找到数组成员 [ES6]

{
        let arr= [1,2,3,4,5]
        let result = arr.find(item=>item>3)
        console.log(result)//4 第一个值
        let result1 = arr.findIndex(item=>item>3)
        console.log(result1)//3 第一个值的下标
    }

是否改变原数组
不会改变原来数组的有：
concat()—连接两个或更多的数组，并返回结果。
every()—检测数组元素的每个元素是否都符合条件。
some()—检测数组元素中是否有元素符合指定条件。
filter()—检测数组元素，并返回符合条件所有元素的数组。
indexOf()—搜索数组中的元素，并返回它所在的位置。
join()—把数组的所有元素放入一个字符串。
toString()—把数组转换为字符串，并返回结果。
lastIndexOf()—返回一个指定的字符串值最后出现的位置，在一个字符串中的指定位置从后向前搜索。
map()—通过指定函数处理数组的每个元素，并返回处理后的数组。
slice()—选取数组的的一部分，并返回一个新数组。
valueOf()—返回数组对象的原始值。

会改变原来数组的有：
pop()—删除数组的最后一个元素并返回删除的元素。
push()—向数组的末尾添加一个或更多元素，并返回新的长度。
shift()—删除并返回数组的第一个元素。
unshift()—向数组的开头添加一个或更多元素，并返回新的长度。
reverse()—反转数组的元素顺序。
sort()—对数组的元素进行排序。
splice()—用于插入、删除或替换数组的元素。

参考：JS数组中常用的方法总结
js数组常用方法