JaveScript数组(JS知识点归纳五)

Posted 2020-10-21 AmorR

1.概念

    a)作用--用于保存多个数据,便于对数据的使用
    b)数组元素--数组中的数据
    c)索引--数组中的元素按照下标(数值)的方式排列(从0 开始),依次递增(也有可能是字符串的类型--不用)
    d)长度--数组中的元素个数--length

? 2.创建方式

    a)构造函数创建方式 var arr = new Array (1,2,3);
    b)字面量方式创建  var arr = [1,2,3];
    c)获取指定元素   arr[index]  
    d)设置元素   arr[index]=要设置的值

? 3.length

    a)与index的关系-index= length-1
    b)length  > 元素个数   没有意义 --会产生误导
    c)length  < 元素个数   后面多出的元素会被删除
    d)清空数组  arr.length-0;--修改数组的元素值
                arr=[];--更换为新的数组

? 4.数组遍历

    a)使用for循环
    b)反向遍历 for(var=  arr.length-1; i >=0;i-- ){ 从后往前取值  };

    练习:
        1)将0-99之间的数放入到数组中

            var arr=[];
            for (var i = 0 ; i <100,i++){
                arr[i]=i;
            }
            console.log(arr);

 

        2)将1-100所有数放入到数组中

            var arr= [ ];
            for (var i = 0 ; i<=100;i++){
                arr[i-1]=i;//索引默认从0 开始,-1就是第一个索引是1
                arr[arr.length]=i;
            }
            console.log(arr)

 

        3)将1-100之间的所有偶数放入到数组中

          var arr = [ ];
            for (var i = 1 ; i <=100 ; i++){
                if (i%2===0){
                    arr[arr.length]=i;
                }
            }
            console.log(arr);        

 

        4)求一组数中的最大值和最小值，以及所在位置（索引值）

                 var arr= [ 1,5,4,33,6,67,999];
                var max=arr[0];//声明变量
                var min =arr[0];
                var maxIndex=0;//声明索引值
                var minIndex=0;
                    for (var i = 0 ; i <arr.length;i++){
                        if (max<arr[i]){
                        max = arr[i];
                            maxIndex=i;//索引值=i
                        }
                        if (min>arr[i]){
                            min=arr[i];
                            minIndex=i;
                        }
                    }
                console.log(max, maxIndex);
                console.log(min, minIndex);

 

        5)将字符串数组用|或其他符号分割

              var arr = ["abc","asd","asdqwe"];
                var str =[];
                var fuhao="-";
                for (var i = 0 ; i < arr.length;i++){
                    str=str+fuhao+arr[i];
                }
                console.log(str);

 

5.翻转数组

     a)反向遍历

        var arr=["a","b","c"];
        var resultArr=[];
        for (var i = arr.length-1;i>=0;i++){
            resultArr[resultARR.length]=arr[i];
        }
        console.log(arr);

 

    b)直接在原有数组的基础上进行翻转

         var arr=["a","b","c"];
         var temp;
         for (var i = 0 ; i<parseInt(arr.length/2-1);i++){
             temp=arr[i];
             arr[i]=arr[arr.length-1-i];
             arr[arr.length-1-i]=temp;
         }
         console.log(arr);

 

? 6.冒泡排序

	 a)基本的冒泡排序

           var arr = [1,2,6,4,9,2];
            var j,temp;
            for(var i = 0 ; i < arr.length-1;i++){
                for (j = 0 ; j <arr.length -i -1;j++){
                    if (arr[j]>arr[j+1]){
                        temp = arr[j];
                        arr[j]=arr[j+1];
                        arr[j+1]=temp;
                    }
                }
            }
            console.log(arr);

 

    b)冒泡排序的优化---假设成立
        1)找到不确定的点,设置假设条件
        2)找到可以让假设失败的条件,设置flag=false
        3)验证flag的结果

            var arr = [1,2,6,4,9,2];
            var j,temp,flag;
            for(var i = 0 ; i < arr.length-1;i++){
                //假设是真
                flag=true;
                for (j = 0 ; j <arr.length -i -1;j++){  
                    if (arr[j]>arr[j+1]){
                        temp = arr[j];
                        arr[j]=arr[j+1];
                        arr[j+1]=temp;
                        //假设不成立
                        flag =false;
                    }
                }
                //是真--成立--跳出
                if (true){
                    break;
                }
            }
            console.log(arr);

? 7.数组去重

        a)假设成立法
      

            var arr = [1,2,6,4,9,2];
            var j,temp,flag;
            for(var i = 0 ; i < arr.length-1;i++){
                //假设是真
                flag=true;
                for (j = 0 ; j <arr.length -i -1;j++){  
                    if (arr[j]>arr[j+1]){
                        temp = arr[j];
                        arr[j]=arr[j+1];
                        arr[j+1]=temp;
                        //假设不成立
                        flag =false;
                    }
                }
                //是真--成立--跳出
                if (true){
                    break;
                }
            }
            console.log(arr);

 

    b)计数法
      

         var arr= [1,1,1,12,2,2,234,346,5,6,78,0];
        var resultArr=[];
        resultArr[0]=arr[0];
        var j ,count;//设置计数
        for(var i = 0 ; i <arr.length;i++){
            count=0;//针对arr[i]设置新的计数
            for(j = 0 ; j <resultArr.length;j++){
                if(resultArr[j]===arr[i]){//相等不执行
                    count++;
                    break;
                }
            }
            if(count===0){检测count的值
                resultArr[resultArr.length]=arr[i];
            }
        }
        console.log(resultArr);

 

    c)循环特性--利用循环特性
        //数组去重：有一个数据重复的数组，我们需要通过处理，得到一个不重复的数组
      

         var arr = [1, 1, 2, 3, 3, 2, 4, 5, 5, 4, 3, 2, 1];
        //1 创建一个结果数组
        //结果数组一定不能重复
        var resultArr = [];
        resultArr[0] = arr[0];
        var j;
        //利用循环特性的解题方式实际上通过判断循环变量和数组长度之间的关系，去检测循环的结束方式
        for (var i = 1; i < arr.length; i++) {
        for (j = 0; j < resultArr.length; j++) {
            if (arr[i] === resultArr[j]) {
            //如果找到相等的项，执行break;
            break;
            }
        }
        //在内循环结束后，检测j和resultArr.length的关系
        if (j === resultArr.length) {
            //说明循环正常结束,说明没有执行过跳出，意味着没有找到相等的元素，进行放入操作
            resultArr[resultArr.length] = arr[i];
        }
        }
        console.log(resultArr);

 

? 8.数组的类型检测--复杂数据类型

     a)Array.isArray([1,2,3]); 返回值--布尔  数组==true  IE9以下不支持
    b)[1, 2, 3] instanceof Array
    c)Object.prototype.toString.call([1,2,3]);

? 9.简单数据类型与复杂数据类型的区别

    a)保存数据个数上不同
        简单--一个值
        复杂--多个值
    b)在内存中的保存方式
        简单--具体值--值类型--保存于栈中
        复杂--具体值的指向(箭头)--引用类型--保存于堆总(初学者)
    c)进行复制操作是,结果不同
        简单--复制前后无关联  复制粘贴
        复制--复杂前后的结果是一样的  设立快捷方式

? 10.二维数组--数组中还有数组

    var arr = [1,2,3,[4,5,6]];
    遍历:

       var j ,temp;
        for (var i = 0 ; i <arr.length ; i ++){
            temp = arr[i];//进行保存,方便下次使用
            if (temp instanceof Array){//检测是否是数组
                for ( j = 0 ; j <temp.length ; j ++){
                    console.log(temp[j]);//是数组,打印出来
                }
            }else{
                console.log(temp);不是数组,直接打印
            }
        }

 

 

 对于,数组的大概也就是这么多.

从写博的这段时间,越来越纠结,每一句话都要去想好久,自己写的对不对,大家看的是否可以理解,我归纳的是否有遗漏等.. 

但是,这段时间却是成长了很多.我会慢慢地去完善,改善自己的.

 

PS:2018-01-20,这天,我在北京798熊猫慢递,写了一封给某某人的信,我希望这封信永远不会被寄出,这个人永远不会看到信..安可