JS数组基础01（数组的创建，push,pop,unshift,shift,concat,join,splice,slice,sort.reverse,indexOf,三种排序)

數組

有序的列表，裏面存儲了若干個無序的元素；是一個緊密型結構

元素被存儲在列表中，這個數據就是元素，簡稱元

從列表中獲取這個元素的方法，使用數組名[下標]就可以得到這個元素，我們把這種方式叫做下標變量

對象：

與對象的區別在於，對象是鬆散型結構，是鍵值對存儲；

儅刪除一個元素時，對象的其他值不會發生變化，所以對象沒有長度（對象中不知道存儲了多少個元素），插入和刪除不會影響其他數據，所以時間複雜度極低；

通過key去一一對應存儲一個值，所以獲取值得時間複雜度極低；

每个数据都是独立存在,不存在关联关系,更不能排序,所以不找因关联关系找到对应的值

數組：

數組是緊密型結構，只用下標存儲對應的值（將元素放在列表中的第幾位，從0開始計算，這個位置就是下標，又叫做索引值）；

刪除一個元素時，因爲緊密結構的關係會導致後面的元素向前遞進，數組有長度arr.length，因爲插入和刪除都會影響數組元素的位置和結構，因此插入和刪除都會影響數組的運行效率，時間複雜度較高；

數組的存儲是依靠下標的，所以如果需要查找一個值，就需要遍歷每個元素，要找到目標元素，時間複雜度極高；

数组在使用时，因为是紧密性解构，我们可以根据上一个内容找到与其相关联的其他元素例如我们可以利用数组排序，找一个最小值，还可以迅速找第二位最小值

1.創建數組

var arr=[];
arr[0]=10;
arr[3]=20;
console.log(arr[3]);
arr=[1,2,3,4,5,6,7];//刪除5 arr=[1,2,3,4,6,7]
​
var arr=[1,"a",true,undefined];//雖然可以這樣寫，但是效率極低，一般把相同類型數據存在一起
​
//創建數組
var arr=[4,5,2,3,8];//1.字面量創建
var arr=[];//創建空數組，因爲js是弱類型語言，所以數組比較隨意，可以任意擴張，不需要限定長度
​
var arr=new Array(4,5,6,3,6,0);//2.構造函數創建法
var arr=new Array(5);//僅有一個非負整數參數，長度為5的新的空數組
var arr=Array(5);//同上，但是建議使用上面那個
​
var arr=new Object([]);//3.對象創建法
var arr=[1,2,3,4];
console.log(typeof arr);//object
//怎麽區分數組和對象？（三種）
console.log(arr.constructor===Array);//通過構造函數constructor來判斷，構造函數名與類名Array相等（這種方法最好）
console.log(Array.isArray(arr));//僅限ES6以後的瀏覽器才支持
console.log(String(arr)!=="[object Object]");//不是對象
​
var arr1=arr;
arr[0]=10;
console.log(arr1);//數組也是引用類型，引用地址賦值
//數組在强轉或者隱式轉換為字符串時，都會轉換為數組元素連接的字符串值
console.log([]===[]);//false，引用地址不相同
console.log([]==[]);//false,左右兩邊類型一樣(因爲是兩個不同的對象)
console.log(![]==[]);//非數組(對象是一個實實在在存在的東西轉成非的布爾類型)轉換為布爾值，左邊為false，兩個等號自動隱式轉換爲相同類型，右邊先轉換爲空字符串，再轉換爲布爾值false
console.log([]=="");//true
console.log([]==false);//true
console.log([]==0);//true
console.log([]==undefined);//false
console.log([]==null);//false

2.數組的長度

是一個可讀可寫的屬性

var arr=[1,2,3,4];
arr.length=3;
console.log(arr);//arr=[1,2,3];
arr.length--;//刪除最尾部的一個元素
arr.length=0;//清空數組中的所有元素
arr.length++;//數組尾部加一個空元素
//數組的長度一般比數組的最大下標值大1
arr[arr.length]=5;//在數組的尾部增加一個元素5
arr[10]=100;//在下標為10的地方增加一個元素100，中間增加空元素或者刪除多餘的
for(var i=0;i<arr.length;i++){
    //console.log(arr[i]===undefined);
    console.log(i in arr);//可以判斷對象中這個key對應的值是否存在
}
for(var index in arr){
    console.log(arr[index]);
}
arr.a=10;
arr.b=20;
for(var i=0;i<arr.length;i++){//for循環
    console.log(arr[i]);//拿不到a 10,b 20
}
for(var index in arr){//for in 遍歷能遍歷到數組的添加屬性
    console.log(index,arr[index]);//能拿到a 10,b 20
}
//数组使用for循环遍历，会将所有下标遍历，不遍历数组的对象属性
//但是会遍历到空元素，遍历时下标都是数值
​
//数组使用for in循环遍历，会将所有的可枚举属性遍历，如果该属性
//没有值就不遍历，例如数组中下标为空元素的，就不会被遍历，但是
//数组的对象属性会被遍历，遍历时都是将下标转换为字符串

3.數組的方法：push,pop,unshift,shift

var arr=[1,2,3,4];
//可以在數組的尾部添加若干個元素，返回新數組的長度
var len=arr.push(5,6,7,8);
console.log(arr,len);
while(arr.push(1)<10);
console.log(arr);
​
var arr=[];
while(arr.push({})<10);//循環給尾部添加若干個元素
arr[0].a=10;
這是個空對象沒有引用關係
​
動態添加數組元素會造成引用地址相同（另一種方法以後學）
​
var element=arr.pop();//返回刪除的元素
console.log(element,arr);
//從後向前刪除到哪裏
var arr=[1,2,3,4,5,6,7]
while(arr.pop()!==3);//arr=[1,2]刪除到那個元素爲止
//把整個數組刪完，刪除到三種undefined(空元素，刪完了，刪到元素undefined)
//所以不能用arr.pop()
while(arr.length>0)arr.pop();//必須優化，原因如下
//如果數組中存儲的是對象，必須將所有的對象引用設爲null
while(arr.length>0){
    arr[arr.length-1]=null;
    arr.pop();
}
//下面這種效率更高
for(var i=0;i<arr.length;i++){
    arr[i]=null;
}
arr.length=0;
​
//shift unshift一般不用，因爲這兩個方法效率低下（時間複雜度高）
//在數組的頭部添加若干個元素，并且返回這個數組的新長度
arr.unshift(5,6)
//將數組的頭部一個元素刪除，并且返回這個元素
var elem=arr.shift();
​
//這四個方法，操作後，原數組的引用關係不變，不返回新數組，因爲是在原來的基礎上更改
​
function push(arr){//使用arguments
    for(var i=1;i<arguments.length;i++){
        arr[arr.length]=arguments[i];
    }
    return arr.length;
}
var arr=[];
var len=push(arr,1,2,3);
console.log(arr,len);
​
function pop(arr){
    var elem=arr[arr.length-1];
    if(arr.length>0)arr.length--;
    return elem;
}
var arr=[1,2,3];
var elem=pop(arr);
console.log(arr,elem);
​
function unshift(arr){
    var len=arguments.length-1;
    for(var i=arr.length-1;i>=0;i--){//從後往前挪
        arr[i+len]=arr[i];
        arr[i]=null;
    }
    //console.log(arr);
    for(var j=1;j<arguments.length;j++){
        arr[j-1]=arguments[j];
    }
    return arr.length;
}
var arr=[1,2,3];
var len=unshift(arr,4,5,6);
console.log(arr,len);
​
function unshift(arr){
    var arr1=[];
    for(var i=0;i,arr.length;i++){
        arr1[i]=arr[i];
    }
    arr.length=0;
    for(var j=1;j<arguments.length;j++){
        arr[j-1]=arguments[j];
    }
    var len=arr.length;
    for(var k=0;k<arr1.length;k++){
        //arr[len+k]=arr1[k];
        arr[arr.length]=arr1[k];
    }
    return arr.length;
})
​
function shift(arr){//刪除數組最頭部的元素
    var elem=arr[0];
    for(var i=1;i<arr.length;i++){
        arr[i-1]=arr[i];
    }
    if(arr.length>0)arr.length--;
    return elem;
}
var arr=[1,3];
var elem=shift(arr);
console.log(elem,arr);

4.concat和join

var arr=[1,2,3,4,5];
//使用某個字符作爲連接符，將所有數組的元素連接成一個字符串
//如果沒有連接符，默認用逗號連接
var str=arr.join("*");
console.log(str);
var arr=[8,10];//8,10
var obj={a:1};//[object Object]
var str=arr.join(s);
var str=arr.join(null);//以null字符串連接
var str=arr.join(undeifned);//以,連接
function join(arr,separator){
    //separator本來就是參數一個局部變量，所以不用再定義了
    if(separator===undefined) separator=",";
    separator=String(separator);//强制轉換為字符串
    var str="";
    for(var i=0;i<arr.length;i++){
        if(i!==arr.length-1)str+=arr[i]+separator;
        else str+=arr[i];
    }
    return str;
}
//join(arr,null);
var str=join(arr,"");
console.log(str);
​
concat連接數組
//數組連接若干個數組或者元素，返回一個新的連接完成的數組，與原數組無引用關係
//不是改變原數組，是產生新數組
//沒有參數時，只有一個參數時，若干個參數時，參數是數組時
var arr=[1,2,3,4];
//arr.concat([5,6,7],[8,9,10]);//多個數組
//arr.concat(5,6,7,8,9);//多個元素
var arr1=arr.concat();
console.log(arr1==arr);//引用地址不一樣
arr[0]=10;
console.log(arr1);//沒有變化
​
function concat(arr){
    //判斷參數長度
    var arr1=[];
    for(var i=0;i<arr.length;i++){
        arr1[i]=arr[i];
    }
    if(arguments.length===1) return arr1;
    for(var j=1;j<arguments.length;j++){
        if(arguments[j]!==null&&arguments[j].constructor===Array){
            //判斷是不是數組
            for(var k=0;k<arguments[j].length;k++){
                arr1[arr1.length]=arguments[j][k];
            }
        }
        else{
            arr1[arr1.length]=arguments[j];
        }
    }
    return arr1;
}
var arr=[3,4,5];
var arr1=concat(arr,6,7,8,[2,3,4],null);
arr[0]=10;
console.log(arr1);

5.splice和slice

var arr=[1,2,3,4];
arr.splice();//從哪個開始，刪除多少個，（添加的元素），返回被刪除元素組成的一個新數組
var arr1=arr.splice(1,2);
console.log(arr1,arr);//[2,3] [1,4]
var arr1=arr.splice(1);//刪除到尾部
var arr1=arr.splice(-1);//將最後一個刪除
var arr1=arr.splice(0);//將一個數組的所有元素轉移到另一個數組
var arr1=arr.splice();//沒有刪除，返回空數組
var arr1=arr.splice(-3,2);//從倒數第三個元素向右刪除兩個元素
​
var arr1=arr.splice(1,2,-2,-3);//從第一位開始向後刪除兩個元素，并且在該位置插入-2和-3，替換，并且返回被刪除的兩個元素組成的數組
var arr1=arr.splice(1,arr.length,0,-1,-2);//從某個位置開始刪除到數組的尾部，并且添加0,-1,-2
var arr1=arr.splice(1,-2);//不刪除也不報錯
​
var arr1=arr.splice(1,0,0);//在第一位插入一個元素0，不刪除，返回空數組
​
function splice(arr){
    
}
//開發中能不用就不用，時間複雜度太高了
//刪除后改變原數組長度（有些東西特別不適合使用這個來處理）
var arr=[1,3,3,6,8,2,3,5,6,3,7,9,8,3,6,7,3,8,9];
​
var len=arr.length;
//for(var i=0;i<len;i++){
//  if(arr[i]===3)arr.splice(i,1)
//  else i++;
//}
​
//數字長度在不斷改變,後面的數跑前去l
var len=arr.length;
//for(var i=0;i<len;i++){
//  arr.pop();
//}
console.log(arr);
​
//數組去重，要做雙重循環
var arr1=[];
for(var i=0;i<arr.length;i++){
    //把不重複的放arr1
    var bool=false;
    for(var j=0;j<arr1.length;j++){
        if(arr[i]===arr1[j]){//找到相等的就跳過不添加
            bool=true;
            break;
        }
    }
    if(!bool) arr1.push(arr[i]);
}
arr.length=0;
//去重原數組,把數組元素挪進去，不能用splice,也不能用concat
for(var k=0;k<arr1.length;k++){
    arr[k]=arr1[k];
}
arr1.length=0;
arr1=null;
console.log(arr,arr1);
//slice
var arr=[1,2,3,4];
var arr1=arr.slice();
console.log(arr1===arr);//false沒有引用關係
//slice這個方法可以複製原數組到新數組，沒有引用關係
​
//數組複製的方法,沒有引用關係
concat arr.concat()
slice arr.slice()
//完成某些功能,强轉為數組
var divs=document.getElementsByTagName("div");//強轉為數組
var arr=Array.from(divs);//ES6，把列表强轉為數組，老瀏覽器不支持
​
var arr=Array.prototype.slice.call(divs);
var arr=[].slice.call(divs);//這兩種屬於同一種方法
​
var arr=Array.prototype.concat.apply([],divs);
var arr=[].concat.apply([],divs);
console.log(arr);
​
var arr1=arr.slice(2);
var arr1=arr.slice(0);//從開始到結束，和不填效果一樣，複製數組
var arr1=arr.slice(-2);//從後向前數，第二個元素到尾部的所有元素複製
var arr1=arr.slice(1,2);//複製了一個，[1,2)不包括結束這一項
console.log(arr1,arr);//從第幾項開始到第幾項結束，原數組不改變
​
function slice(arr,start,end){
    if(start===undefined)  start=0;
    if(end===undefined)  end=arr.length;
    start=Number(start);
    end=Number(end);
    if(!isNaN(end)&&isNaN(start))  start=0;//强轉以後是數值的，就令它為0
    if(isNaN(start))  return [];
    if(start<0) start=arr.length+start;
    if(end<0)  end=arr.length+end;
    var arr1=[];
    for(var i=start;i<end;i++){
        arr1[i-start]=arr[i];
    }
    return arr1;
}
var arr=[2,3,4,5];
var arr1=slice(arr);
console.log(arr1);

6.sort和reverse

var arr=[1,2,3,,4];
//當前數組按照倒裝的順序將原數組顛倒并且返回原數組
var arr1=arr.reverse();
console.log(arr,arr1,arr==arr1);
​
/*function reverse(arr){//以中閒爲界交換兩邊對稱的元素
    var len=parseInt(arr.length/2);
    for(var i=0;i<len;i++){
        var temp=arr[i];
        arr[i]=arr[arr.length-i-1];
        arr[arr.length-i-1]=temp;
    }
    return arr;
}*/
var arr1=reverse(arr);
console.log(arr);
​
function reverse(arr){
    var arr1=[];
    for(var i=0;i<arr.length;i++){
        if(i in arr){
            arr1[i]=arr[i];
        }
    }
    arr.length=0;
    for(var j=arr1.length-1;j>=0;j--){
        if(j in arr){//用if in
            arr[arr1.length-j-1]=arr1[j];
        }
    }
    return arr;
}
arr.reverse();
console.log(arr);
var arr=[3,7,2,9,1,0,6,5,4,4,12,11];//按照字符的首字符ASCII碼排序
vr arr1=arr.sort();
console.log(arr,arr1,arr===arr1);//是引用關係
//sort的用法
arr.sort(function(a,b){
    return a-b;//從小到大
    return b-a;//從大到小
});//給sort裏放了一個回調函數
console.log(arr);
​
var arr=["a","b","c","d","e","ab","bc","def","aaa","efg"];
"a".charCodeAt(0);
arr.sort(function(a,b){
    //return a.charCodeAt(0)-b.charCodeAt(0);//只能比較第一位
    //重構排序
});
console.log(arr)
​
var arr=[
    {id:1001,name:"苹果IphoneX",price:6900,num:2,info:"最新的苹果手机"},
    {id:1002,name:"小米10",price:3900,num:3,info:"最新的小米手机"},
    {id:1003,name:"华为meta10",price:8900,num:4,info:"最新的华为手机"},
    {id:1004,name:"锤子手机",price:1900,num:1,info:"最新的锤子手机"},
    {id:1005,name:"三星手机",price:4900,num:2,info:"最新的三星手机"},
    {id:1006,name:"vivo手机",price:2900,num:4,info:"最新的vivo手机"},
    {id:1007,name:"魅族手机",price:1900,num:5,info:"最新的魅族手机"},
];
arr.sort(function(a,b){
    return a.price-b.price;
})
console.log(arr)
//對象型數組某個屬性的排序
​
//排序算法  記
//冒泡排序,一個個交換，從最後一個開始循環，循環到
function sort(arr){
    var len=arr.length-1;
    while(len>=0){
        for(var i=0;i<arr.length-1;i++){
            if(arr[i]>arr[i+1]){
                var temp=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=temp;              
            }
        }
        len--;
    }
}
var arr=[3,2,9,7]; */
      // 2,3,9,7
      // 2,3,9,7
      // 2,3,7,9
      
function selectionSort(arr) {
    var len = arr.length;
    var minIndex, temp;
    for (var i = 0; i < len - 1; i++) {
        minIndex = i;
        for (var j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {
              minIndex = j; //将最小数的索引保存
            }
        }
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    return arr;
}
var arr=[2,7,1,4,6]; */
//   min 0      7 2  arr[0]
//   min 0      1 2   arr[0]
//   min 2      4 1   arr[2]
//   min 2      6 1   arr[2]
//   min 2    用当前项和最小项交换    1,7,2,4,6
​
// 1,7,2,4,6
//   min 1      2 7  arr[1];
//     min 2       2 4  arr[2];
//     min 2       2 6   arr[2];
//    min  2     用当前项和最小项交换    1,2,7,4,6
​
//   1,2,7,4,6
// min 2    7 4  arr[2]
// min 3    4 6  arr[3]
// min 3    用当前项和最小项交换    1,2,4,7,6
​
// 1,2,4,7,6
//  min  3    7 6  arr[3]
//  min  4    6 7
// min 4 1,2,4,6,7
​
function quickSort(arr) {
    if (arr.length <= 1) {
        return arr;
    }
    var pivotIndex = parseInt(arr.length / 2);
    var pivot = arr.splice(pivotIndex, 1)[0];
    var left = [];
    var right = [];
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] < pivot) {
            left.push(arr[i]);
        } else {
        right.push(arr[i]);
        }
    }
    return quickSort(left).concat([pivot], quickSort(right));
} 
quickSort(arr);
console.log(arr);
​
//   1,5,2,7,3
//   中2    [1,5,7,3]
//   left [1]   right [5,7,3]; 
//   5,7,3   
//   中7   left 5,3
//   中3  right 5  
//   3,5    中+右  
//    3,5,7  上面的值+ 中 
//    1,2,3,5,7   [1].concat(2)+[3,5,7]  左+中+上面的值
//隨機亂序
var arr=[1,2,3,4,5,6,7,8];
arr.sort(function(a,b){
    //隨機生成0-1之間的浮點數，不包括1
    return Math.random()-0.5;
})
console.log(arr);//缺陷是太多的概率是連續性的，不均匀
//俄羅斯輪盤圖算法
//驗證碼（是不是機器注冊登錄）需要防抖
// 随机乱序
  
var arr=[1,2,3,4,5,6,7,8];
arr.sort(function(a,b){
    // 随机生成0-1直接的浮点数，不包括1
    return Math.random()-0.5
});
console.log(arr); 
​
function getSecurityCode() {
    var arr = [];
    var i = 47;
    while (i++ < 122) {
        if (i > 57 && i < 65) continue;
        if (i > 90 && i < 97) continue;
        arr.push(String.fromCharCode(i));
    }
    arr.sort(function(){
        return Math.random()-0.5;
    });
    arr.length=4;
    return arr.join("");
}
console.log(getSecurityCode()); 
​
// 索引查找对象的问题
var arr=[
    {id:1001,site:"网易",url:"http://www.163.com"},
    {id:1002,site:"腾讯",url:"http://www.qq.com"},
    {id:1003,site:"京东",url:"http://www.jd.com"},
    {id:1004,site:"淘宝",url:"http://www.taobao.com"},
    {id:1005,site:"天猫",url:"http://www.tmail.com"}
];
var index=arr.indexOf({id:1001,site:"京东",url:"http://www.jd.com"});
​
function searchObj(arr,obj){
    for(var i=0;i<arr.length;i++){
        if(arr[i].id===obj.id) return i;
    }
    return -1;
} 
​
function searchObj(arr,obj){
    for(var i=0;i<arr.length;i++){
        if(JSON.stringify(arr[i])===JSON.stringify(obj)) return i;
    }
    return -1;
}
​
var arr=[
    {site:"网易",url:"http://www.163.com"},
    {site:"腾讯",url:"http://www.qq.com"},
    {site:"京东",url:"http://www.jd.com"},
    {site:"淘宝",url:"http://www.taobao.com"},
    {site:"天猫",url:"http://www.tmail.com"}
]
var index=searchObj(arr,{site:"京东",url:"http://www.jd.com"});
console.log(index); 

7.indexOf和lastIndexOf

var arr=[1,2,5,3,4,2,3];
//在數組中查找元素，并且返回該元素的下標
var index=arr.indexOf(5);
var index=arr.indexOf(3,4);//從第幾個下標開始查找
indexOf(要搜索的元素，從第幾個下標開始搜索)
console.log(index);
​
var index=0;
do{
    index=arr.indexOf(3,index);
    console.log(index);
}while(++index>0)
​
var arr=[1,3,3,6,8,2,3,5,6,3,7,9,8,3,6,7,3,8,9];
var arr1=[];
for(var i=0;i<arr.length;i++){
    if(arr1.indexOf(arr[i])<0) arr1.push(arr[i]);
}
console.log(arr1); 
​
function indexOf(arr,search,index){
    if(index===undefined)index=0;
    for(var i=index;i<arr.length;i++){
        if(arr[i]===search)return i;
    }
    return -1;
}
​
var arr=[1,3,3,6,8,2,3,5,6,3,7,9,8,3,6,7,3];
lastIndexOf(要查找的元素，從什麽)
var index=arr.lastIndexOf(3);
console.log(index);
​
//fill填充
var arr=[,,,,];
arr.fill(5,1,3); fill(要填充的值，從什麽位置開始，到什麽位置結束)
console.log(arr);
//fill只能用於有長度的數組，如果不給予開始位置和結束位置，
var arr=[1,2,3,4,5,6];
arr.fill(10);
console.log(arr);
//這種方式如果填充對象，就會造成填充同一個引用地址的對象
var arr=Array(6).fill(10);
var arr=Array(6).fill({a:1});//有一個問題
arr[0].a=10;
console.log(arr)；

8.數組的遍歷

//forEach map
var arr=[1,2,5,,3,6,8];
//遍歷數組，可以獲取使用元素和下標，自動過濾空元素，空元素不遍歷，比for in好，不會遍歷到數組的屬性,比for來説不會遍歷到空元素
//缺陷是函數中this指向將會被改變
arr.forEach(function(item,index,arr){
    console.log(item,index,arr);
    item=10;
    arr[index]=item+10;
})
console.log(arr);
​
function forEach(arr,fn){
    for(var i=0;i<arr.length;i++){
        if(i in arr) fn(arr[i],i,arr);
    }
}
//每次遍歷到一個元素
//設計模式 橋接模式
var arr=[2,3,4,6,7,5,8];
forEach(arr,function(item,index,arr){
    console.log(item,index,arr);
})
forEach(arr,fn2);
function fn2(item,index,arr){
​
}
//map
var arr=[2,3,4,6,7,5,8];
//遍歷數組，并且使用return返回元素，這些被返回的元素會被放在一個
//新數組的長度和原數組相同
var arr1=arr.map(function(item,index,arr){
    return item+10;
})
console.log(arr1,arr);
​
function map(arr,fn){
    var arr1=[];
    for(var i=0;i<arr.length;i++){
        if(i in arr) arr1[i]=fn(arr[i],i,arr);
    }
    return arr1;
}
​
var arr=[1,2,5,,3,6,8];
var arr1=map(arr,function(item){
    return item+10;
});
console.log(arr1);
​
var arr=[1,3,3,6,8,2,3,5,6,3,7,9,8,3,6,7,3,8,9];
for(var i=0;i<arr.length;i++){
    var index=i;
    while(index>-1){
        index=arr.indexOf(arr[i],index+1);
        if(index>-1)delete arr[i];//使用delete会变成松散型数组
    }
}
// var arr1=arr.map(function(item){
//     return item;
// });
var arr1=[];
arr.forEach(function(item){
    arr1.push(item);
})
console.log(arr1);
​
var arr=[
            {site:"网易",url:"http://www.163.com"},
            {site:"腾讯",url:"http://www.qq.com"},
            {site:"京东",url:"http://www.jd.com"},
            {site:"淘宝",url:"http://www.taobao.com"},
            {site:"天猫",url:"http://www.tmail.com"}
        ]
var str="";
arr.forEach(function(item){
    str+="<a href='"+item.url+"'>"+item.site+"</a><br>";
})
document.body.innerHTML+=str; 
function sort(arr,fn){
    var len=arr.length-1;
    while(len>0){
        for(var i=0;i<arr.length-1;i++){
            // if(arr[i]>arr[i+1])
            // if(arr[i]-arr[i+1]>0)
            // if(a-b)
            if(fn(arr[i],arr[i+1])>0){
                var temp=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=temp;
            }
        }
        len--;
    }   
}
var arr = [3, 7, 2, 9, 1, 0, 6, 5, 4, 4, 12, 11];
sort(arr,function(a,b){
    return b-a;
});
console.log(arr);

9.some.every

//some遍歷數組，并且判斷是否有元素滿足條件，如果有，直接跳出返回true
​
var arr=[1];
var arr=[1,4,6,5,8,3,2];
var bool=arr.some(function(item,index,arr){
    return item>4;//true
    return item>10;//false
});
console.log(bool);
//every遍歷數組，并且判斷是否都滿足條件，如果不是，直接跳出返回false
var bool=arr.every(function(item,index,arr){
    return item>4;
})
console.log(bool);
​
//橋接模式
function some(arr,fn){
    for(var i=0;i<arr.length;i++){
        if(i in arr && fn(arr[i],i,arr)) return true;
    }
    return false;
}
function every(arr,fn){
    for(var i=0;i<arr.length;i++){
        if(i in arr && !fn(arr[i],i,arr)) return false;
    }
    return true;
}
//案例
var all,list;
init();
function init(){
    list=document.getElementsByTagName("input");
    list=Array.form(list);
    all=list.splice(0,1)[0];
    all.onclick=clickHandler;
    list.forEach(function(item){
        item.onclick=clickHandler;
    })
}
function clickHandler(){
    console.log(this);//在點擊事件中,this是被點擊的元素
    if(this===all){
        list.forEach(function(item){
            item.checked=all.checked;
        })
    }else{
        all.checked=list.every(function(item){
            return item.checked;
        })
    }
}