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

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循环遍历，会将所有的可枚举属性遍历，如果该属性
//没有值就不遍历，例如数组中下标为空元素的，就不会被遍历，但是
//数组的对象属性会被遍历，遍历时都是将下标转换为字符串

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);

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);

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);

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); 

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)；

//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);

//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;
        })
    }
}