前端JS数组属性和方法总结

Array的判断

var a = []
//instanceof
a instanceof Array
//constructor
a.constructor === Array
//Object.prototype.isPrototypeOf
Array.prototype.isPrototypeOf(a)
//getPrototypeOf
Object.getPrototypeOf(a) === Array.prototype
//Object.prototype.toString
Object.prototype.toString.apply(a) == '[Object Array]'
//Array.isArray
Array.isArray(a)

数组的构造器

字面量

var a = []

构造器

var a = Array(6)

Array.of

将参数转化为数组中的一项，返回新数组，不管参数是数字还是其他(区别Array构造器)

Array.from

快速边界的基于其他独享创建新数组，就是从一个类似数组的可迭代对象中创建一个新的数组实例。

参数

1. 一个可迭代对象(Obj,Set,Map)
2. (可选)加工函数，新生成的数组会经过这个函数的加工再返回，必须有return，否则返回undefined
3. (可选)this作用域，表示加工函数执行时this的值

Array.isArray

判断一个变量是否是数组类型

API

截止ES7 数组一共有33个API

改变自身

pop,push,reverse,shift,sort,splice,unshift,copyWithin,fill

1. pop:从数组的结尾删除元素，并且返回这个被删除的元素

let array = [1,2,3,4,5]
let a = array.pop()
//array [1,2,3,4]
//a 5

2. push:向数组末尾添加一个或多个元素，返回长度

let array = [1,2,3,4,5]
let a= array.push(1,2)
//array [1,2,3,4,5,1,2]
//a 7

3. reverse:翻转元素中元素的顺序,返回新数组

let array = [1,2,3,4]
array.reverse()
//array [4,3,2,1]

4. shift:删除并返回数组中的第一个元素

let array = [1,2,3,4]
let a = array.shift()
//a 1
//array [2,3,4]

5. unshift:在数组头添加一个或多个元素，返回长度

let array = [1,2,3,4]
let a = array.unshift(1,2)
//a 6
//array [1,2,1,2,3,4]

6. sort:数组排序，默认按照字母升序排列，参数是一个函数，规定排序规则

let array = [5,4,3,2,21]
let a = array.sort()
//array [2,21,3,4,5]
//a [2,21,3,4,5]
array = [5,4,3,2,21]
let c = array.sort((a,b) => a-b)
//array [2,3,4,5,21]
//a [2,3,4,5,21]

7. splice:从数组中添加或者删除替换元素,如果删除元素，则返回删除元素的数组，没有删除，返回空数组

• splice(index,howmany,item1,item2…):index是开始删除的元素的下标，howmany是长度，删除的长度，剩下的是填充的元素。
• 可以理解为从index开始裁剪，裁剪长度为howmany，把item接上。

let array = [1,2,3,4,5]
let a = array.splice(1,2,7)
// array [1,7,4,5]
// a [2,3]

8. copyWithin:从数组的指定位置拷贝元素到数组的另一个指定位置中，返回数组

• copyWithin(target,start,end):target是要复制到的地方的索引，start是复制的起点索引，end是停止复制的索引位置。

let array = [1,2,3,4,5,6]
let a =  array.copyWithin(2,0,2)
//array [1,2,1,2,5,6]
//a [1,2,1,2,5,6]

9. fill:使用一个固定值替换数组中的元素,返回数组

• fill(value,start,end):value填充值，start开始位置，end结束位置

let array = [1,2,3,4]
let a = array.fille(1)
//array [1,1,1,1]

不改变自身

concat,join,slice,toString,toLicateString,indexOf,lastIndexOf,toSource,includes

1. concat:连接两个或多个数组，返回连接好的数组的副本

• concat(item1,item2…):item1可以是数组或者元素，如果是数组，就是把它的元素添加到新的数组中。

let array = [1,2,3]
let c = array.concat([5,4],7)
//array [1,2,3]
//c [1,2,3,5,4,7]

2. join:把数组中的所有元素连接起来，返回一个字符串

• join(s),s是分隔符，就是连接数组时，插入到元素中间的东西
• 如果数组的元素是Object,则会调用它的toString方法。

let array = [1,2,3,4,5]
let c = array.join("+")
//array [1,2,3,4,5]
// c 1+2+3+4+5

3. slice:从已有的数组中返回选定的元素的数组

• slice(start,end):start是开始选取的下标，end是结束的下标

let array = [1,2,3,4,5]
let c= array.join(2,4)
//c [3,4]

4. toString:把数组转化为字符串，然后返回这个字符串

let array = [1,2,3,4]
let c= array.toString()
//c '1,2,3,4'

5. toLicateString:

6. indexOf:返回被查找元素在数组中的第一个下标，参数是要查找的元素。

let array = [1,2,3,4]
let c = array.indexOf(2)
//c 1

7. lastIndexOf:返回被查找元素在数组中的最后一个下标，参数是要查找的元素

let array = [1,4,3,4]
let c = array.indexOf(3)
//c 1

8. toSource
9. includes:判断一个数组是否包含一个元素，返回Boolean

• includes(ele,index):ele是要检查的元素，index是开始检查的下标，默认是0

let array = [1,2,3,4,5]
let c = array.includes(2)
//c true

遍历方法

1. foreach:遍历数组，每一个元素都执行一次回调函数

• Array.forEach(func(Value,index,arr),thsiValue):value是每次执行时传的元素，index是当前元素的下标，arr是当前元素所属的数组，thisValue一般是this
• 当遍历的时候，传过去的v只是一个副本，修改v不能表现到array上，想要修改arra的元素的值，要用a[i]。
• forEach不支持continue和break

let array = [1,2,3,4]
array.forEach((v,i,a)=>{v+=i})
//没有返回值
//实现continue关键字
array.forEach((v)=>{
    if(v === 2){
        return;
    }
    console.log(v)
})
//实现break
//用every

2. every:检测数组所有元素是否都符合指定条件。

• 如果检测到一个元素不满足，则整个表达式返回fasle，并且剩余的元素不会被检测；如果都满足，name返回true
• every(func(value,index,arr),thisValue):参数同forEach
• 返回值是boolean

let array = [1,2,3,4]
let c = array.every((v,i,a)=>{return v>0})
//c true

3. some:检测数组中的元素是否满足指定条件

• some会一次执行数组中的每个元素，如果一个元素满足条件，则表达式返回true，并且剩余元素不再检测，如果没有满足条件的元素，返回false
• 参数同forEach

let array = [1,2,3,4]
let c = array.some((v,i,a)=>{return v>3})
//c true

4. filter:创建一个新数组，检查指定数组中符合条件的元素，放入新数组中

• 参数同forEach,返回一个数组

let array = [1,2,3,4,5]
let c = array.filter((v,i,a)=>{
    return v>3
})
//c [4,5]

5. map:对数组中的每个元素都调用函数处理，处理后的值放入一个新数组中。

• 参数同forEach，返回值为数组

let array = [1,2,3,4,5]
let c = array.map((v,i,a)=>{
    return v+=i
})
//c [1,3,5,7,9]

6. reduce:接受一个函数做累加器，数组中的每个值从左到右开始遍历，最终计算出一个值，并返回它

• 参数：reduce(func(t,v,i,a),init):t是最后返回的值，也是初始值，v是数组的元素，i是元素对应的下标,a是数组本身,init是t的初始值。
• 当省略init时，t的初始值就是数组的第一项，然后遍历调用函数直接从第二项开始，这就会出现一些稍难理解的现象

let array = [1,2,3,4,5]
let c= array.reduce((t,v)=>{
    return t+=v*2
})
//c 29
let d = array.reduce((t,v)=>{
    return t+=v*2
},0)
//c 30

7. reduceRight:同reduce只是，调用顺序是从右至左

8. find:返回符合函数的第一个元素值

• 参数同forEach，返回值是元素的值，或者undefined

let array = [1,2,3,4,5]
let c = array.find(v=>v>2)
//c 3

9. findIndex:同find，只是返回值是下标，没有的话返回-1
10. entries:返回数组的可迭代对象

• 没有参数，返回值是一个可迭代对象

11. keys:返回包含数组键的可迭代对象
12. values:返回包含数组值的可迭代对象