JS数组常用的20种方法

  //1.push() 往数组结尾处添加一个或多个内容,返回值是新数组的长度
    let a = []
    //语法
    a.push(1, 'one')
    //打印
    console.log(a, 'push');
    //结果
    // (2)[1, 'one']

    //2.unshift() 向数组的头部添加单个或者多个内容,返回值是新数组的长度
    let c = [1, 2, 3,]
    //语法
    c.unshift(3)
    //打印
    console.log(c, 'unshift');
    //结果
    // [3, 1, 2, 3] 

    //3.pop() 从数组的结尾处删除数据,返回值是被删除的元素,
    let b = [1, 2, 3,]
    b.pop()
    console.log(b, 'pop');
    //结果
    // [1, 2] 

    //4.shift() 从数组的头部删除数据,返回值是被删除的元素
    let d = [1, 2, 3, 4, 5]
    //语法
    d.shift()
    //打印
    console.log(d, 'shift');
    //结果
    //[2,3,4,5]

    //5.reverse() 可以吧数组进行翻转 返回值是一个新数组
    let e = [1, 2, 3, 4, 5]
    //语法
    e.reverse()
    console.log(e, 'reverse');
    //结果
    //[5, 4, 3, 2, 1]

    //6.srot(a,b) 可以将一个混乱的数组进行排序 a-b 正序 b-a 倒序
    let f = [5, 1, 2, 3, 4, 7, 6]
    //语法
    f.sort((a, b) => { return a - b })
    console.log(f, 'sort');
    //结果
    //[1,2,3,4,5,6,7]

    //7.concat() 用于数组合并 返回一个新数组
    let g = [6, 7]
    let h = [8, 9]
    let i = []
    //语法
    i = g.concat(h)
    console.log(i, 'concat');
    //结果
    //[6,7,8,9]

    //8.splice(参1,参2,参3) 截取,删除 参1是截取的下标 参2是截取的个数 参3 是往数组中添加的内容,此方法可以更改数组的原始数据 返回的是删除的那个删除项组成的数组 
    let j = [1, 2, 3, 4, 5]
    //语法
    j.splice(2, 2)
    console.log(j, 'splice');
    //结果
    //[1, 2, 5]

    //9 indexof() 根据内容在数组中从前往后查找,如果查找到则返回下标,查找不到则返回-1 如果有相同的数组 返回第一个数据的下标
    let k = [1, 2, 3, 4, 5, 6, 7]
    //语法
    let l = k.indexOf(5)
    console.log(l, 'indexof');
    //结果
    //4 

    //10 lastIndexOf() 根据内容在数组中从后往前查找,如果查找到则返回下标,查找不到则返回-1 如果有相同的数组 返回第一个数据的下标
    let m = [1, 2, 3, 4, 5, 6, 7]
    //语法
    let n = m.lastIndexOf(5)
    console.log(n, 'lastIndexOf');
    //结果
    //4 

    //11 join(x) 将数组的元素组成一个字符串 以x为分隔符 省略默认使用,做为分隔符
    let o = [1, 2, 3, 4, 5, 6, 7]
    //语法
    let p = o.join('|')
    console.log(p);
    //结果
    //1|2|3|4|5|6|7

    //12 slice() 可以接受一个或两个参数 即要返回项 起始和结束的位置 
    //只有一个参数的时候返回从该参数指定位置开始到当前数组末尾的所有项
    //如果有两个参数 该方法返回起始和结束位置之间的项 不包括结束位置的项
    //语法
    let q = [1, 2, 3, 4, 5, 6]
    let r = q.slice(1)
    let s = q.slice(2, 3)
    console.log(r, s, 'slice');
    //结果
    //[2, 3, 4, 5, 6] [3]

    //13 forEach() 对数组进行遍历循环，对数组中的每一项运行给定数。这个方法没有返回值。参数都是function类型 参数1,遍历数组的内容，对应数组索引的下标
    let t = [1, 2, 3, 4, 5, 6, 7]
    //语法
    t.forEach((item, index) => {
        console.log(item, index, 'forEach');
    })
    //结果
    // 1 0 
    // 2 1
    // 3 2
    // 4 3
    // 5 4
    // 6 5
    // 7 6

    //14.map() 返回一个新数组 第一个参数:item 必填 第二个参数:index 可选 第三个参数:arr 当前元素的数组对象 
    let u = [1, 2, 3, 4, 5, 6]
    //语法
    u.map((item, index) => {
        console.log(item * item, 'map');
    })
    //结果
    // 1
    // 4
    // 9
    // 16
    // 25
    // 36

    //15 filter() 过滤 把数组中的某个元素过滤掉 返回剩下未被过滤的元素 第一个参数:item 必填 第二个参数:index 可选
    let v = [1, 2, 3, 4, 5, 6]
    let w = v.filter(num => num === 3)
    //语法
    console.log(w, 'filter');
    //结果
    //3

    //16 every()  判断数组中每一项是否满足条件,只有所有项都满足条件才会返回true
    //语法
    let x = [1, 2, 3, 4, 5, 6]
    let flag = x.every(item => item < 10)
    console.log(flag, 'every');
    //结果
    //true

    //17 some() 判断数组是否存在满足条件的项 只要有一项满足条件 就会返回true
    let y = [1, 2, 3, 4, 5, 6, 7]
    //语法
    let flag1 = y.some(item => item < 2)
    console.log(flag1, 'some');
    //结果
    //true

    //18 includes() 用来判断一个数组中是否包含一个指定的值,如果是返回true 不是则返回false
    let z = [1, 2, 3, 4, 5, 6, 78]
    //语法
    let a1 = z.includes(78)
    console.log(a1, 'includes');
    //结果
    //true

    //19 find() 返回匹配项的值 满足条件 第一次返回true就停止查找
    let b1 = [1, 2, 3, 4, 5, 6, 7, 99]
    //语法
    let c1 = b1.find(item => item > 7)
    console.log(c1, 'find');
    //结果
    //99

    //20 findIndex() 返回匹配项值的下标 满足条件 第一次返回true 就停止查找
    let d1 = [1, 2, 3, 4, 5, 6, 7, 8]
    //语法
    let e1 = d1.findIndex(item => item > 7)
    console.log(e1, 'findIndex');
    //结果
    //7