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

var arr=[1,2,3,4];
//可以在數組的尾部添加若干個元素，返回新數組的長度
var len=arr.push(5,6,7,8);
console.log(arr,len);
while(arr.push(1)0)arr.pop();//必須優化，原因如下
//如果數組中存儲的是對象，必須將所有的對象引用設爲null
while(arr.length>0){
    arr[arr.length-1]=null;
    arr.pop();
}
//下面這種效率更高
for(var i=0;i=0;i--){//從後往前挪
        arr[i+len]=arr[i];
        arr[i]=null;
    }
    //console.log(arr);
    for(var j=1;j

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

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

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=0){
        for(var i=0;iarr[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  57 && i  90 && i 

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

//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-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+=""+item.site+"
";
})
document.body.innerHTML+=str; 
function sort(arr,fn){
    var len=arr.length-1;
    while(len>0){
        for(var i=0;iarr[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