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

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

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

//1. new 操作符后跟構造函數創建Object實例
var person = new Object()
person.name = "nike"
person.age = "25"

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

JavaScript中，數組存儲的是一組有序列表，與其他語言不同的是Js中數組的每一項是可以存儲任何類型的數據。而且Js中數組的大小（長度）是可以動態調整。
創建數組的基本方式有兩種：第一種是通過Array構造函數的方式，第二種是是通過數組字面量的方式進行創建。如下：

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

注意，在使用構造函數創建數組的時候可以省略掉new操作符：

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

再看下數組字面量的方式創建數組：

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

在只用數組字面量的形式創建數組時和對象一樣，也不會調用Array構造函數。

數組中的項數是可以動態改變的，看下下面的例子及說明：

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]"

檢測數組
第一種通過instanceof操作符：

arr instanceof Array

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

Array.isArray(arr)

轉換方法
所有對象都具有 toLocaleString(), toString(), valueOf（）方法。其中調用數組的 toString() 方法會返回由數組中每個值的字符串形式拼接而成的一個由逗號分隔的字符串，而調用valueOf()返回的還是數組。實際上為了創建這個字符串會調用數組每一項的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接受字符串為參數，所有在后臺會調用toString方法

toLocaleString()方法經常也會返回和toString()和valueOf()方法相同的值，當調用數組的toLocaleString()方法時，它會創建一個數組值得以逗號分隔的字符串。而與前兩個方法不同的是它是調用每一項的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()方法可以將組數組合并為一組字符串然后返回。

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

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

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

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

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()方法,會移除數組最后一項，并返回移除項。

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

注意：以上的push()和pop(）方法都會改變原數組的數據結構。

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

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()方法，從數組最前面移除一項，然后返回該項：

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

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

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

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

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

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

操作方法
1. concat()

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

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()它能基于當前數組的一個或者多個項創建一個新數組。slice()可以接受一個或者兩個參數，即要返回項的起始和結束位置，只有一個參數的情況下，slice會返回從該參數指定位置開始到當前數組末尾的所有項。如果是兩個參數，會返回起始位置到結束位置之間的項（不包括結束位置）。注意，slice也不會影響原數組。

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) //[]

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

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

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]

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

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

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

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始終會返回一個數組，該數組包含從原數組中刪除的項，如果沒有刪除則返回一個空數組。

位置方法

數組中位置查找的方法有兩個 indexOf和lastIndexOf() ，這兩個方法都接受兩個參數，要查找的項和查找的起始位置。第二個參數是可選的，如果不傳分別表示從數組的開頭和結束進行查找。這兩個方法會返回查找到的項的位置下標，如果沒有找到的話則返回-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 , 因為是從最后開始查找

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

(1). 第一個迭代方法every()：對數組的每一項運行給定函數，如果該函數對每一項都返回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()方法，對數組的每一項運行給定函數，返回該函數會返回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(),對數組的每一項運行給定函數，沒有返回值。

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

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

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()：對數組的每一項執行函數，如果函數對任意一項返回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

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

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

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() 只不過是從數組的后面開始進行，其他的操作都是一樣的。