檢測一個對象是否是數組;(用來對付復雜數據類型;)// 簡單數據類型 typeof ;A instanceof B // A是不是B造出來的;例：  var arr = [1,2,3];  console.log(arr instanceof Array); //arr屬不屬于Array類型;

Array.isArray(參數); // 判斷參數是不是數組,返回布爾值;例：  var arr = [1,2,3];  var num = 123;  console.log(Array.isArray(arr)); //true  console.log(Array.isArray(num)); //false

數組.toString(); // 把數組變成字符串,去除了[],內容用逗號鏈接;例：  var arr = ["aaa","bbb","ccc"];  console.log(arr.toString());   //返回 aaa,bbb,ccc

數組.valueOf(); //返回數組本身;  例：  var arr = ["aaa","bbb","ccc"];  console.log(arr.valueOf());   //返回數組本身 ["aaa","bbb","ccc"]

數組.join(參數); // 數組中的元素可以按照參數進行鏈接變成一個字符串;console.log(arr.join()); //和toString()一樣用逗號鏈接console.log(arr.join("|")); //用參數鏈接console.log(arr.join("&")); //用參數鏈接console.log(arr.join(" ")); //如果是空格，真的用空格鏈接console.log(arr.join("")); //空字符是無縫連接

1. 數組.push() //在數組的最末尾添加元素;2. 數組.pop() //不需要參數;在數組的最末尾刪除一項;例：  var arr = [1,2,3];  var aaa = arr.push("abc");//在數組的最末尾添加一個元素;  console.log(arr);//元素被修改了  console.log(aaa);//返回值是數組的長度;  aaa = arr.pop();//不需要參數;在數組的最末尾刪除一項;  console.log(arr);//元素被修改了  console.log(aaa);//被刪除的那一項

1. 數組.unshift() //在數組的最前面添加一個元素;2. 數組.shift() //不需要參數;在數組的最前面刪除一項;例：  var arr = [1,2,3];  aaa = arr.unshift("abc");//在數組的最前面添加一個元素;  console.log(arr);//元素被修改了  console.log(aaa);//返回值是數組的長度;  aaa = arr.shift();//不需要參數;在數組的最前面刪除一項;  console.log(arr);//元素被修改了  console.log(aaa);//被刪除的那一項

reverse()  //翻轉數組例:  var arr1 = [1,2,3,4,5];  var aaa = arr1.reverse(); // [5,4,3,2,1]

sort() // 數組中元素排序;(默認：從小到大)   // 默認：按照首個字符的Unicode編碼排序;如果第一個相同那么就比較第二個...例：      var arr = [4,5,1,3,2,7,6];  var aaa =arr.sort();  console.log(aaa);     // [1, 2, 3, 4, 5, 6, 7]  console.log(aaa === arr);// true 原數組被排序了(冒泡排序)  //默認還可以排列字母;  var arr2 = ["c","e","d","a","b"];  var bbb = arr2.sort();  console.log(bbb);     // ["a", "b", "c", "d", "e"]  console.log(bbb===arr2); // true 原數組被排序了(冒泡排序)sort() //數值大小排序方法,需要借助回調函數;例：   var arr = [4,5,1,13,2,7,6];   //回調函數里面返回值如果是：參數1-參數2;升冪；  參數2-參數1;降冪；   arr.sort(function (a,b) {    return a-b; //升序    //return b-a; //降序    //return b.value-a.value; //按照元素value屬性的大小排序;   });   console.log(arr); // [1, 2, 4, 5, 6, 7, 13]

  var aaa = bubbleSort([1,12,3], function (a,b) {//    return a-b;//實參：array[j]-array[j+1]；    return b-a;//實參：array[j+1]-array[j]；  });  console.log(aaa);  function bubbleSort(array,fn){    //外循環控制輪數，內循環控制次數，都是元素個數-1;    for(var i=0;i<array.length-1;i++){      for(var j=0;j<array.length-1-i;j++){//次數優化，多比較一輪，少比較一次;        //滿足條件交換位置;//        if(array[j]>array[j+1]){//大于升冪排序；否則降冪;        //a-b>0 和 a>b是一個意思;        //b-a>0 和 a<b是一個意思;//        if(array[j]-array[j+1]>0){//升冪排序//        if(array[j+1]-array[j]>0){//降冪排序        //把兩個變量送到一個函數中;        if(fn(array[j],array[j+1])>0){          var temp = array[j];          array[j] = array[j+1];          array[j+1] = temp;        }      }    }    //返回數組    return array;  }

數組1.concat(數組2); // 鏈接兩個數組;var arr1 = [1,2,3];var arr2 = ["a","b","c"];var arr3 = arr1.concat(arr2);console.log(arr3)  //  [1, 2, 3, "a", "b", "c"]

數組.slice(開始索引值，結束索引值);   //數組截取;例 ：   var arr = [1, 2, 3, "a", "b", "c"];   console.log(arr.slice(3));      //從索引值為3截取到最后;["a", "b", "c"]   console.log(arr.slice(0,3));      //包左不包右;[1, 2, 3]   console.log(arr.slice(-2));      //負數是后幾個;["b", "c"]   console.log(arr.slice(3,0));      //如果前面的比后面的大，那么就是[];[]   console.log(arr);             //原數組不被修改;[1, 2, 3, "a", "b", "c"]

數組.splice(開始索引值，刪除幾個，替換內容1，替換內容2，...); // 替換和刪除;                           //改變原數組;返回值是被刪除/替換的內容例:  var arr = [1,2,3,4,5,6,"a", "b", "c"]  arr.splice(5);    //從索引值為3截取到最后;(刪除)  console.log(arr);   // [1, 2, 3, 4, 5]  arr.splice(1,2);  //(刪除指定個數)從索引為1的開始刪除2個  console.log(arr);  //[1, 4, 5]//替換  var arr = [1,2,3,4,5,6,"a", "b", "c"];  console.log(arr.splice(3,3,"aaa","bbb","ccc"));  //(刪除指定數并替換)  console.log(arr);   // [1, 2, 3, "aaa", "bbb", "ccc", "a", "b", "c"]//  添加  arr.splice(3,0,"aaa","bbb","ccc");//(刪除指定個數)//  console.log(arr);//截取或者替換之后的;  [1, 2, 3, "aaa", "bbb", "ccc", "aaa", "bbb", "ccc", "a", "b", "c"]

數組.indexOf(元素);   // 給元素，查索引(從前往后)數組.lastIndexOf(元素); // 給元素，查索引(從后往前)例：  var arr = ["a","b","c","d","c","b","b"];  console.log(arr.indexOf("b"));    // 1 查到以后立刻返回  console.log(arr.lastIndexOf("b"));  // 6 找到以后立刻返回  console.log(arr.indexOf("xxx"));  // -1; 查不到就返回-1；

對數組中每一項運行回調函數，如果都返回true，every返回true，如果有一項返回false，則停止遍歷 every返回false；不寫默認返回false像保鏢失誤一次，游戲結束！！！例：1.  var arr = [111,222,333,444,555];  arr.every(function (a,b,c) {    console.log(a);  //元素    console.log(b);  //索引值    console.log(c);  //數組本身;    console.log("-----");  //數組本身;    //數組中元素賦值：c[b] = 值;   a=有時候無法賦值;    return true;  });2. //every返回一個bool值，全部是true才是true；有一個是false，結果就是false  var bool = arr.every(function (element, index, array) {    //判斷：我們定義所有元素都大于200;    //if(element > 100){    if(element > 200){      return true;    }else{      return false;    }  })  alert(bool); //false

//  對數組中每一項運行回調函數，該函數返回結果是true的項組成的新數組//   新數組是有老數組中的元素組成的，return為ture的項;例：  var arr = [111,222,333,444,555];  var newArr = arr.filter(function (element, index, array) {    //只要是奇數，就組成數組;(數組中辨別元素)    if(element%2 === 0){      return true;    }else{      return false;    }  })  console.log(newArr); // [222, 444]

// 和for循環一樣；沒有返回值;例：  var arr = [111,222,333,444,555];  var sum = 0;  var aaa = arr.forEach(function (element,index,array) {    console.log(element); // 輸出數組中的每一個元素    console.log(index); // 數組元素對應的索引值    console.log(array); // 數組本身 [111, 222, 333, 444, 555]    sum += element; //數組中元素求和;  });  console.log(sum); // 數組元素加起來的和  console.log(aaa);//undefined；沒有返回值 所以返回undefined

// 對數組中每一項運行回調函數，返回該函數的結果組成的新數組//  return什么新數組中就有什么; 不return返回undefined; 對數組二次加工例：  var arr = [111,222,333,444,555];  var newArr = arr.map(function (element, index, array) {    if(index == 2){      return element; // 這里return了 所以下面返回的值是333    }    return element*100; // 返回的元素值都乘上100后的值  })  console.log(newArr); // [11100, 22200, 333, 44400, 55500]

//對數組中每一項運行回調函數，如果該函數對某一項返回true，則some返回true; 像殺手，有一個成功，就勝利了！！！例：  var arr = [111,222,333,444,555];  var bool = arr.some(function (ele,i,array) {    //判斷：數組中有3的倍數    if(ele%3 == 0){      return true;    }    return false;  })  alert(bool); //true ; 有一個成功就是true

  1. arr.length = 0; // (不好，偽數組無法清空)  2. arr.splice(0); // 偽數組沒有這個方法;  3. arr = [];   // 可以操作偽數組; (推薦!)

// 偽數組: 就是長的像數組，但是沒有數組的方法;也不能添加和刪除元素;例： // arguments    fn(111,222,333);    function fn(){      arguments.length = 0; // 無法清空 返回 [1, 2, 3]      arguments.splice(0); // 會報錯 arguments.splice is not a function      arguments = []; // 可以清空,返回空數組[]       console.log(arguments);    }

    var arr = ["劉備","張飛","關羽"];    var separator = "|";    //通過for循環累加    var str = arr[0];    for(var i=1;i<arr.length;i++){      str += separator+arr[i];    }    console.log(str); // 劉備|張飛|關羽    //join()可以把數組中的元素鏈接成字符串;    console.log(arr.join("|")); // 劉備|張飛|關羽

 // 數組.reverse() 方法      var arr = ["a", "b", "c", "d"];      console.log(arr.reverse()); // ["d", "c", "b", "a"]        // 三種：1.正向遍歷，反向添加; 2.反向遍歷，正向添加;  3.元數組元素交換位置;      for(var i=0;i<arr.length/2;i++){        var temp = arr[i];        arr[i] = arr[arr.length-1-i];        arr[arr.length-1-i] = temp;      }      console.log(arr);

  var arr = [1500, 1200, 2000, 2100, 1800];  //利用filter()形成一個數組;return true;組成的數組;  var newArr = arr.filter(function (ele, i, array) {    //2000以上返回false;    if(ele<2000){      return true;    }else{      return false;    }  });  console.log(newArr); // [1500, 1200, 1800]

  var arr = ["c", "a", "z", "a", "x", "a"];  //遍歷數組(for/while/do...while)  forEach();  arr.forEach(function (ele, index, array) {    //如果元素等于“a”，那么就輸出索引值；    if("a" === ele){      console.log(index);    }  });

    var arr = ["鳴人","鳴人","佐助","佐助","小櫻","小櫻"];  // 方法1： 思路：定義一個新數組，遍歷老數組，判斷，如果新數組里面沒有老數組的元素就添加，否則就不添加；    var newArr = [];    //遍歷老數組    arr.forEach(function (ele,index,array) {      //檢測老數組中的元素，如果新數組中存在就不添加了，不存在才添加;      if(newArr.indexOf(ele) === -1){//不存在就添加;（去新數組中查找元素索引值，如果為-1就是沒有）        newArr.push(ele);      }    });    console.log(newArr); // ["鳴人", "佐助", "小櫻"]