Js 數組(一）：基礎應用

（一） Js 數據類型

　　分為基本數據類型以及引用類型

　　基本數據類型有 null,undefined,Boolen,Number,String，還有一種復雜數據類型 Object。

        var var1 = "xianrongbin", var2 = false, var3 = null, var4 = undefined, var5 = 123;
        console.log(typeof var4);

        var var6 = [1, 23, 5];
        console.log(typeof var6);

　　 這里，其實只需一個var的，為了區別基本數據類型與復雜數據類型，寫了兩個var 關鍵字。

       將所有的變量定義在一個var后面，有益提升程序運行效率。

       如果在一個函數中，不標注 var，則該變量是全局變量，是window的變量，因為所有全局變量都是由window承擔的。

　　　　 function testVar() {
            num = 1;
        }
        testVar();
        console.log(window.num);

　　　這里輸出1，如果在 "num" 前加上var，輸出則會報錯。

        基本數據類型與值類型，一個是傳值，一個是改變地址。   

  var var6 = [1, 23, 5];   
        function changeValue(obj) {
            obj.pop();
        };
        
        changeValue(var6);
        console.log(var6);

        var num = 1;
        function changeNum(num) {
            num = num + 1;
        };
        console.log(num);

　　 輸出的值是 [1,23]  1。 這點很重要。 這里於C#有很大的不同。

（二） 數組操作

       數組類型是Object,數組是值得有序集合。

　　每個值叫做元素，每個元素在數組中都有數字位置的編號，即索引。

　　數組是弱類型的，數組中可以含有不同類型的元素。

　　　　var arr=[1,'2',[1,2],null]

　　數組中允許最后面有一個多余的 ‘，’，

　　　　var arr1=[,,]  --undefined,undefined

　　1、數組最大長度

　　　　最大長度是 2^23-1

　　2、創建數組

　　　  var arr=new Array();

　　　　var arrWidthLength=new Array(1000);

　　　　var arrLikesLiteral=new Array(1,2,3);

　　    --new  其實是可以省略的

     3、數組元素的增刪

　　　 數組是動態的，無需指定大小

　　　 arr[arr.length]  --尾部添加一個元素

　　　 arr.length-=1   --刪除尾部元素

      若要     往數組尾添加一個或多個元素，可用push(),

                 刪除最后一個元素，可用pop(),

　　           刪除數組頭一個元素，可用shif(),

　　　　　　delete arr[2] --第三個元素索引不存在，仍然會存在這個位置，值為undefined

　　　　　　向數組頭添加一個或多個元素，可使用unshift,

　　　

        var testArry = [1, 2, 3, 4, 5, 6];
        testArry.push(7);
      
        testArry.pop();

        testArry.shift();

        testArry.unshift('unshift1', 'unshift2');

        concatArry= testArry.concat('concat1');

        var index = testArry.indexOf('concat1');
        testArry.splice(index, 1);

        testArry.splice(0, 1, 'replace1','replace2');

　　結果是:   ["replace1", "replace2", "unshift2", 2, 3, 4, 5]

　　4.數組迭代

　　　　我們可以使用

　　　　　　for(i in arr) { console.log(arr[i]);

　　　　如果我們在數組的prototype添加屬性a=‘testa',則輸出時也會輸出 testa

　　　   因此需要判斷 if(arr.hasOwnProperty(i)) {  }

　　5.稀疏數組

　　　　稀疏數組並不含有從0開始的連續索引，一般length屬性值比實際元素個數大。

　　　　var arr1=[undefined];

　　　　var arr2=new Array(1);

　　　　0 in arr1;---true   0 in arr2; ---false

　　　　arr1.length=100;  arr1[99]=123;  99 in arr1; --true  98 in arr1;  --false

　　6.五個迭代函數

　　這五個迭代函數是.every .some .filter .forEach  .map他們都有三個參數(item,key,value),key是從0開始計數，后兩個參數可選用。

　　. every()      對數組中的每一項運行給定的函數，如果該函數對每一項都返回true，則返回true   

　　. some()      對數組中的每一項運行給定的函數，如果該函數對任意一項返回true，則返回true  

　　. filter()       對數組中的每一項運行給定的函數，返回該函數返回true的項組成的數組，不會影響原函數

　　. forEach()   對數組中的每一項運行給定的函數，這個方法沒有返回值  

　　. map()        對數組中的每一項運行給定的函數，返回每次函數調用的結果組成的數組，不會影響原函數

     用法如下

var testArry = [1, 2, 3, 4, 5, 6];
        var isAllBig2 = testArry.every(function (item) {
           return item > 2;
        });
        console.log(isAllBig2);

        var isSomeBig2 = testArry.some(function (item) {
            return item > 2;
        });
        console.log(isSomeBig2);

        var filterArray = testArry.filter(function (item) {
           return item > 2;
        });
        console.log(filterArray);
       
        var mapArray = testArry.map(function (item) {
           return item + 2;
        });
        console.log(mapArray);

        var forEachResult = testArry.forEach(function (item) {
            if (item >5) {
                console.log(item);
            }
        });

　　其中，.forEach是無返回值，而其他幾個是有返回值的，這點需要注意。

　　上述輸出結果分別是 

　　　　false

　　　　true

　　　　[3, 4, 5, 6]

　　　　[3, 4, 5, 6, 7, 8]

　　　　6

 　　

　　 { }=>Object.prototype

　　  []=>Array.prototype

     

　　 1.Array.prototype.reverse

　　　　　會對原函數造成逆序

　　　　   var arr=[1,2,3];  arr.reverse();  arr;---[3,2,1]

　　 2.Array.prototype.sort

　　　　 是按照字母進行排序的，原數組也會被修改,即改變指針；

　　　　 arr.sort(function(a,b)){ return a-b; });

      3.Array.prototype.contact

　　　　  contact不會改變原有的數組，只是返回原數組的一個副本。

　　        arr.contact([12,11],13); --里面有一維數組，會被拉平一次

　　　　   arr.contact([12,[13,14]]);     -有多維數組，最外的一層數組被拉平，里層數組不會被拉平

　　

     4.Array.prototype.slice  返回部分數組

　　　  

　　　　 var arr=[1,2,3,4,5];

　　　　 arr.slice(1,3); --- 2,3  左開右閉區間 ，若省略第二個參數，表示刪除index后面所有的元素

　　　　 arr.slice(1,-1); --- 2,3,4  -1表示從最后一個元素

　　

　　5.Array.prototype.splice 數組拼接函數

 

　　　　　  需要知道某個元素在數組中的位置，可用indeOf(元素名稱)，不存在返回-1，

　　　　　　知道元素的位置后    5.1 需刪除某個元素，則使用splice(index,1)    ---若省略第二個參數1，表示刪除index后面所有的元素

　　　　　　　　　　　　　　    5.2 需要刪除某個元素，替換成1個或多個元素，則使用splice(index,1,a,b...),

　　　　　　　　　　　　　　    5.3 需要在某個元素后插入1個或多個元素，      則使用splice(index,0,a,b...)

　　

　　　6. Array.prototype.reduce & reduceRight 數組兩兩操作，然后返回一個值

　　　　　　var arr=[1,2,3];

　　　　　　var sum=arr.reduce(function(x,y){

　　　　　　　　retrun x+y;

　　　　　　},0); ---0表示傳入的第一個值

 

　　　　7.Array.isArray(..) 判斷是否是數組

　　　　     或者  ... instanceof Array

　　　　　　　　 .constructor===Array

 

　　  數組是對象，對象不一定是數組，都可以當做對象添加刪除屬性

　　  數組自動更新length，按索引訪問數組常常比訪問一般對象屬性明顯迅速，

　　  數組對象繼承Array.prototype上的大量數組操作方法。