数组常用API整理

1.arr.valueOf() // 返回值为该对象的原始值

var arr=[1,2,3,4,56,6];

2.arr.toString() // 返回数组内容的字符串表示形式

  const arr = [1, 2, 3, 4, 56, 6];
  console.log(arr.toString()); //1,2,3,4,56,6

3.String(arr) // 将数组中每个元素转为字符串，并用逗号连接。

 const arr = [1, 2, 3, 4, 56, 6];
        console.log(String(arr)); //1,2,3,4,56,6

4.arr.join(“连接符”) // 将数组中每个元素转为字符串，用自定义的"连接符"连接每个元素,需要用变量借助

const arr = [1, 2, 3, 4, 56, 6];
  console.log(arr.join("")); //1234566
  console.log(arr.join(" ")); //1 2 3 4 56 6
 console.log(arr.join(",")); //1,2,3,4,56,6

5.arr.reverse() // 将数组中元素的位置颠倒,并返回该数组,注意：原数组会改变

const arr = [1, 2, 3, 4, 56, 6];
    console.log(arr.reverse()); // [6, 56, 4, 3, 2, 1]

6.arr.sort() // 数组排序，按字符串大小排序,会改变原数组

 const arr = [1, 2, 3, 4, 56, 6];
        console.log(arr.sort((a, b) => a - b)); // [1, 2, 3, 4, 6, 56]
         console.log(arr.sort((a, b) => b - a)); //[56, 6, 4, 3, 2, 1]

7.arr.concat(otherArr) // 合并新元素，返回一个新数组需要用变量接住，不会改变原数组

const arr = [1, 2, 3, 4, 56, 6];
        arr.concat([0, 12, 12]);
        console.log(arr.concat([0, 12, 12])); //[1, 2, 3, 4, 56, 6, 0, 12, 12]
        console.log(arr.concat(2)); //[1, 2, 3, 4, 56, 6, 2]

8.arr.slice(start,end) // 剪切数组，含头不含尾 ,返回新的数组，不会改变原数组

  const arr = [1, 2, 3, 4, 56, 6];
        //两个参数
        console.log(arr.slice(1, 3)); //[2, 3]
        //一个参数
        console.log(arr.slice(1)); //[2, 3, 4, 56, 6]
        console.log(arr.slice(2)); //[ 3, 4, 56, 6]

注意：拼接和截取: 都无法直接修改原数组而是返回新数组，用变量接住
arr.split([ 起始位置 | 要删除元素的个数 | 要插入元素的值，可以写入多个值 ] )剪切数组/替 换/新增
9.arr.indexOf(item) // 返回第一个匹配到的元素在数组中所在的位置 ，如果没有找到就是返回 -1

 const arr = [1, 2, 3, 4, 56, 6];
        console.log(arr.indexOf(6)); //5
        console.log(arr.indexOf(66)); //-1表示没有找到

10.arr.push() // 尾部添加元素，返回被新数组的长度,原数组会改变

const arr = [1, 2, 3, 4, 56, 6];
        console.log(arr.push(1)); //返回数组元素的个数
        console.log(arr); //[1, 2, 3, 4, 56, 6, 1]

11.arr.pop() // 尾部删除元素，返回被删除的元素,原数组会改变

const arr = [1, 2, 3, 4, 56, 6];
        console.log(arr.pop()); //返回被删除的元素，原数组被修改
        console.log(arr); //[1, 2, 3, 4, 56]

12.arr.unshift(item) // 头部添加元素，返回新数组的长度,原数组会改变

const arr = [1, 2, 3, 4, 56, 6];
        console.log(arr.unshift(1)); //在数组卡起头添加元素，返回数组元素的个数，会修改原数组的
        console.log(arr); //[1, 1, 2, 3, 4, 56, 6]

13.arr.shift(item) // 头部删除元素，返回被删除的元素,原数组会改变

const arr = [1, 2, 3, 4, 56, 6];
    console.log(arr.shift()); //返回被删除的元素，会修改原数组的
    console.log(arr); //[ 2, 3, 4, 56, 6

14.arr.every(function(item,index,array){}) // 该函数对每一项都返回true，则返回true,否则返回false

array.every(function(item,index,array）{
   //item:当前元素的值；

   //index:当前元素的索引；

  // array:当前元素的数组对象；
})

every()方法使用指定函数检测数组中的所有元素:
如果数组中检测到有一个元素不满足，则整个表达式返回false，且剩余的元素不会再进行检测。如果所有元素都满足条件，则返回true；
注意：every()不会对空数组进行检测；
every()不会改变原来的数组

15.arr.some(function(item,index,array){}) // 该函数对其中一项返回true，则返回true

array.some(function(item,index,array){
      //item:当前元素的值；
 
      //index:当前元素的索引；
 
      // array:当前元素的数组对象；
 }

some()方法会依次执行数组的每个元素:
如果有一个元素满足条件，则表达式返回true，剩余的元素不会再执行检测。如果没有满足条件的元素，则返回false
注意：some()不会对空数组进行检测；
some()不会改变原始数组；
16.arr.filter(callback) // 数组过滤，返回满足条件的元素组成的一个新数组

17.arr.map(callback) // 对数组每一项进行计算等处理，返回处理结果组成的数组,返回的是一个新数组

var numbers = [1, 4, 9];
var doubles = numbers.map(function (num) {
    return num * 2;
});
console.log(numbers);
console.log(doubles);

注意:通常情况下，map 方法中的 callback 函数只需要接受一个参数，就是正在被遍历的数组元素本身。但这并不意味着 map 只给 callback 传了一个参数
eg;

["1", "2", "3"].map(parseInt);// [1, NaN, NaN]

18.arr.reduce(fn) // 前一个元素 | 当前元素，从1开始 | 后一个元素的序列，从1开始计数 | 表示该数组

var arr = [1,2,3,4,5];
var reduceArr = arr.reduce(function(pre,cur,index,array){
    return prev + cur;
})   //15

19， …[arr] 数组扩展运算符

20.Math.min(…[arr]) 等同于Math.min.apply(null,arr) 替换数组的apply方法

  var arr=[1,2,3,4,5,6,7];
      console.log(Math.min(...arr));//1

21.arr1.push(…arr2) 等同于Array.prototype.push.apply(arr1,arr2) 一个数组添加到另一个数组的尾部

  var arr=[1,2,3,4,5,6,7];
        var arr1=[8,9,10];
          arr.push(...arr1);
        console.log(arr);//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

22.[…arr1,…arr2,…arr3] 等同于arr1.concat(arr2,arr3) 合并数组

var arr=[1,2,3,4,5,6,7];
        var arr1=[8,9,10];
        var arr2=[20,23,34,35,26];
        console.log([...arr,...arr1,...arr2]);//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 23, 34, 35, 26]

23.let[first,…const]=[1,2,3,4]，结果first=1，const=[2,3,4] 结合解构一起使用

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

24.Array.from() 将类数组对象和可遍历的对象转换为真正的数组（包括ES6新增的数据结构Set和Map）

Array.from(“hello”)  [“h”,”e”,”l”,”l”,”o”]
let person={
    0:'张三',
    1:'李四',
    2:'王五',
    length:3 //必须要设置对象长度
};
let arr=Array.from(person); //等同于let arr=[].slice.call(person);

Array.of(1,2,3) //将一组值转换为数组 [1, 2, 3]

25.Array.find(function(val,index,arr){
…
})
找到第一个符合条件的数组成员Array.find(function(val,index,arr)) 找到第一个符合条件的数组位置
这两个方法都可以发现NaN，弥补了数组的IndexOf方法的不足。

//find方法
 [1, 2, 3, 4].find((value, index, arr) => {
 console.log(value,index,arr);
//  1 0 (4) [1, 2, 3, 4]
//  2 1 (4) [1, 2, 3, 4]
//  3 2 (4) [1, 2, 3, 4]
//  4 3 (4) [1, 2, 3, 4]
value：每一次迭代查找的数组元素。
index：每一次迭代查找的数组元素索引。
arr：被查找的数组。
//-------------------------------------------------
 const arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
        var ret1 = arr1.find((value, index, arr) => {
            return value > 4
        })
        var ret2 = arr1.find((value, index, arr) => {
            return value > 14
        })
        console.log(ret1);//5
        console.log(ret2);//undefined

26.arr.includes()方法

let site = ['runoob', 'google', 'taobao'];
site.includes('runoob'); 
// true 
site.includes('baidu'); 
// false
//------------------------------------
//arr.includes(searchElement, fromIndex)
[1, 2, 3].includes(2);     // true
[1, 2, 3].includes(4);     // false
[1, 2, 3].includes(3, 3);  // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true
//searchElement	必须。需要查找的元素值。
//fromIndex	可选。从该索引处开始查找 searchElement。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。