數(shù)組是有序的集合，有序很重要，逗號(hào)隔開，逗號(hào)很重要。每一個(gè)值叫元素，而每個(gè)元素在數(shù)組中有一個(gè)位置，以數(shù)字表示（關(guān)聯(lián)數(shù)組除外），稱為索引。數(shù)組是無類型的，數(shù)組元素可以是任意類型，包括數(shù)組自身，數(shù)組可以創(chuàng)建極其復(fù)雜的結(jié)構(gòu)。

數(shù)組第一個(gè)元素的索引是0，最大可能的索引為4 294 967 294 （2的32次方-2），有看過我入門ES6文章的小伙伴應(yīng)該知道，JavaScript中最大的整數(shù)是2的53次方，稱之為最大的安全整數(shù)，再往上就取不到了，但是由于外國人是喜歡從0開始，所以2的53次方-1是邊界

其實(shí)本來想寫函數(shù)的，但是函數(shù)深入起來太難，之后編寫底層機(jī)制的時(shí)候再深入，本期數(shù)組也是快速過

創(chuàng)建數(shù)組

字面量就不解釋了，簡(jiǎn)單介紹構(gòu)造函數(shù)形式

var a = new Array() == var a=[]

如果我們傳入一個(gè)參數(shù)數(shù)字

var a = new Array(5) == var a=[,,,,,] 
console.log(a) // [empty*5]  空的*5
console.log(a[0]) // undefined  如果省略數(shù)組的值，省略的元素將賦予undefined 不是null

如何判斷數(shù)組為空，可能之前小伙伴寫多了value為空，對(duì)象為空，這邊也是做個(gè)提醒

  var a=null
  var b=undefined
  var c=""
  var d=[]
  var e=[]
  var f=[]
  d.push(a)
  e.push(b)
  f.push(c)
  console.log(d,d.length,d[0])
  console.log(e,e.length,e[0])
  console.log(f,f.length,f[0])   

很明顯都是有值的，因?yàn)閿?shù)組可以存儲(chǔ)所有類型，如何判斷數(shù)組為空呢

  var a=null
  var b=undefined
  var c=""
  var d=[]
  var e=[]
  var f=[]
  d.push(a)
  e.push(b)
  f.push(c)
  d.length=0
  e.length=0
  f.length=0
  console.log(d,d.length,d[0])
  console.log(e,e.length,e[0])
  console.log(f,f.length,f[0])  

改變數(shù)組長度為0即可，寫邏輯判斷的時(shí)候注意一下

對(duì)了，剛才有個(gè)錯(cuò)誤，就是前面創(chuàng)建

 var a = new Array(5) == var a=[,,,,,] 

這里是不等價(jià)的，結(jié)果相同結(jié)構(gòu)不同，使用構(gòu)造函數(shù)定義的數(shù)組，如果只是傳入一個(gè)數(shù)字相當(dāng)于用來預(yù)分配了一個(gè)數(shù)組空間，沒有存儲(chǔ)值沒有索引也就是說沒有a[index]這種寫法，但是右邊的存在索引寫法，注意一下

其實(shí)數(shù)組很多博客都有介紹比我詳細(xì)的多，我主要就寫一些比較冷門的數(shù)組知識(shí)，數(shù)組方法也過一遍，然后數(shù)組排序以及數(shù)組去重寫幾個(gè)方法

稀疏數(shù)組

稀疏數(shù)組就是包含從0開始的不連續(xù)索引數(shù)組。通常，數(shù)組的length屬性值代表數(shù)組中元素的個(gè)數(shù)，如果數(shù)組是稀疏的，length大于元素個(gè)數(shù)?？梢允褂肁rray（）構(gòu)造函數(shù)或簡(jiǎn)單地指定數(shù)組的索引值 大于當(dāng)前的數(shù)組長度創(chuàng)建稀疏數(shù)組

        a=new Array(5) //數(shù)組沒有元素，但是a.length=5
        a=[] //創(chuàng)建一個(gè)空數(shù)組，length=0
        a[1000]=0 //賦值添加一個(gè)元素，但是length為1001

在數(shù)組字面量創(chuàng)建的時(shí)候如果省略值不會(huì)創(chuàng)建稀疏數(shù)組。剛才提過省略的數(shù)組是存在值的，因此索引是存在的?？梢允褂胕n區(qū)別一下，但這里有個(gè)誤區(qū)我們要排排

    const a1 = [undefined, undefined, undefined];
    const a2 = [, , ,];

    a1.length  // 3
    a2.length  // 3

    a1[0]  // undefined
    a2[0]  // undefined

    a1[0] === a2[0]  // true

所以為什么我們說未定義數(shù)組內(nèi)容的時(shí)候，其實(shí)是有值并且值就是undefined，因?yàn)樗鼈兪侨鹊那闆r，但是看這種情況

    var a=[,undefined]
    console.log(0 in a,1 in a) // false true  

第一個(gè)索引0 沒有值（false） 第二個(gè)索引 1 有值（true）， a=new Array(5)這種就不用測(cè)了，都是false
那么小伙伴要注意一下這種情況，畢竟布爾值判斷條件指不定就被誤區(qū)給搞砸了，不過我們一般都是操作非稀疏數(shù)組的

我們之前聊對(duì)象的時(shí)候說過，所有的對(duì)象都是關(guān)聯(lián)數(shù)組，所以數(shù)組也可以使用對(duì)象方法，簡(jiǎn)單用一下

   var arr=[1,2,3]
   Object.defineProperty(arr,'length',{writable:false}) //設(shè)置不可操作length
   arr.length=0;
   console.log(arr) // 123  

直接凍結(jié)就很刺激了

直接操作數(shù)組方法好了，其實(shí)很多時(shí)候我們都在操作數(shù)組方法而已

length屬性很強(qiáng)大，清空設(shè)置為0，刪除后面元素減少length，靈活運(yùn)用大大提高了開發(fā)效率

console.log(Array.prototype) 查看數(shù)組方法

以下方法不按順序，想到什么寫什么

join 轉(zhuǎn)字符串

Array.join（ ）返回最后生成的字符串，返回什么很重要

    var a=[1,2,3]
    var str=a.join() //括號(hào)內(nèi)的參數(shù)代表字符串直接的分隔符，默認(rèn)是逗號(hào)
    var strs=a.join('')
    var strss=a.join(' ')
    var strsss=a.join('-')
    console.log(str,strs,strss,strsss) //"1,2,3" "123" "1 2 3"  "1-2-3"

該方法在開發(fā)比較常用，字符串?dāng)?shù)組互相轉(zhuǎn)換，也有簡(jiǎn)單粗暴直接toString（），多維數(shù)組都遭不住直接變字符串，如果面試有這種題，多維數(shù)組轉(zhuǎn)一維數(shù)組，直接toString 然后split即可（我在想待會(huì)要不要找?guī)椎烂嬖囶}耍耍）

reverse 倒轉(zhuǎn)

Array.reverse（）返回逆序的數(shù)組，這個(gè)數(shù)組它的引用并沒有改變，在原數(shù)組的基礎(chǔ)上進(jìn)行操作

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

sort 排序

Array.sort（）方法將數(shù)組中的元素排序并返回排序后的數(shù)組 ，該方法有一些坑

    var arr=['a','b','z',undefined,'y']
    arr.sort()
    console.log(arr) // a b y z undefined  

首先sort只針對(duì)值的第一個(gè)字母操作，并且如果有值是undefined 直接排最后

   var arr=[11,2,3,4,5]
   arr.sort()
   console.log(arr) // 11 2 3 4 5

這種情況肯定不是我們想要的，所以我們都會(huì)在sort中傳個(gè)參數(shù)規(guī)定一下
函數(shù)是可以當(dāng)成參數(shù)的，每個(gè)函數(shù)的返回結(jié)果都是return后面的內(nèi)容，函數(shù)的結(jié)果只與return有關(guān)

   var arr=[11,2,3,4,5]
   arr.sort(function(a,b){
       return a-b
   })
   console.log(arr) // 2 3 4 5 11

為什么return一個(gè)a-b就是升序了呢，反過來b-a就是降序呢

拋開原理不講，給一個(gè)記憶方法。兩個(gè)參數(shù)a，b 如果返回前一個(gè)減后面一個(gè)就是升序，相當(dāng)于a b c層級(jí)上升，那反過來就是降，那我是這么記的

為什么a-b是升，如果 a<b,那么a-b就<=-1，也就是return 一個(gè) -1做判斷，若返回值>-1 && <1，則表示 a 和 b 具有相同的排序順序。若返回值>=1，則表示 a 在排序后的序列中出現(xiàn)在 b 之后。假設(shè)a>b ，return a-b>=1，那么排序就是b,a，為升序；反之return b-a<=-1，那么排序就是a,b，為降序,也就是說它會(huì)根據(jù)負(fù)數(shù)、0、正數(shù)相應(yīng)順序返回，理解的不了的還是記上方的內(nèi)容 ，而且如果是字符串機(jī)制就多了一步，這里使用匿名函數(shù)非常方便，既然只使用一次就沒必要命名了

var arr=['and','Bug','Dog','cat']
arr.sort()
console.log(arr) //["Bug", "Dog", "and", "cat"]

其實(shí)沒毛病，不過這不是我們想要的

在字符串中，字符串的比較是從左邊開始依次比較，跟長度無關(guān)，一旦比出大小就結(jié)束比較，比較依據(jù)就是Unicode編碼，它是ASCII和Latin-1的超集，并支持地球上幾乎所有在使用的語言，什么阿拉伯啊，什么數(shù)學(xué)公式啊都支持

這里我們番外一下啊，比如我們自定義一個(gè)字符串文字，看看它的編碼以及編碼值

    var a='中'
    var code=a.charCodeAt()//編碼值
    console.log("\\u"+code.toString(16))   //因?yàn)閁nicode的編碼值格式都是有加\u的,這里為什么多加一個(gè)\呢，
    //因?yàn)橹挥幸粋€(gè)\代表引用，如果想引用'\'就必須在 \前面再加一個(gè)\ 看過我正則的應(yīng)該不難理解哈

    console.log(String.fromCharCode(code))  //這里就是轉(zhuǎn)換為字符串

    for(var i=0;i<100;i++){
        console.log(String.fromCharCode(i))  //小伙伴可以自行打印看看 我這里只取了前100個(gè)  
    }

言歸正傳，字符串比較的其實(shí)就是Unicode編碼，像剛才數(shù)組怎么排序呢，其實(shí)很簡(jiǎn)單

var arr=['and','Bug','Dog','cat']
arr.sort(function(a,b){
    var s=a.toLowerCase()
    var t=b.toLowerCase()    //都轉(zhuǎn)換大小寫比較
    if(s<t){    //注意只能比大小，字符串沒辦法相減，數(shù)字字符串除外
        return -1
    }
    if(s>t){
        return 1
    }
})
console.log(arr)  //(4) ["and", "Bug", "cat", "Dog"]

sort有點(diǎn)啰嗦了，看下一個(gè)

concat

Array.concat（）創(chuàng)建并返回一個(gè)新數(shù)組，注意是新數(shù)組

    var a=[1,2,3]
    a.concat(4,5)             // [1 2 3 4 5]
    a.concat([4,5])           //[1 2 3 4 5]
    a.concat([4,5],[6,7])     // [1 2 3 4 5 6 7]
    a.concat(4,[5,[6,7]])     // [1 2 3 4 5 [6 7]]

需要注意的是，如果參數(shù)是數(shù)組，連接的是數(shù)組的元素而非數(shù)組本身。其次concat不會(huì)遞歸扁平化數(shù)組

slice

Array.slice（）方法基于當(dāng)前數(shù)組中的一個(gè)或多個(gè)項(xiàng)創(chuàng)建一個(gè)新數(shù)組，接受一個(gè)或兩個(gè)參數(shù)，最后返回新數(shù)組slice(start,end)方法需要兩個(gè)參數(shù)start和end，返回這個(gè)數(shù)組中從start位置到(但不包含)end位置的一個(gè)子數(shù)組。左閉右開，就是左邊是有等于的而右邊沒有

如果end為undefined或不存在，則返回從start位置到數(shù)組結(jié)尾的所有項(xiàng)
如果沒有參數(shù)，則返回原數(shù)組
start和end無法交換位置
如果start是負(fù)數(shù)，則start = max(length + start,0)，也可以理解倒數(shù)第幾個(gè)索引位置
如果end是負(fù)數(shù)，則end = max(length + end,0)，也可以理解倒數(shù)第幾個(gè)索引位置
如果不提供參數(shù)，slice()方法返回當(dāng)前數(shù)組的一個(gè)淺拷貝

    var a=[1,2,3,4,5]
    a.slice(0,3) // 1 2 3
    a.slice(3)  // 4 5
    a.slice(1,-1) // 2 3 4 end是負(fù)數(shù) 其實(shí)end此時(shí)等于5 + -1 = 4  或者 end是倒數(shù)第一個(gè)索引位置也就是 4
    a.slice(-3,-2) //3  此時(shí)其實(shí)是 5 + -3 = 2  5 + -2 = 3      倒數(shù)第三個(gè)數(shù)3 索引 2   倒數(shù)第二個(gè)數(shù)字4 索引 3

看自己習(xí)慣記憶負(fù)數(shù)

splice（）

Array.splice（）可以從數(shù)組中刪除插入替換元素，最強(qiáng)大的數(shù)組方法。與上一個(gè)slice看起來相似，slice不改變?cè)瓟?shù)組而splice改變?cè)瓟?shù)組

splice（）第一個(gè)參數(shù)指定了插入和（或）刪除的起始位置，第二個(gè)參數(shù)指定了應(yīng)該從數(shù)組中 刪除元素的個(gè)數(shù)。如果省略第二個(gè)參數(shù)，從起點(diǎn)到結(jié)尾的元素都將刪除，splice返回一個(gè)由刪除元素組成的數(shù)組，或者如果沒有刪除元素就返回一個(gè)空數(shù)組，注意它會(huì)改變?cè)瓟?shù)組

    var a=[1,2,3,4,5,6,7,8]
    a.splice(4) //返回[5,6,7,8] a變成[1,2,3,4]  
    a.splice(1,2) //返回[2,3] a是[1,4] 因?yàn)闀?huì)改變?cè)瓟?shù)組 所以此時(shí)的a是[1,2,3,4]
    a.splice(1,1) //返回[4] a是[1]

注意第二個(gè)參數(shù)是個(gè)數(shù)，不是索引，splice也是支持左閉右開的原則
如果我們只操作刪除數(shù)組，調(diào)用前兩參數(shù)即可，我們來看看插入與替換

    var a=[1,2,3,4,5,6,7,8]
    a.splice(1,2,'a','b')
    console.log(a) // [1, "a", "b", 4, 5, 6, 7, 8]  最簡(jiǎn)單的替換，刪幾個(gè) 插幾個(gè)

    var a=[1,2,3,4,5,6,7,8]
    a.splice(1,0,'a','b')
    console.log(a) // [1, "a", "b", 2,3，4, 5, 6, 7, 8] 最簡(jiǎn)單的插入

push（）和 pop（）

push（）和pop（）允許數(shù)組當(dāng)做棧來使用，push（）在數(shù)組尾部添加一個(gè)或多個(gè)元素，并返回?cái)?shù)組新的長度，注意返回的是長度。pop（）方法則相反，刪除數(shù)組最后一個(gè)元素并返回刪除的值。雖然改變?cè)瓟?shù)組但返回的值一定要注意一下

簡(jiǎn)單的方法我就快速過了哈

    var a=[1,2]
    a.push(3) //3  a[1,2,3]
    a.push([4,5]) // 4  a[1,2,3,[4,5]] 傳的數(shù)組算一項(xiàng)
    a.pop() // [4,5] a[1,2,3]

返回什么很重要

unshift（）和 shift（）

unshift（）和shift（）的方法類似push（）和pop（），unshift（）在數(shù)組頭部添加一個(gè)或多個(gè)元素，并將已存在的元素移動(dòng)到更高索引位置，最后返回?cái)?shù)組長度。shift（）刪除數(shù)組的第一個(gè)元素并返回該元素

找了一個(gè)例子偷懶 很舒服

ES5中數(shù)組增加了些許方法，我也為大家整理一下

位置方法----indexOf() lastIndexOf()

兩者方法都是尋找數(shù)組中的元素，返回找到的第一個(gè)元素的索引或者沒找到返回-1。indexOf（）從頭至尾搜索，lastIndexOf（）反向搜索

  a=[0,1,2,1,0]
  a.indexOf(1) // 1  正開始數(shù) 第1個(gè)索引就找到
  a.lastIndexOf(1) //3 從后面開始數(shù)，第三個(gè)索引才找到
  a.indexOf(3) //-1 找不著

迭代方法

首先迭代方法的參數(shù)有兩個(gè)，第一個(gè)參數(shù)是一個(gè)函數(shù)，函數(shù)里面有三個(gè)參數(shù)，分別是value值，index索引，arr數(shù)組本身，第二個(gè)參數(shù)是this指向 待會(huì)看forEach（）方法演示

every( )

every()對(duì)數(shù)組中的每一項(xiàng)運(yùn)行給定函數(shù)，如果該函數(shù)對(duì)每一項(xiàng)都返回 true ，則返回 true 。 類似于&&符號(hào)

    var arr=[100,200,300,400,500];
    var result=arr.every(function(v){
        return v>=100;
    });
    console.log(result);  //true 全部滿足才為true 

some（）

some（）就很隨便了，其中一項(xiàng)滿足就是true

    var arr=[100,200,300,400,500];
    var result=arr.some(function(v){
        return v>=500;
    });
    
    console.log(result)  //true

filter（）

filter（）方法，過濾操作，返回滿足條件的值

    var arr=[100,200,300,400,500];
    var result=arr.filter(function(v){
        return v>100;
    });
    console.log(result);// [200, 300, 400, 500]

map（）

map()對(duì)數(shù)組中的每一項(xiàng)運(yùn)行給定函數(shù)，返回每次函數(shù)調(diào)用的結(jié)果組成的數(shù)組。返回就是數(shù)組，不考慮true或者false；

    var arr=[100,200,300,400,500];
    var result=arr.map(function(v){
        return v+=v*0.3;
    });
    console.log(result);//[130, 260, 390, 520, 650] 

forEach（）

forEach() ：對(duì)數(shù)組中的每一項(xiàng)運(yùn)行給定函數(shù)。這個(gè)方法沒有返回值。

    var arr=[100,200,300,400,500];
    arr.forEach(function(a,b,c){//第一個(gè)參數(shù)：是函數(shù)，里面又有三個(gè)參數(shù),參1：數(shù)組項(xiàng)的值  參2：索引   參3：數(shù)組本身
        //alert(this);//hehe
        console.log(a+'-----'+b+'-----'+c); //可以自行打印看看
    },'hehe');//第二個(gè)參數(shù)使用來改變this指向的

歸并方法，一個(gè)是reduce（）和reduceRight（），這個(gè)表示用的很少，我?guī)缀鯖]用過，有興趣可以自行了解詳細(xì)的介紹，可能是我太菜了

數(shù)組去重

數(shù)組去重有很多方法，百度上也有很多，我寫一個(gè)最原理的方法解析方便記憶，有興趣的可以自行查找一下，并不是我懶得寫，而是......好吧我就是懶，不過掌握好了原理就很簡(jiǎn)單

    var arr=[1,2,1,2,4,5,3,2,1,4,5,7,8] //待去重?cái)?shù)組
    var newarr=[] //空數(shù)組
    for(var i=0;i<arr.length;i++){
        if(newarr.indexOf(arr[i])==-1){ //如果空數(shù)組中沒有去重?cái)?shù)組里面的內(nèi)容，也就是找不到為-1
            newarr.push(arr[i]) //把沒有的內(nèi)容添加到空數(shù)組中
        }
    }
    console.log(newarr) //[1, 2, 4, 5, 3, 7, 8]

    var arr=[1,2,1,2,4,5,3,2,1,4,5,7,8]
    var newarr=[]
    for(var i=0;i<arr.length;i++){
        for(var j=i+1;j<arr.length;j++){
            if(arr[i]==arr[j]){  //如果找到相同的
                i++;  //結(jié)束當(dāng)前循環(huán)，回到頂部開始下一次循環(huán)
                j=i   //將++后的i賦值給 j
            }
        }
        newarr.push(arr[i]) // 如果沒找到相同的  就添加到空數(shù)組中
    }
    console.log(newarr) //[3, 2, 1, 4, 5, 7, 8]

數(shù)組去重的原理就是前面與后面相對(duì)比，做出相應(yīng)的操作

    var arr=[1,2,1,2,4,5,3,2,1,4,5,7,8]
    var newarr=arr.filter(function(v,i,arr){
        return arr.indexOf(v)==i  //每一個(gè)索引對(duì)應(yīng)一個(gè)值，如果相同的值對(duì)應(yīng)不同的索引那就是重復(fù)了
                                 //比如說第一個(gè)數(shù)字是1 它的索引是0 相對(duì)應(yīng)  可是后面又來了一個(gè)1 但是此時(shí)它的索引是2 這就不對(duì)了
    })
    console.log(newarr)  //[1, 2, 4, 5, 3, 7, 8] 

數(shù)組排序

有興趣的小伙伴復(fù)制粘貼自行了解一下即可

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title></title>
    </head>
    <body>
        <script type="text/javascript">
            //1.冒泡排序：是一種計(jì)算機(jī)科學(xué)領(lǐng)域的較簡(jiǎn)單的排序算法。bubblesort
            //冒泡排序算法的運(yùn)作如下：（從后往前）
            //比較相鄰的元素。如果第一個(gè)比第二個(gè)大，就交換他們兩個(gè)。
            //對(duì)每一對(duì)相鄰元素作同樣的工作，從開始第一對(duì)到結(jié)尾的最后一對(duì)。在這一點(diǎn)，最后的元素應(yīng)該會(huì)是最大的數(shù)。
            //針對(duì)所有的元素重復(fù)以上的步驟，除了最后一個(gè)。
            //持續(xù)每次對(duì)越來越少的元素重復(fù)上面的步驟，直到?jīng)]有任何一對(duì)數(shù)字需要比較。
            var arr=[12,5,68,123,77,68,79,9,35,7];
            var times=0;
            for(var i=0;i<arr.length-1;i++){//外出控制次數(shù)   
                for(var j=0;j<arr.length-i-1;j++){//數(shù)組的每個(gè)值
                    if(arr[j]>arr[j+1]){
                        var temp=arr[j];
                        arr[j]=arr[j+1];
                        arr[j+1]=temp;
                    }
                    times++;//兩兩交換的次數(shù)
                }
            }
            //arr.length-1:兩兩交換，少一次
            //arr.length-i-1;每一次i循環(huán)完，有一個(gè)數(shù)字已經(jīng)排好了。
            console.log(arr);
            console.log(times);//24
            
            
            //2.選擇排序selectsort
            //選擇排序（Selection sort）是一種簡(jiǎn)單直觀的排序算法。它的工作原理是每一次從待排序的數(shù)據(jù)元素中選出最小（或最大）的一個(gè)元素，存放在序列的起始位置，直到全部待排序的數(shù)據(jù)元素排完。
            var arr=[-120,5,68,123,77,68,-79,9,35,7];
            for(var i=0;i<arr.length;i++){
                var minindex=i;//依次假設(shè)最小值的索引
                var minvalue=arr[minindex];//最小值
                for(var j=i+1;j<arr.length;j++){
                    if(minvalue>arr[j]){
                        minvalue=arr[j];//如果余下的每一項(xiàng)比我最小值還要小，當(dāng)前這項(xiàng)就是最小值。
                        minindex=j;//最小索引
                    }
                }
                //內(nèi)部的循環(huán)執(zhí)行完。minindex:真正的最小值的索引
                if(i!=minindex){//如果假設(shè)的最小索引真的是最小索引，省略交換過程。
                    var temp=arr[i];
                    arr[i]=arr[minindex];
                    arr[minindex]=temp;
                }
            }
            console.log(arr);
            
            //快速排序
            //：通過一趟排序?qū)⒁判虻臄?shù)據(jù)分割成獨(dú)立的兩部分，其中一部分的所有數(shù)據(jù)都比另外一部分的所有數(shù)據(jù)都要小，然后再按此方法對(duì)這兩部分?jǐn)?shù)據(jù)分別進(jìn)行快速排序，整個(gè)排序過程可以遞歸進(jìn)行，以此達(dá)到整個(gè)數(shù)據(jù)變成有序序列。
            function quicksort(arr){
                if(Array.isArray(arr)){
                    if(arr.length<=1){//如果分割的數(shù)組的長度小于或者等于1,輸出數(shù)組。
                        return arr;//基點(diǎn)值。
                    }else{
                        var midindex=parseInt(arr.length/2);//中間值得索引
                        //從中間值開始截取，截取一個(gè)，結(jié)果是數(shù)組
                        var midvalue=arr.splice(midindex,1)[0];
                        var left=[];//存放小于midvalue值得數(shù)組
                        var right=[];//存放大于midvalue值得數(shù)組
                        for(var i=0;i<arr.length;i++){//比較賦值
                            if(arr[i]<midvalue){
                                left.push(arr[i]);
                            }else{
                                right.push(arr[i]);
                            }
                        }
                        //遞歸應(yīng)用。
                        return quicksort(left).concat(midvalue,quicksort(right));
                    }
                }else{
                    throw new Error('請(qǐng)輸入數(shù)組');
                }
            }
            
            console.log(quicksort([120,68,1000,123,77,-79,9,35,7]));
        </script>
    </body>
</html>