数组方法-方法分类

****、总览

方法	功能	返回值	是否改变原数组
push	数组尾部添加元素	返回:添加元素之后数组的长度	是
unshift	数组首部添加元素	返回:添加元素之后数组的长度	是
pop	删除数组尾部第一个元素	返回被删除的元素	是
shift	删除数组首部第一个元素	返回被删除的元素	是
reverse	数组倒序排列	返回倒叙排列后的数组	是
sort	对数组元素进行排序	返回排序后的数组	是
splice	数组中插入或删除元素(注意:不同个数参数区别)	返回被删除元素组成的数组	是
copyWithin	将指定位置的元素复制到其他位置	返回更换后的数组	是
fill	填充数组(替换数组元素)	返回填充后的数组	是
-	-	-	-
join	将数组元素转化为字符串拼接一起	返回拼接后生成的字符串	否
concat	创建并返回一个新的合并数组	返回原数组和参数组数合并后的数组	否
slice	分割数组(注意:1个参数，2个参数区别)	返回被分割出来的数组	否
map	遍历数组，返回一个新数组	返回新数组	否
filter	遍历数组，条件过滤，返回一个符合条件的新数组	返回符合条件的新数组	否

1-5

    // 1、push()  数组尾部添加元素，返回值为数组长度, 参数：item1,item2,itemX......
    let arr = [1, 2, 3]
    console.log(arr.push('a')) // 4
    console.log(arr) // [1, 2, 3, 'a']

    // 2、unshift() 数组首部添加元素，返回值为数组长度, 参数：item1,item2,itemX......
    let arr = [1, 2, 3]
    console.log(arr.unshift('a')) // 4
    console.log(arr) // ['a', 1, 2, 3]

    // 3、pop() 数组首部添加元素，返回值为被删除的元素, 参数：无
    let arr = [1, 2, 3]
    console.log(arr.pop()) // 3
    console.log(arr) // [1, 2]

    // 4、shift() 数组首部删除元素，返回值为被删除的元素， 参数：无
    let arr = [1, 2, 3]
    console.log(arr.shift()) // 1
    console.log(arr) // [2, 3]

    // 5、reverse() 将数组倒叙排列， 返回倒叙排列后的数组， 参数：无
    let arr = [1, 2, 3]
    console.log(arr.reverse()) // [3, 2, 1]
    console.log(arr) // [3, 2, 1]

6、sort() 将数组倒叙排列， 返回倒叙排列后的数组

    // 参数(可选): 规定排序的函数
    // 没有传参：默认按字母升序，如果不是元素不是字符串，
    // 会调用toString()方法将元素转化为字符串的Unicode(万国码)位点，然后再比较字符
    // 无参数情况下：
    let arr = [3, 10, 2, 15, 26, 1]
    console.log(arr.sort()) // [1, 10, 15, 2, 26, 3]
    console.log(arr) //[1, 10, 15, 2, 26, 3]

    let arr = ['color', 'red', 'blue']
    console.log(arr.sort()) // ["blue", "color", "red"]
    console.log(arr, 202) // ["blue", "color", "red"]
    // 传参情况下
    // 参数为函数， 函数有两个默认参数a, b; 函数比较两个参数大小
    // 若比较函数返回值 < 0, a 会排在 b 前面
    // 若比较函数返回值 = 0, a 和 b 位置不变
    // 若比较函数返回值 > 0, a 会排在 b 后面

    // sort排序常用方法
    // 1、数组元素为Number类型的升序，降序排列
    let arr = [3, 10, 1, 25, 18]
    // 升序排列
    console.log(arr.sort((a, b) => {return a - b})); // [1, 3, 10, 18, 25]
    console.log(arr); // [1, 3, 10, 18, 25]
    // 降序排列
    console.log(arr.sort((a, b) => {return b - a})); // [25, 18, 10, 3, 1]
    console.log(arr); // [25, 18, 10, 3, 1]

    // 2、数组多条件排序
    let arr = [{id: 1, age: 18}, {id: 3, age: 24}, {id: 2, age: 6}]
    // 按照id 排序
    console.log(arr.sort((a, b) => {return a.id - b.id}));
    [{id: 1, age: 18}, {id: 2, age: 6}, {id: 3, age: 24}]
    // 按照age 排序
    console.log(arr.sort((a, b) => {return a.age - b.age}));
    [{id: 2, age: 6}, {id: 1, age: 18}, {id: 3, age: 24}]

7、splice() 添加/删除数组元素， 返回被删除的元素，（截取包含起始值）

    // 参数：至少两个 splice(index, endIndex)
    // 参数1（必需）：index, 添加/删除元素的位置，（使用负数，则从数组尾部定位,最后一个元素index为 -1）
    // 参数2（可选）：endIndex, 要删除的元素数量， 若不选，从起始位置到最后的元素都会删除 
    // 如果为0，不删除元素
    // 参数3（可选）：item1, item2, itemX....  向数组中添加元素
    let arr = [1, 2, 3, 4, 5]
    // 从2开始，截取后面所有元素
    console.log(arr.splice(2)) // [3, 4, 5]
    console.log(arr); // [1, 2]
    // 从-2 元素倒数第二个截取后面所有元素
    console.log(arr.splice(-2)) // [4, 5]
    console.log(arr) // [1, 2, 3]
    // 从0 开始截取2位元素
    console.log(arr.splice(0, 2)) // [1, 2]
    console.log(arr); // [3, 4, 5]
    // 从1开始截取2个元素之后，添加参数元素
    console.log(arr.splice(1, 2, 'a', 'b')) // [2, 3]
    console.log(arr) // [1, "a", "b", 4, 5]
    // 不删除，只添加元素
    console.log(arr.splice(1, 0, 'a', 'b')) // 没有删除元素， 返回[]
    console.log(arr) // [1, "a", "b", 2, 3, 4, 5]
    console.log(arr.splice(-1, 0, 'a', 'b')) // 没有删除元素， 返回[]
    console.log(arr) // [1, 2, 3, 4, "a", "b", 5]

8、copyWithin() 指定位置的元素复制到其他位置, 返回更换后的数组

    // 参数1（必需）：target，从该位置开始替换，若为负数，从尾部开始
    // 参数2（可选）：start，从该位置开始读取数据，默认为0，若为负数，从尾部开始
    // 参数3（可选）：end，读取到该位置前一个元素（不包含该元素），默认为数组长度，若为负数，从尾部开始
    let arr = [1, 2, 3, 4, 5]
    console.log(arr.copyWithin(1)); // [1, 1, 2, 3, 4]
    console.log(arr); // [1, 1, 2, 3, 4]
    console.log(arr.copyWithin(2, 1, 3)); // [1, 1, 2, 3, 4]

9、fill() 填充数组，返回填充后的数组

    // 参数1（必需）：需要填充的值
    // 参数2（可选）：填充开始位置，默认为0
    // 参数3（可选）：填充结束位置(不包含该位置)，默认为数组长度
    let arr = [1, 2, 3, 4]
    console.log(arr.fill(8)); // [8, 8, 8, 8]
    console.log(arr.fill(8, 1)); //[1, 8, 8, 8]
    console.log(arr.fill(8, 1, 3)); // [1, 8, 3, 4]

------------以下方法不改变数组------------
10、join() 把数组通过传入分隔符转为字符串，返回生成的字符串

    // 参数string(可选)，默认为逗号 ，
    let arr = [1, 3, 'a']
    console.log(arr.join()); // 1, 3, a
    console.log(arr, 555);
    console.log(arr.join('-')); // 1-3-a

    // 如果数组里面是对象，会直接被转为[object Object]，如果使用JSON.stringify()会识别转换
    let arr = [{name: 'zs', id: 1}, 5, 'a']
    console.log(arr.join('+')); // [object Object]+5+a
    console.log([JSON.stringify({name: 'zs', id: 1}), 5, 'a'].join()); // {"name":"zs","id":1},5,a

    // 如果数组里面还是数组，也会调用join()方法，返回值是用逗号隔开的字符串
    let arr = [[1, 2, 'b'], 5, 'a']
    console.log(arr.join('*')); // 1,2,b*5*a

11、slice() 返回一个从起点，到结尾（不包含尾部）所选择的部分数组，浅拷贝到另一个数组， 不改变原数组

    // 参数1（可选），数组索引数值，默认为0
    // 参数2（可选），数组索引数值（不包括），截取到该索引前一个元素
    let arr = [1, 2, 3, 4, 5]
    console.log(arr.slice(0, 2)); // [1, 2]
    console.log(arr.slice(1, 3)); // [2, 3]

    // 浅拷贝
    let arr = [{id: 1}, {id: 2}, {id: 3}, {id: 4}]
    let b = arr.slice(0, 2)
    b[0].id = 8
    console.log(arr); // [{id: 8}, {id: 2}, {id: 3}, {id: 4}]

12、concat() 合并两个或多个数组，返回合并后的数组 (浅拷贝)

    let a = [1, 2, 3]
    let b = [4, 5, 6]
    console.log(a.concat(b)); // [1, 2, 3, 4, 5, 6]
    console.log(a); // [1, 2, 3]
    // 浅拷贝
    let a = [{id: 1}, {id: 2}, {id: 3}, {id: 4}]
    let b = [4, 5, 6]
    let c = a.concat(b)
    console.log(c); // [{id: 1}, {id: 2}, {id: 3}, {id: 4}, 4, 5, 6]
    c[0].id = 8
    console.log(a); // [{id: 8}, {id: 2}, {id: 3}, {id: 4}]

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

13、indexOf() 查找数组是否存在某个元素，找到了返回对应值的索引，没找到返回 -1

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

14、includes() 查找数组是否包含某个员数， 返回布尔值

     let arr = [1, 2, 3]
    console.log(arr.includes(2));  // true
    console.log(arr.includes(5)); // false