数组方法-方法分类

2019-03-22  本文已影响0人  有灵魂
****、总览
方法 功能 返回值 是否改变原数组
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
上一篇下一篇

猜你喜欢

热点阅读