js数组的归纳

数组

数组对象的作用是：使用单独的变量名来存储一系列的值。
我今天从数组的创建到对数组的行为进行归类。

创建数组

1. 常规方式：创建数组并给数组元素赋值。

> var baby = new Array();
undefined
> baby[0] = "meili"
'meili'
> baby[1]="lulu"
'lulu'
> baby
[ 'meili', 'lulu' ]

2.简洁方式：直接实例化。

  > var arr = new Array(1,5,8,9)

3.字面量：隐式创建

var arr = [1,2,5,8]

这里提一下数组的属性：
consturctor:返回对创建此对象的数组函数的引用
length：设置或返回数组中元素的数目
prototype:使我有能力向对象添加属性或方法。

数组行为

从行为上是否会改变数组来归纳为两部分，原数组被修改，原数组不变。

会改变原数组

push,unshift,pop,shift,reverse,sort,splice,这几种数组方法会改变原数组
push,unshift---------->返回值是数组新长度
pop,shift---------->返回值是被删除的元素
splice----------->返回值是被删除元素组成的数组
sort,reverse-------->返回值是新数组

1. push
   末尾添加一个元素，返回值是新长度。

> arr
[ 1, 5, 8, 9 ]
> arr.push(10)
5 //数组长度此时+1=5
> arr
[ 1, 5, 8, 9, 10 ]//原数组被改变

2. unshift
   开头添加一个元素，返回值是新长度

> arr
[ 1, 5, 8, 9, 10 ]
> arr.unshift(1)
6 //数组长度和push一样+1
> arr
[ 1, 1, 5, 8, 9, 10 ]
> //原数组被改变，并且添加的元素在数组开头                    

3. pop
   删除数组末尾的元素，返回删除的值

> arr
[ 1, 1, 5, 8, 9, 10 ]
> arr.pop()
10 //返回被删除的元素10
> arr
[ 1, 1, 5, 8, 9 ] //原数组被改变

4.shift
删除第一个元素，返回删除的值

> arr
[ 1, 1, 5, 8, 9 ]
> arr.shift()
1 //返回删除元素的值
> arr
[ 1, 5, 8, 9 ]

5.reverse
倒序，返回新数组

> arr
[ 1, 5, 8, 9 ]
> arr.reverse()
[ 9, 8, 5, 1 ]//返回值是新数组===arr 
> arr
[ 9, 8, 5, 1 ]

6.sort
根据ASCII码值进行，返回值是新数组

> baby
[ 'meili', 'lulu' ]
> baby.sort()
[ 'lulu', 'meili' ]
> baby
[ 'lulu', 'meili' ]//原数组被改变

7.splice
删除添加元素，返回的是被删除元素组成的数组

> arr
[ 1, 5, 8, 9 ]
> arr.splice(1,1,10,10)
[ 5 ] //splice方法的参数，第一个是删除元素开始的位置，第二个是要删除的个数，从低2个以后的元素都是要往数组中添加的元素。
> arr
[ 1, 10, 10, 8, 9 ] 

不会改变原数组

1.concat
数组拼接，返回值是拼接之后的数组

> var a = [1,2,3]
undefined
> var b = [4,5,6]
undefined
> var c = a.concat(b)
undefined
> c
[ 1, 2, 3, 4, 5, 6 ]
> a
[ 1, 2, 3 ] //原数组并没有被改变

2.slice
剪切,返回值是被剪切元素组成的数组

> c
[ 1, 2, 3, 4, 5, 6 ]
> c.slice(0,2)
[ 1, 2 ]
> c
[ 1, 2, 3, 4, 5, 6 ]

3.join
数组转换为字符串，返回值是字符串

> a.join()
'1,2,3'//默认以，分割
> a.join('*')
'1*2*3'
> a
[ 1, 2, 3 ]

4.indexOf
返回规定数组索引开始第一个查询到的索引值

> var a = [1,2,5,5,5]
undefined
> a.indexOf(5,4)//indexOf第一个参数是要查询的值，第二个参数是开始查找的索引值
4
> a
[ 1, 2, 5, 5, 5 ]
> a.indexOf(9,2)
-1//查询不到返回值为-1
> a.includes(5)
true//includes返回值是true或false
> a
[ 1, 2, 5, 5, 5 ]

5.filter
过滤 ，返回值是数组中满足条件的元素组成的新数组

[ 1, 2, 5, 5, 5 ]
> a.filter(function(current,index,array){
> return current>3 //filter方法的参数是一个函数，第一个值是当前值，index是当前值的索引，第三个值是当前数组
> })
[ 5, 5, 5 ]
> a
[ 1, 2, 5, 5, 5 ]

6.map
格式化数组，返回值是格式化后的数组

> a
[ 1, 2, 5, 5, 5 ]
> a.map(function(current,index,array){return current*2})
[ 2, 4, 10, 10, 10 ]//被格式化，全部被乘以2
> a
[ 1, 2, 5, 5, 5 ]//原数组没有被改变

1…every
数组项遍历执行every给定的函数，返回值是true和false组成的数组

[ 1, 2, 5, 5, 5 ]
> a.map(function(current,index,array){return current>7})
[ false, false, false, false, false ]
> a
[ 1, 2, 5, 5, 5 ]

8.some
数组项遍历执行some给定的函数，返回值是true或者false

> a
[ 1, 2, 5, 5, 5 ]
> a.some(function(current,index,array){return current>4})
true //只要存在有一项为true，返回值就是true
> a
> > var a = [{name:'tony'},{age:12}]
undefined
> a.some(function(a,b,c){return a.name=="tony"})
true//some也可以遍历对象数组

9.forEach
数组遍历，遍历不能中断

> arr.forEach(function(item){console.log(item)})
1
10
10
8
9
undefined
> arr
[ 1, 10, 10, 8, 9 ]//并没有改变原数组

10.find
找到数组中满足条件的第一个元素，返回值是查找到的元素，否则返回值是undefined

[ 4, 5, 6 ]
> b.find(function(a){return a>4})
5                      

11.findIndex
返回值是第一个满足条件的索引值，否则为-1

[ 4, 5, 6 ]
> b.findIndex(function(a){return a>10})
-1
> b.findIndex(function(a){return a>5})
2       

11.Array.isArray()
判断一个元素是否为数组，返回值是true或者false.

> b
[ 4, 5, 6 ]
> Array.isArray(b)
true

includes,Array.isArray(),some,every---------->返回值是true或者false
concat,slice,map,filter-------->返回值是数组
join-------->返回值是字符串
findIndex,indexOf-------->返回索引值，否则为-1
find--------------->返回查找到的值

收藏起来！