数组及其方法详细

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