js数组

js数组的相关做法是每次面试都要提到的问题 ，今天来整理一下，以后面试都不得怕

数组的常用方法

• push( ) —— 从结尾添加元素

• pop( ) —— 从结尾提取元素

• shift( ) —— 从开头提取元素

• unshift( ) —— 从开头添加元素

• splice(index,howmany,item1,.....,itemX) —— 从数组中添加\删除元素，然后返回被删除的元素（index-添加\删除的位置可以为负数，为负数从数组尾部开始算起的位置，howmany为删除个数，item1,.....,itemX为向数组添加的元素）

• slice( start，end ) —— 返回一个新数组，从下标start开始到end结束（如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推）

• concat( ) —— 返回一个新的数组，用于连接两个或多个数组

• indexof( ) —— 返回某个指定的字符串值在字符串中首次出现的位置，如果没有返回-1

• lastIndexOf —— 返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找，从 fromIndex 处开始。

• includes( value ) —— 用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false

• find( ) —— 返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined

• findeIndex( ) —— 方法返回数组中满足提供的测试函数的第一个元素的索引。否则返回-1

• filter( callback() ) —— 创建一个新数组, 其包含通过callback函数为true的测试的所有元素

• map( ) —— 创建一个新数组，其结果是该数组中的每个元素都调用一次提供的函数后的返回值。

• sort( compareFunction ) —— 对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建

  如果指明了 compareFunction ，那么数组会按照调用该函数的返回值排序。即 a 和 b 是两个将要被比较的元素：

  • 如果 compareFunction(a, b) 小于 0 ，那么 a 会被排列到 b 之前；

  • 如果 compareFunction(a, b) 等于 0 ， a 和 b 的相对位置不变。备注： ECMAScript 标准并不保证这一行为，而且也不是所有浏览器都会遵守（例如 Mozilla 在 2003 年之前的版本）；

  • 如果 compareFunction(a, b) 大于 0 ， b 会被排列到 a 之前。

  • compareFunction(a, b) 必须总是对相同的输入返回相同的比较结果，否则排序的结果将是不确定的。

• reverse( ) —— 将数组中元素的位置颠倒，并返回该数组

• join( ) —— 方法将一个数组的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项目，那么将返回该项目而不使用分隔符。

• reduce( ) —— 对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值。

• forEach( ) —— 对数组的每个元素执行一次给定的函数。

• some( ) —— 测试数组中是不是至少有1个元素通过了被提供的函数测试。它返回的是一个Boolean类型的值。

• every( ) —— 测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值。

• fill(value , start,end ) —— 用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引。(value用来填充数组元素的值。start 可选起始索引，默认值为0。end 可选终止索引，默认值为 this.length)

• Array.isArray( ) —— 用于确定传递的值是否是一个 Array。

• Array.from( ) —— 从一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例

• Array.of() —— 创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型

• Array.toString() —— 返回一个字符串，表示指定的数组及其元素

代码展示

都是改变之后新数组或原数组的值，对于返回值下一节会写

//Array.from
Array.from('foo') //['f','o','o']
Array.from([1, 2, 3], x => x + x) //[2,4,6]

//Array.isArray
Array.isArray([1, 2, 3]) //true
Array.isArray("foobar") //false

//Array.of
Array.of(7) //[7]
Array.of(1,2,3,4) //[1,2,3,4]

//Array
Array(7) //[ , , , , , , ]
Array(1,2,3,5) //[1,2,3,5]

//Array.concat
const array1 = ['a', 'b', 'c']
const array2 = ['d', 'e', 'f']
const array3 = array1.concat(array2);//['a','b','c','d','e','f']

//Array.every
const array1 = [1,2,4,12,34]
array1.every(item => item<40) //true

//Array.some
const array1 = [1,2,4,12,34]
array1.some(item => item<3) //true

//Array.fill
const array1 = [1,2,3,4]
array1.fill(5,1) //[1,5,5,5]
array1.fill(0, 2, 4) //[1,2,2,4]
array1.fill(4) //[4,4,4,4]

//Array.filter
const array1 = [1,2,3,4,5,6]
array1.filter(item => item>3) //[4,5,6]

//Array.find
const array1 = [5, 12, 8, 130, 44]
array1.find(element => element > 10) //12

//Array.findIndex
const array1 = [5, 12, 8, 130, 44]
array1.find(element => element > 13) //3
array1.find(element => element > 1000) //-1

//Array.flat
var array1 = [1, 2, [3, 4]]
array1.flat(); //[1,2,3,4]
var array2 = [1, 2, [3, 4, [5, 6]]]
array2.flat(); //[1,2,3,4,[5,6]]
var array3 = [1, 2, [3, 4, [5, 6]]]
array3.flat(2);// [1, 2, 3, 4, 5, 6]
//使用 Infinity，可展开任意深度的嵌套数组
var array4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]]
array4.flat(Infinity);// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

//Array.forEach
const array1 = ['a', 'b', 'c']
array1.forEach(element => console.log(element)) //a//b//c

//Array.includes
const array1 = [1,2,3,4]
array1.includes(1) //true
array1.includes(12) //false

//Array.indexOf
const array1 = [1,2,3,4]
array1.indexOf(1) //0
array1.indexOf(12) //-1

//Array.join 
const array1 = ['a','b','c','d']
array1.join() //'a,b,c,d'
array1.join('') //'abcd'
array1.join('-') //a-b-c-d

//Array.key
const array1 = ['a', 'b', 'c'];
const iterator = array1.keys(); //[0,1,2]

//Array.lastIndexOf
const animals = ['Dodo', 'Tiger', 'Penguin', 'Dodo']
animals.lastIndexOf('Dodo') //3
animals.lastIndexOf('Dodoasd') //-1

//Array.map
const array1 = [1, 4, 9, 16]
array1.map(x => x * 2) //[2,8,18,32]

//Array.pop
const array1 = [1, 4, 9, 16]
array1.pop() //[1,4,9]

//Array.push
const array1 = [1, 4, 9, 16]
array1.push(32) //[1,4,9,16,32]

//Array.shift
const array1 = [1, 4, 9, 16]
array1.shift() //[4, 9, 16]

//Array.unshift
const array1 = [1, 4, 9, 16]
array1.unshift(1) //[1,1,4,9,16]

//Array.reduce
const array1 = [1, 2, 3, 4]
array1.reduce((accumulator, currentValue) => accumulator + currentValue,0) //10

//Array.reserve
const array1 = [1, 2, 3, 4]
array1.reserve() //[4,3,2,1]

//Array.slice
const array1 = [1, 2, 3, 4, 5, 6]
array1.slice(2) //[3,4,5,6]
array1.slice(2,4) //[3,4]

//Array.splice
const array1 = [1, 2, 3, 4, 5, 6]
array1.splice(2,1) //[1,2,4,5,6]
array1.splice(2,1,2) //[1,2,2,4,5,6]

//Array.sort
const array1 = [1, 30, 4, 21, 100000]
array1.sort() //[1, 100000, 21, 30, 4]

//Array.toString
const array1 = [1, 2, 3, 4, 5, 6]
array1.toString() //'1,2,3,4,5,6'

返回值

plice、sort、reverse这3个常用方法是对数组自身的操作，会改变数组自身，

其他会改变自身的方法是增删push/pop/unshift/shift、填充fill和复制填充copyWithin。