摘要：引用類型有時候也被稱為對象定義。類型目前看到大多數(shù)引用類型都是類型的實例。第一種是使用操作符后跟一個構(gòu)造函數(shù)。創(chuàng)建數(shù)組的基本方式有兩種第一種是通過構(gòu)造函數(shù)的方式，第二種是是通過數(shù)組字面量的方式進行創(chuàng)建。

前言
引用類型的值是引用類型的一個實例，引用類型是一種數(shù)據(jù)結(jié)構(gòu)，用于將數(shù)據(jù)和功能組織到一起。它通常被稱為類。引用類型有時候也被稱為對象定義。對象是某個引用類型的實例。新對象是使用new操作符后跟一個構(gòu)造函數(shù)創(chuàng)建（構(gòu)造函數(shù)本身就是一個函數(shù)）。

目前看到大多數(shù)引用類型都是Object類型的實例。object類型在應用程序中存儲和傳輸數(shù)據(jù)而言，是一個理想的選擇。
創(chuàng)建Object實例的方式有兩種。第一種是使用new操作符后跟一個構(gòu)造函數(shù)。第二種是使用對象字面量的形式創(chuàng)建。如下：

//1. new 操作符后跟構(gòu)造函數(shù)創(chuàng)建Object實例
var person = new Object()
person.name = "nike"
person.age = "25"

//2. 對象字面量的形式創(chuàng)建Object實例，在通過對象字面量的方式定義對象時，實際上是不會調(diào)用Object構(gòu)造函數(shù)。
var person = {
    name: "nike",
    age: 29 //注意這里后面不能加逗號了，因為會在IE7和Opera中導致錯誤
}

JavaScript中，數(shù)組存儲的是一組有序列表，與其他語言不同的是Js中數(shù)組的每一項是可以存儲任何類型的數(shù)據(jù)。而且Js中數(shù)組的大?。ㄩL度）是可以動態(tài)調(diào)整。
創(chuàng)建數(shù)組的基本方式有兩種：第一種是通過Array構(gòu)造函數(shù)的方式，第二種是是通過數(shù)組字面量的方式進行創(chuàng)建。如下：

var arr = new Array() //創(chuàng)建了一個空數(shù)組存儲到變量arr中 : []
var arr = new Array(4) //創(chuàng)建了一個數(shù)組長度為5，每個元素為undefined的數(shù)組： [undefined,undefined,undefined,undefined,undefined]
var arr = new Array(1,2,3) //創(chuàng)建一個長度為3，數(shù)組元素分別為1，2，3的數(shù)組：[1,2,3]

注意，在使用構(gòu)造函數(shù)創(chuàng)建數(shù)組的時候可以省略掉new操作符：

var colors = Array(3)
var names = Array("gray")

再看下數(shù)組字面量的方式創(chuàng)建數(shù)組：

var colors = ["red","blue","yellow"]
var arr = []
var value = [1,2,]//這樣可能會創(chuàng)建長度為2或3的數(shù)組，不支持這樣！！
var opt = [,,,,,]//這樣可能會創(chuàng)建長度為5或6的數(shù)組，不支持這樣??！

在只用數(shù)組字面量的形式創(chuàng)建數(shù)組時和對象一樣，也不會調(diào)用Array構(gòu)造函數(shù)。

數(shù)組中的項數(shù)是可以動態(tài)改變的，看下下面的例子及說明：

var arr = [1,2,3]
arr[5] = 5
console.log(arr) //"[1,2,3,undefined,undefined,5]"

var arr = [1,2,3]
arr.length = 2
console.log(arr) // [1, 2]

var arr = [1,2,3]
arr.lenght = 5
console.log(arr) //"[1,2,3,undefined,undefined,undefined]"

檢測數(shù)組
第一種通過instanceof操作符：

arr instanceof Array

第二種通過 Array.isArray()方法，這個方法最終確定某個值到底是不是數(shù)組，而不管它是在哪個全局環(huán)境中創(chuàng)建的。

Array.isArray(arr)

轉(zhuǎn)換方法
所有對象都具有 toLocaleString(), toString(), valueOf（）方法。其中調(diào)用數(shù)組的 toString() 方法會返回由數(shù)組中每個值的字符串形式拼接而成的一個由逗號分隔的字符串，而調(diào)用valueOf()返回的還是數(shù)組。實際上為了創(chuàng)建這個字符串會調(diào)用數(shù)組每一項的toString()方法。

var colors = ["red", "blue", "green"]

console.log(colors.toString()) //"red, blue, green"
console.log(colors.valueOf()) //["red", "blue", "green"]
console.log(colors) //["red", "blue", "green"]
alert(colors)// alert接受字符串為參數(shù)，所有在后臺會調(diào)用toString方法

toLocaleString()方法經(jīng)常也會返回和toString()和valueOf()方法相同的值，當調(diào)用數(shù)組的toLocaleString()方法時，它會創(chuàng)建一個數(shù)組值得以逗號分隔的字符串。而與前兩個方法不同的是它是調(diào)用每一項的toLocaleString()方法，而不是toString方法。

var person1 = {
    toLocaleString: function(){ return "nike"},
    toString: function () {return "lining"}
}
var person2 = {
    toLocaleString: function(){ return "apple"},
    toString: function () {return "orange"}
}
var arr = [person1, person2]

alert(arr) // "lining, orange"
alert(arr.toString()) "lining, orange"
alert(arr.toLocaleString()) //"nike, apple"

join()方法可以將組數(shù)組合并為一組字符串然后返回。

var arr = [1,2,3]
var a = arr.join() //"1,2,3"
var b = arr.join("|") // "1|2|3"

注意：如果數(shù)組中某一項是null或者undefined，那么該值在join(),toLocaleString(), toString()和valueOf()方法返回的結(jié)果中用空字符串表示。

棧方法
push(), pop()分別是在數(shù)組最后添加元素和從末尾移除最后一項，然后修改數(shù)組的長度。

首先看下push()方法,可以從數(shù)組后推入任意項，且可以為任意數(shù)據(jù)類型。

var arr = [1,2,3,4]
var res = arr.push(5)
console.log(arr) //[1,2,3,4,5]
console.log(res) // 5

var arr2 = [1,2,3]
var res = arr2.push(4,5)
console.log(arr2) // [1,2,3,4,5]
console.log(res) // 5

var arr3 = [1,2,3]
var res = arr3.push([1,2])
console.log(arr3) // [1,2,3, [1,2]]
console.log(res) // 4

在看下pop()方法,會移除數(shù)組最后一項，并返回移除項。

var arr = [1,2,3,4,5]
var res = arr.pop() //5

注意：以上的push()和pop(）方法都會改變原數(shù)組的數(shù)據(jù)結(jié)構(gòu)。

隊列方法
數(shù)組的隊列方法有shift()和unshift()。shift(）方法是從數(shù)組前端移除一項并返回該項。unshift()是在數(shù)組前端添加任意項，并返回數(shù)組長度。

var arr = [1,2,3,4]
var res = arr.unshift(1)
console.log(arr) // [1,1,2,3,4]
console.log(res) // 5

var arr1 = [1,2,3,4]
var res = arr.unshift(1,2)
console.log(arr1) //[1,2,1,2,3,4]
console.log(res) //6

var arr2 = [1,2,3]
var res = arr2.unshift([1,2])
console.log(arr2) //[[1,2], 1, 2, 3]
console.log(res) // 4

再看下shift()方法，從數(shù)組最前面移除一項，然后返回該項：

var arr = [1,2,3,4]
var res = arr.shift()
console.log(arr) //[2,3,4]
console.log(res) // 1

重排序方法
數(shù)組中有兩個排序方法reverse()和sort()。reverse()是反轉(zhuǎn)數(shù)組項的順序，會改變原數(shù)組。

var arr = [1,2,3,4]
arr.reverse() //[4,3,2,1]
console.log(arr) //[4,3,2,1]

sort()方法默認是按照升序排列數(shù)組項，sort方法會調(diào)用每一項的toString方法，然后比較得到的字符串，以確定如何排序。

var val = [0,1,5,10,15]
val.sort()
console.log(val) //[0,1,10,15,5]

然而，sort可以接受一個比較函數(shù)作為參數(shù)，以便指定哪個值位于哪個值前面或者后面，比較函數(shù)接受兩個參數(shù)，如果第一個參數(shù)應該位于第二個之前則返回一個負數(shù)，如果兩個參數(shù)相等則返回0，如果第一個參數(shù)位于第二個參數(shù)后，則返回正數(shù)。

操作方法
1. concat()

關(guān)于數(shù)組的操作方法有很多，除了上面說的幾個方法外，這里要介紹一些常用的方法。
首先看下 concat() 這個方法，該方法會基于當前數(shù)組的所有項再創(chuàng)建一個新的數(shù)組，具體的說就是該方法會創(chuàng)建一個當前數(shù)組副本，然后將接受到的數(shù)據(jù)添加到這個副本末尾，最后返回新的數(shù)組。在沒有個concat方法傳參數(shù)的情況下，它只是復制當前數(shù)組并返回副本，如果傳遞給concat方法的是一個或者多個數(shù)組，則該方法是將這些數(shù)組中的每一項都添加到結(jié)果數(shù)組中，如果傳遞的不是數(shù)組，這些值就會簡單的被添加到數(shù)組末尾。

var arr= [1,2,3,4]
var arr2 = arr.concat("yellow", ["blue", "red"])
console.log(arr) //[1,2,3,4]
console.log(arr2) //[1,2,3,4,"yellow", "blue", "red"]

2. slice()
再看下第二個方法slice()它能基于當前數(shù)組的一個或者多個項創(chuàng)建一個新數(shù)組。slice()可以接受一個或者兩個參數(shù)，即要返回項的起始和結(jié)束位置，只有一個參數(shù)的情況下，slice會返回從該參數(shù)指定位置開始到當前數(shù)組末尾的所有項。如果是兩個參數(shù)，會返回起始位置到結(jié)束位置之間的項（不包括結(jié)束位置）。注意，slice也不會影響原數(shù)組。

var arr = [1,2,3,4,5,6,7]
var res1 = arr.slice(1) //[2,3,4,5,6,7]
var res2 = arr.slice(1,4)//[2,3,4]

看下幾個特殊情況：

var arr = [1,2,3,4,5,6]
var res1 = arr.slice(-3) //[4,5,6]
var res2 = arr.slice(-6, -3) //[1,2,3]
var res3 = arr.slice(4, 3) //[]

如上，如果傳的是負數(shù)的話是從后往前數(shù)，如果第二個參數(shù)比第一個小的話則返回空數(shù)組。

3. splice()
這個方法可以對數(shù)組進行刪除，插入，替換操作。注意該方法會改變原數(shù)組
首先看下刪除功能：

var arr = [1,2,3,4,5]
var res = arr.splice(0, 2) //從下標0開始刪除2個元素
console.log(arr) //[3,4,5]
console.log(res) //[1,2]

再看下插入功能, 可以向指定位置插入任意數(shù)量的項：

var arr = [1, 2, 3, 4, 5]
var res = arr.splice(0, 0, 1,2,3) //可以插入多個和單個數(shù)據(jù)
console.log(arr) //[1,2,3,1,2,3,4,5]
console.log(res) //[],返回的是一個空數(shù)組

接下來再看下替換功能了，相信大家也知道該怎么去操作了：

var arr = [1,2,3,4,5]
var res = arr.splice(0, 3, "a","b","c")
console.log(arr) //["a", "b", "c", 4, 5]
console.log(res) //[1, 2, 3]

splice始終會返回一個數(shù)組，該數(shù)組包含從原數(shù)組中刪除的項，如果沒有刪除則返回一個空數(shù)組。

位置方法

數(shù)組中位置查找的方法有兩個 indexOf和lastIndexOf() ，這兩個方法都接受兩個參數(shù)，要查找的項和查找的起始位置。第二個參數(shù)是可選的，如果不傳分別表示從數(shù)組的開頭和結(jié)束進行查找。這兩個方法會返回查找到的項的位置下標，如果沒有找到的話則返回-1，在查找的時候會使用嚴格等于進行查找（===）。

var arr = [1,2,3,4,5]
console.log(arr.indexOf(1)) //返回0
console.log(arr.indexOf("1")) //返回-1， 因為是基于嚴格等于的。

var arr = [1, 2, 3, 4, 5, 1]
arr.lastIndexOf(1) // 5 , 因為是從最后開始查找

迭代方法
數(shù)組的迭代方法有5種，每個方法都接受兩個參數(shù)：要在每一項上運行的函數(shù)和運行該函數(shù)的作用于對象(可選，影響this的值)。在每項上運行的函數(shù)可以接受三個參數(shù)：數(shù)組的每一項，當前項的下標，數(shù)組對象本身。

(1). 第一個迭代方法every()：對數(shù)組的每一項運行給定函數(shù)，如果該函數(shù)對每一項都返回true，則返回true

var arr = [1, 2, 3, 4, 5]
var res = arr.every(function(item, index, array) {
    if(item == 1 || item == 2) {
        return true
    }else {
        return false
    }
})
console.log(res) //false

var arr = [1, 2, 3, 4, 5]
var res = arr.every(function(item, index, array) {
    return true
})
console.log(res) //true

(2). 第二個迭代filter()方法，對數(shù)組的每一項運行給定函數(shù)，返回該函數(shù)會返回true的項。

var arr = [1, 2, 3, 4, 5]
var res = arr.filter(function(item, index, array){
    if(item == 1 || item == 3 || item == 5){
        return true
    }
})
console.log(res) //[1, 3, 5]

(3). 第三個迭代方法forEach(),對數(shù)組的每一項運行給定函數(shù)，沒有返回值。

var arr = [1, 2, 3, 4, 5]
var res = arr.forEach(function(item, index, array) {
    return item+1
})
console.log(res) //undefined

(4). 第四個迭代方法map()：對數(shù)組的每一項運行函數(shù)，返回函數(shù)每次調(diào)用的結(jié)果組成的數(shù)組。

var arr = [1, 2, 3, 4, 5, 6]
var res = arr.map(funtion(item, index, array) {
    return item + "元"
})
console.log(res) // ["1元", "2元", "3元", "4元", "5元", "6元"]

(5). 第五個迭代方法some()：對數(shù)組的每一項執(zhí)行函數(shù)，如果函數(shù)對任意一項返回true則返回true。

var arr = [1,2,3,4,5,6]
var res = arr.some(function(item, index, array){
    if(item > 3) {
        return true
    }else {
        return false
    }
})
console.log(res) //true

歸并方法
這里還有兩個歸并數(shù)組的方法：reduce() 和reduceRight() ，這兩個方法會迭代數(shù)組中所有的項，然后返回一個最終的值。其中reduce()方法從數(shù)組的第一項開始遍歷直到數(shù)組的最后一項。而reduceRight() 則是從數(shù)組最后面開始遍歷到第一項。

這兩個方法都有兩個參數(shù)：在每一項上調(diào)用的函數(shù)和作為歸并基礎的初始值。然后在每一項上都會執(zhí)行的函數(shù)會接受到四個參數(shù)：前一個值，當前值，項的索引，數(shù)組對象。這個函數(shù)返回的任何值都會作為第一個參數(shù)自動傳給下一項。第一次迭代發(fā)生做數(shù)組的第2項上，所以第一個參數(shù)是數(shù)組的第一項，第二個參數(shù)就是數(shù)組的第二項。

var arr = [1, 2, 3, 4, 5]f
var sun = arr.reduce(function(pre, next, index, arr) {
    return pre+next
})
console.log(sun) //15

reduceRight() 只不過是從數(shù)組的后面開始進行，其他的操作都是一樣的。