乐趣区

关于javascript:数组及其方法详细

jiezi

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
退出移动版