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上的大量数组操作方法。