美文网首页JavaScript
数组的操作方法

数组的操作方法

作者: Lia代码猪崽 | 来源:发表于2018-08-08 17:12 被阅读3次

    要特别留意的是,有一些操作会修改当前数组,而某一些不会修改当前数组,返回一个新数组。

    一、添加或者删除元素

    1.在起始位置添加或者删除一个元素(unshift、shift)----- 修改原数组

    const arr = ['a', 'b', 'c']
    arr.unshift('d') //  返回4,arr为['d', 'a', 'b', 'c']
    arr.shift() //  返回'd', arr为['a', 'b', 'c']
    

    2.在末尾处添加或者删除一个元素(push、pop)----- 修改原数组

    const arr = ['a', 'b', 'c']
    arr.push('d') //  返回4,arr为['a', 'b', 'c', 'd',]
    arr.pop() //  返回'd', arr为['a', 'b', 'c']
    

    3.在末尾处添加多个元素(concat)----- 不修改原数组

    const arr = ['a', 'b', 'c']
    arr.concat('d', 'e', 'f') //  返回['a', 'b', 'c', 'd', 'e', 'f'],arr为['a', 'b', 'c']
    arr.concat(['d', 'e', 'f']) //  返回['a', 'b', 'c', 'd', 'e, 'f''],arr为['a', 'b', 'c']
    arr.concat(['d', 'e'], 'f') //  返回['a', 'b', 'c', 'd', 'e', 'f'],arr为['a', 'b', 'c']
    
    // concat 只会拆分传给它的数组,不会拆分传给它的数组里的数组元素
    arr.concat([['d', 'e'], 'f']) //  返回['a', 'b', 'c', ['d', 'e'], 'f'],arr为['a', 'b', 'c']
    

    4.从任意位置添加或者删除多个元素(splice)----- 修改原数组

    第一个参数是起始修改位置的下标,第二个参数是需要删除的元素个数(不想删除就传0),其他参数就是要增加到数组里的元素。

    const arr = [1, 5, 7]
    
    arr.splice(1, 0, 2, 3, 4)  
    // 分析一下, 第一个元素告诉我们index为1,第二个元素告诉我们不是删除操作,所以:在index为1的位置前,加入2, 3, 4
    // 返回[], arr为 [1, 2, 3, 4, 5, 7]
    
    arr.splice(5, 0, 6)  
    // 分析一下, 第一个元素告诉我们index为5,第二个元素告诉我们不是删除操作,所以:在index为5的位置前,加入6
    // 返回[], arr为 [1, 2, 3, 4, 5,  6, 7]
    
    arr.splice(1, 2)  
    // 分析一下, 第一个元素告诉我们index为1,第二个元素告诉我们是删除操作,删除2个元素,没有第三个元素告诉我们没有增加操作,所以:从index为1开始,连续删除2个元素
    // 返回[2, 3], arr为 [1, 4, 5,  6, 7]
    
    arr.splice(2, 1, 'a', 'b')  
    // 分析一下, 第一个元素告诉我们index为2,第二个元素告诉我们是删除操作,删除1个元素,有第三第四个元素,所以:从index为2开始,连续删除1个元素,再加入'a', 'b'
    // 返回[5], arr为 [1, 4, 'a', 'b', 6, 7]
    

    这里要注意的是,删除元素是从index位置开始的,而添加元素是添加到index的前面


    二、分割或者替换数组

    1.获得子数组(slice) ----- 不修改原数组

    第一个参数是子数组的起始位置,第二个参数是终止的位置(省略则到数组末尾)。
    下标位置也可以用负数来表示倒数的元素(从-1开始,正数的是从0开始的)。

    const arr = [1, 2, 3, 4, 5]
    arr.slice(3)  // 截取从index为3到末尾,所以:返回[4, 5],arr为 [1, 2, 3, 4, 5]
    arr.slice(2, 4)  // 截取从index为2开始到4之前,所以:返回[3, 4],arr为 [1, 2, 3, 4, 5]
    arr.slice(-2)  // 截取从倒数第2个开始到末尾,所以:返回[4, 5],arr为 [1, 2, 3, 4, 5]
    arr.slice(1, -2)  // 截取从index为1到倒数第二个之前,所以:返回[2, 3],arr为 [1, 2, 3, 4, 5]
    arr.slice(-2, -1)  // 截取从倒数第2个开始到倒数第1个之前,所以:返回[4],arr为 [1, 2, 3, 4, 5]
    

    这里要注意的是,截取到第二个参数之前,不包括第二个参数位置的当前元素

    2.数组内的分割和替换(copyWithin) ----- 修改原数组

    ES6引入的新方法,将数组中一串有序的元素到这个数组的另外一个位置,会覆盖掉原来的内容。
    第一个参数是目标位置,第二个参数是复制内容的开始参数,第三个参数是复制内容的结束参数(如果省略就到末尾)。
    下标位置也可以用负数来表示倒数的元素(从-1开始,正数的是从0开始的)。

    const arr = [1, 2, 3, 4]
    arr.copyWithin(1, 2)  // 目标index为1,复制内容为从index为2的开始,到结尾,所以arr为[1, 3, 4, 4]
    arr.copyWithin(2, 0, -2)  // 目标index为2,复制内容为从index为0的开始,到index为-2之前,所以arr为[1, 3, 1, 3]
    arr.copyWithin(0, -3, -1)  // 目标index为0,复制内容为从index为-3的开始,到index为-1之前,所以arr为[3, 1, 1, 3]
    

    这里要注意的是,复制内容截取到第三个参数之前,不包括第三个参数位置的当前元素


    三、用指定值填充数组

    1.填充数组(copyWithin) ----- 修改原数组

    ES6引入的新方法,将一个固定值付给数组中任意位置。与数组构造器搭配使用更佳哦。
    下标位置也可以用负数来表示倒数的元素(从-1开始,正数的是从0开始的)。

    const arr = new Array(5).fill(1)  // arr被初始化为[1, 1, 1, 1, 1]
    arr.fill('a')  // arr为['a', 'a', 'a', 'a', 'a']
    arr.fill('b', 1)  // arr为['a', 'b', 'b', 'b', 'b']
    arr.fill('c', 2, 4)  // arr为['a', 'b', 'c', 'c', 'b']
    arr.fill(5.5, -4)  // arr为['a', 5.5, 5.5, 5.5, 5.5]
    arr.fill(0, -3, -1)  // arr为['a', 5.5, 0, 0, 5.5]
    

    四、数组元素排序

    1.倒序数组(reverse) ----- 修改原数组

    const arr = [1, 2, 3, 4, 5]
    arr.reverse()  // arr为[5, 4, 3,  2, 1]
    

    2.正序数组(sort) ----- 修改原数组

    const arr = [5, 4, 3,  2, 1]
    arr.sort()  // arr为[1, 2, 3, 4, 5]
    

    3.按照指定排序函数来排序(sort) ,可用于对象数组!----- 修改原数组

    const arr = [{ name:  'Suzanne' }, { name:  'Jim' }, { name:  'Trevor' }, { name:  'Amanda' }]
    arr.sort()  // arr没有变化
    
    arr.sort( (a, b) => a.name > b.name)  // arr按照元素name属性的字母顺序排序,大于号为正序
    // arr为[{name: "Amanda"}, {name: "Jim"}, {name: "Suzanne"}, {name: "Trevor"}]
    
    arr.sort( (a, b) => a.name[1] < b.name[1] )  // arr按照元素name属性的第二个字母的字母顺序排序,小于号为倒序
    // arr为[{name: "Suzanne"}, {name: "Trevor"}, {name: "Amanda"}, {name: "Jim"}]
    

    五、搜索元素

    1.返回跟所要查找的内容完全相同的第一个元素的下标(indexOf、lastIndexOf)

    第一个元素是匹配的内容,第二个元素查找起始的位置的下标。
    如果没有找到,则会返回 -1。

    const arr = [1, 5, 'a', 5]
    arr.indexOf('a') // 返回2
    arr.indexOf(5) // 返回1
    arr.indexOf(5, 2) // 返回3
    arr.indexOf(9) // 返回-1
    arr.lastIndexOf('a') // 返回2
    arr.lastIndexOf(5) // 返回3
    arr.lastIndexOf(9) // 返回-1
    

    2.通过指定函数来查找内容相同的第一个元素的下标(findIndex、findLastIndex)

    const arr = [ { id: 5, name: 'Judth'}, { id: 7, name: 'Francis'} ]
    arr.findIndex( o => o.id === 5 ) // 返回0
    arr.findIndex( o => o.name === 'Francis' ) // 返回1
    arr.findIndex( o => o.id === 3) // 返回-1
    arr.findIndex( o => o.name === 'asdsadas' ) // 返回-1
    

    3.通过制定函数来查找内容相同的元素(find)

    find方法的第一个参数是搜索函数,第二个参数则为绑定this的对象。
    搜索函数第一个参数为数组的每一个元素,第二个参数为每一个元素对应的下标,第三个元素是数组本身。
    返回值为找到的元素。

    const arr = [1, 17, 16,  5, 4, 16, 10, 3, 47]
    arr.find( (x, i) => i > 2 && Number.isInteger(Math.sqrt(x)))  // return 4
    

    4.查找某个元素是否在数组中存在(some)

    一旦找到符合条件的元素,就会返回true,否则返回false。

    const arr = [5, 7, 12, 15, 17]
    arr.some(x => x % 2 === 0)  // return true; 12是偶数
    arr.some(x => Number.isInteger(Math.sqrt(x))  // return false; 没有平方数
    

    5.查找是否每个元素都符合(every)

    const arr = [4, 6, 16, 36]
    arr.every(x => x % 2 === 0)  //return true; 没有奇数
    arr.every(x => Number.isInteger(Math.sqrt(x))  // return false; 6不是平方数
    

    六、得到想要的新数组

    1.一一映射(map) ---- 不修改原数组

    const items = ['Widget', 'Gadget']
    const prices = [9.25, 22.95]
    // 这里要把对象用小括号包围,如果没有箭头函数会把{}里的内容当做程序块
    const cart = items.map((x, i) => ({ name: x, price: prices[i]})) 
    // cart为[{name: "Widget", price: 9.25}, {name: "Gadget", price: 22.95}]
    

    2.过滤,删除不需要的元素(filter) ---- 不修改原数组

    const arr = [5, 8, 4, 13]
    const filters = arr.filter(x => x%2 !== 0)  // return [5, 13];删除了不是偶数的元素
    

    相关文章

      网友评论

        本文标题:数组的操作方法

        本文链接:https://www.haomeiwen.com/subject/lsdovftx.html