数组对象

数组对象

与普通对象功能类似，也是用来存储一些值的。

不同之处在于，普通对象以字符串作为属性名，而数组使用（下标）索引来操作元素。

索引：从零开始的整数。

一个索引来对应一个值，这叫一个元素。

数组存储性能比对象好，因此在开发中经常使用。

创建数组对象

let arr = new Array()
console.log(arr) // []

向数组添加元素
arr[0] = 'hello'  // console.log(arr1[0])  hello ---> string

如果读取不存在的下标，不会报错，而是会返回undefined，就像的确不存在的对象属性也不会报错，也会报undefined一样。

数组长度：

数组.length  // arr.length

若是不连续的数组，length会获取最大的索引+1。
arr[0]="1"
arr[1]="2"
arr[10]="3"  

尽量不要创建非连续数组。

修改数组length 属性，若修改length大于原长度，多出的会显示empty;
let arr = [1,3,5]
console.log(arr.length = 4, arr)   // 4 [1, 3, 5, empty]

若修改的length小于原长度，值保留对应长度的，多余的会被删除。因此可用length来删除一些元素

向数组最后位置添加一个元素

arr[arr.length] = "70"  

为什么使用arr.length可以向最后的位置添加？length是最大的索引（index） + 1，所以 arr.length 意为最大的索引 + 1,也就是增加一项。（下一位索引）

数组字面量

语法 ： let arr = []

与 let arr = new Array()一样，但字面量创建的更加简单！

向数组arr.hello = "123" 是完全正确的，但这样没有任何意义，数组最大的特点便是下标（索引）。

使用数组字面量的方式创建数组，可以在创建时就指定数组中的元素。  let arr = [1, 2, ,3, 4]

使用构造函数创建函数
let arr3 = new Array(10, 20, 30)
console.log(arr3) // [10, 20, 30]

不同：
arr = [10] // 创建一个数组，里面只有一个元素（10）

arr4 = new Array(10) // 创建一个长度为10 的数组

数组中的元素可以是任意数据类型，亦可以是对象。

例如： let obj = {name : "wind"}
    
     let arr5 = []
     console.log('length----->',arr5.length) // 0
     arr5[arr5.length] = obj
     console.log(arr5) // [{...}]
     console.log(arr5.length)  // 1

也可以是函数：

     let arr7 = [function(){alert('11111')}]
    
     arr7[0]() // 调用

亦可以是数组 ：

     let arr9 = [[4, 8, 10], [2, 5, 6]]
     console.log(arr9[0])  //  [4, 8, 10]

数组四方法

push ：向数组的末尾添加一个或多个元素，并返回数组新长度。返回值为数组新长度。

pop ： 删除数组最后一个元素，返回值是被删除元素。

Unshift ：向数组开头添加一个或多个元素并返回新的长度，插入元素，后面的元素索引依次调整。

shift ：删除数组第一个元素，将被删除元素作为返回值。

数组遍历

遍历就是将数组中所有元素取出来。

    let arr10 = [1, 2, 4, 5, 7, 8]
    
    for(let i = 0; i < arr10.length ; i++){
        console.log('item----->',arr10[i])
    }

数组遍历之forEach:

forEach 以一个函数为参数，它的参数就是回调函数，回调函数我们并没有调，而是浏览器调了。

arr.forEach( function(){console.log('111')})
数组有几个元素，函数就会执行几次，每次执行浏览器会将遍历的元素以实参形式传递进来。

浏览器向该回调函数传递了三个参数：

第一个参数为数组的每一项，第二个参数为每一项的下标，第三个参数为正在遍历的数组。

arr10.forEach(function(item,index,c){
        console.log('1111',item,index,c)
})

实参列表.html:55 1111 1 0 (6) [1, 2, 4, 5, 7, 8]
实参列表.html:55 1111 2 1 (6) [1, 2, 4, 5, 7, 8]
实参列表.html:55 1111 4 2 (6) [1, 2, 4, 5, 7, 8]
实参列表.html:55 1111 5 3 (6) [1, 2, 4, 5, 7, 8]
实参列表.html:55 1111 7 4 (6) [1, 2, 4, 5, 7, 8]
实参列表.html:55 1111 8 5 (6) [1, 2, 4, 5, 7, 8]

数组方法slice,splice

slice 

包含两个参数，
第一个参数为开始下标（包括开始索引），第二个参数为结束下标（不包括结束索引）。

只写一个参数，会截取以开始到后面所有的。

slice不会影响原数组。

如果传递一个负值，则从后往前计算。

splice

会影响原数组，会将指定元素从数组删除，并将被删除元素作为返回值返回。

包含三个参数，

第一个参数表示开始位置索引，

第二个参数表示删除数量，

第三个参数可传递一些新元素，会自动插入开始位置前。

数组去重

待续。。。

数组其他方法

concat

合并数组，concat()中除可以传数组，也可以传单个元素。

arr1.concat(arr2, "牛恒")

join

将数组所有元素放入字符串，不会影响原数组，而是将转换的字符串作为结果返回。

join()括号中可指定一个字符作为元素的连接符。


reverse

反转数组

sort

对数组进行排序，会影响原数组。按unicode编码进行排序，小的在前，大的在后，abc在前，efd在后。

排序数字：

排序数字也是按照unicode编码排序，但可能得到错误的结果
arr = [3, 4, 11 5, 7]
arr.sort() // [11, 3, 4, 5, 7]

指定排序规则

可在sort中添加一个回调函数，浏览器会分别使用数组中的元素作为实参去调用回调函数。

arr = [5, 4, 3]

arr.sort(function(){
    console.log("a = " + a)
    console.log("b = " + b)
})

/**
得到：
 "a = 5"
 "b = 4"
 "a = 4"
 "b = 3"
*/

使用哪个元素调用不太确定，但确定的是,在数组中a一定在b的前面。

浏览器会根据函数的返回值来决定元素的顺序。
若返回一个大于0的值，则元素交换位置。
若返回一个小于0的值，则元素位置不变。
若返回一个0，则认为两元素相等，也不交换位置。

let arr = [4, 1, 3, 8, 2]
arr.sort(function(a, b){
    if(a > b){
        return 1
    }else if(a < b){
        return -1
    }else{
        return 0
    }
})

简写 ：

升序 return a - b

降序 retun b - a