数组及其方法详细

2024-02-23 00:00:00 数组 方法 详细

javascript 数组及其办法具体

简介

在 JavaScript 中,除了 Object 之外,数组(Array)应该是最罕用的类型了。数组是一组有序的数据,应用方括号示意[1, 2, 3],可通过索引来拜访每个元素(索引从 0 开始)。 JavaScript 中的数组的长度和元素类型都是非固定的。

数组的创立

数组的几种创立办法:字面量形式,Array构造函数,扩大运算符(…),ES6新增的用于创立数组的静态方法from()of()

数组字面量

//  语法
const arr = []
console.log(arr) // []

构造函数

//  语法
const arr1 = new Array();
console.log(arr1) // []

const arr2 = Array()
console.log(arr2) // []

在应用 Array 构造函数时,加不加 new 操作符,后果都一样。

扩大运算符

//  语法 ...
 const arr3 = [1,2,3]
 console.log(...arr3); // 1,2,3

Array静态方法

Array.form()

Array.from()能够能够接管3个参数

// 第一个参数是必传参
console.log(Array.from('arr')); // ['a', 'r', 'r']
// 第二个是可选的映射函数参数
console.log(Array.from([1,2,3],x => x + x)); // [2, 4, 6]
const arr1 = [1,2,3,4]
const arr2 = Array.from(arr1,function(x){return x**this.exponent},{exponent:2})
console.log(arr2); // [1, 4, 9, 16]
Array.of()
console.log(Array.of(1,2,3)); // [1,2,3]

数组检测

//  语法 Array.isArray()
console.log(Array.isArray([1,2,3])); // true
console.log(Array.isArray({foo:123})); // false
console.log(Array.isArray("hello")); // false
console.log(Array.isArray(undefined)); // false

数组的办法

contact() 合并

concat它将新数组的元素,增加到原数组的前面,返回一个新的数组,原数组不变

// 语法 .concat()
let arr = [1,2,3].concat(4,5,6);
console.log(arr); // [1, 2, 3, 4, 5, 6]

slice() 截取

slice()办法能够接管一个或俩个参数:返回元素的开始索引和完结索引.slice()返回的后果包含开始索引,不包含完结索引

let arr = [1,2,3]
arr.slice(1); // [2,3]
arr.slice(1,2); // [2]

splice() 删除 插入 替换

有以下三种应用形式:

  • 删除。须要给splice()传入两个参数:要删除的第一个元素的地位和要删除的元素和数量

    const arr = [1,2,3]
    arr.splice(0,1); // [1]
  • 插入。须要给splice()传入三个参数:开始掺入地位索引,0(删除0个元素)和要插入的元素,能够在数组中指定的地位插入元素.第三个参数之后还能够传第四个、第五个参数,乃至任意多个要插入的元素

    let arr = [1,2,3]
    arr7.splice(1,0,3)
    console.log(arr); //[1, 3, 2, 3]
  • 替换splice() 在删除元素的同时能够在指定地位插入新元素,这样咱们能够很不便实现元素的替换

    let arr = [1,2,3]
    arr.splice(0,1,0) // [0, 2, 3]

    sort() 排序

    let arr = [2,3,1]
    arr.sort((a,b)=> a - b) // 升序 [1,2,3]
    let arr = [2,3,1]
    arr.sort((a,b)=> b - a) // 降序 [3,2,1]

    reverse() 反转

    顾名思义,reverse() 办法就是将数组元素反向排列。该办法将扭转原数组。

    let arr = [1,2,3]
    arr.reverse(arr10) // [3,2,1]

    push() 开端增加

    push()办法用于向数组开端增加元素(任意数量的元素),返回数组的最新长度,该办法会扭转原数组

    let arr = []
    arr.push('a') // ['a']

    shift() 删除第一个

    shift()办法用于删除数组的第一个元素,并返回该元素。该办法会扭转原数组。

    let arr12 = ['a','b','c']
    arr12.shift() //  ['b', 'c']

    unshift() 增加第一个

    unshift()办法用于在数组的第一个地位增加元素,并返回增加新元素后的数组长度。该办法会扭转原数组。

    let arr13 = ['a','b','c']
    arr13.unshift('d') // ['d', 'a', 'b', 'c']

    forEach() 遍历循环数组没有返回值

    forEach 办法迭代数组的每一个元素,并对每个元素都调用一次咱们指定的回调函数。它没有返回值,只用来操作数据。forEach() 办法相当于应用 for 循环遍历数组。

     let arr = [1,2,3,4,5]
      arr.forEach((item, index, array)=>{
          console.log(item);  // 1 2 3 4 5
      })

    map() 遍历循环数组有返回值

    map()会将数组的每个元素都按程序传入回调函数,而后返回由每次函数调用的后果组成的新数组。 留神:回调 函数只会在有值的索引上被调用。

    let arr = [1,2,3,4,5]
      let brr =  arr.map((item, index, array)=>{
          return item * 2
      })
      console.log(brr); // [2, 4, 6, 8, 10]

    filter() 遍历过滤数组

    filter()` 办法用于过滤数组元素。它会对数组每一项都运行传入的函数,返回后果为true的元素将组成一个新数组返回。该办法不会扭转原数组。

    let arr = [1,2,3,4,5]
       let brr =  arr.filter((item, index, array) => item > 2)
       console.log(brr); // [3, 4, 5]

    some()

    如果数组中至多有一个元素满足测试函数,则返回 true,否则返回 false

    let arr = [1,2,3,4,5]
       let brr =  arr.some((item,index,array)=>item > 2 )
       console.log(brr); // true

    every()

    如果数组中的每个元素都满足测试函数,则返回 true,否则返回 false

    let arr = [1,2,3,4,5]
       let brr = arr.every((item,index,array)=> item > 2)
       console.log(brr); // false

    reduce()

    从左到右为每个数组元素执行一次回调函数,并把上次回调函数的返回值放在一个暂存器中传给下次回调函数,并返回最初一次回调函数的返回值。

       let arr = [1,2,3,4,5]
      let brr = arr.reduce((start,now,index,array)=>{
          console.log(start,now);
          return start+now
       },2)
       console.log(brr);
    //  2 1
    //  3 2
    //  5 3
    //  8 4
    //  12 5
    //  17

相关文章