JavaScript学习笔记（七）——JS中的数组

数组

数组是js中的引用类型之一，装载一组数据的容器。

引用类型和值类型的区别：
存放位置：引用类型存放在内存里，堆内存；值类型存放在内存里，栈内存

数组的定义

• 字面量
  语法：

var arr = [];

• 构造函数
  语法：

var arr = new Array();

传参规则：

• 当没有参数时， 定义的是一个空数组
• 当参数只有一个并且是数字时，该数字表示数组的长度
• 当参数有多个时，参数就是每一个成员

• 构造函数
  语法：

var arr = Array();

传参规则：

• 当没有参数时， 定义的是一个空数组
• 当参数只有一个并且是数字时，该数字表示数组的长度
• 当参数有多个时，参数就是每一个成员

        var arr = []; // 在栈内存中存放的是数组arr在堆内存中的地址
        var arr1 = []; // 在栈内存中存放的是数组arr1在堆内存中的地址
        // 引用类型比较的时候，比较的是地址,虽然arr和arr1都是空数组，但是地址不一样
        console.log(arr === arr1); // false

        var arr2 = [];
        var arr3 = arr2;
        console.log(arr2 === arr3); // true

        // 值类型比较的时候，比较的是值
        var a = 10;
        var b = 10;
        console.log(a === b); // true

数组的使用

• 存储数据
  数据是以一定的顺序存储在内部，每一个数据都有一个序号 ，这个序号叫做下标 或者 索引
  语法：

arr[idx] = value;

• 访问数据
  语法：

arr[idx] 

当该代码单独出现，就表示要使用数据。就会去读取对应的数据。如果数据存在，就得到，如果不存在就读取不到，返回undefined。

数组的length属性

• 数组是一组数据，length属性表示这个数组中的内容的个数。也就是数组的长度
• length可读可写
• 当设置它的时候，表示要修改该数组的长度。数组的长度会发生变化。
• 当读取时，会实时返回数组的当时的长度。

    var arr = [1, 2, 3, 4];
    console.log(arr.length); // 4
    arr.length = 1; // 修改数组的长度
    console.log(arr); // 输出 [1]
    console.log(arr.length); // 1

循环数组

• for循环

    // 定义数组
    var arr = [1, 2, , , , 6, , , , 10];
    // 循环数组
    for (var i = 0; i < arr.length; i++) {
        console.log(arr[i]);
    }
    //  输出 1 2 undefined undefined undefined undefined 6 undefined undefined undefined 10

• for in循环

    // 定义数组
    var arr = [1, 2, , , , 6, , , , 10];
    // 循环数组
    for (var i in arr) {
        console.log(arr[i]);
    }
    // 输出 1 2 6 10 不会输出undefined

数组常用方法

• push(item)：在数组末尾添加任意项，会改变原数组，返回值是数组的长度
• pop()：在数组末尾移除一项，会改变原数组，返回值是被移除的成员
• unshift(item)：在数组头部添加任意项，会改变原数组，返回值是数组的长度
• shift()：在数组头部删除一项，会改变原数组，返回值是被移除的成员
• concat()：拼接，可以给数组添加一个或多个元素，不会改变原数组
• reverse()：反转，将原数组的顺序逆序，返回值是原数组，会改变原数组
• sort：排序，分为升序、降序，返回值是原数组
• slice(m, n)：截取，从原数组中获取某一部分的元素，即获取子数组
• splice()：从任意位置对原数组进行添加、删除元素
• join()：用于将数组转为字符串
• indexOf()：从数组的头部开始搜索，将返回跟所要查找的内容完全相同的第一个元素的下标
• lastIndexOf()：从数组的尾部开始搜索，将返回跟所要查找的内容完全相同的第一个元素的下标
• toString()：将数组里面的每一个元素都强制类型转换成字符串

        // push(item)：在数组末尾添加任意项，会改变原数组，返回值是数组的长度
        var arr1 = [2,3,4];
        arr1.push(5);
        console.log(arr1);
        arr1.push(6,7);
        console.log(arr1);
        arr1.push(8,["a","b"]);
        console.log(arr1);

        // pop()：在数组末尾移除一项，会改变原数组，返回值是被移除的成员
        arr1.pop();
        console.log(arr1);
        arr1.pop();
        console.log(arr1);
        
        // unshift(item)：在数组头部添加任意项，会改变原数组，返回值是数组的长度
        arr1.unshift(1);
        console.log(arr1);
        arr1.unshift("A","B");
        console.log(arr1);

        // shift()：在数组头部删除一项，会改变原数组，返回值是被移除的成员
        arr1.shift();
        console.log(arr1);
        arr1.shift();
        console.log(arr1);

        // concat()：拼接，可以给数组添加一个或多个元素，不会改变原数组
        // 如果给concat传一些数组作为参数，它会把这些数组拆分再把拆分后的元素添加到原数组中。
        // 注意：只拆分数组最外一层
        var arr2 = ["东","西","南","北"];
        var arr3 = arr1.concat(arr2);
        console.log(arr3);
        var arr4 = [8,[9,10]];
        var arr5 = arr1.concat(arr4);
        console.log(arr5);

        // reverse()：反转，将原数组的顺序逆序，返回值是原数组，会改变原数组
        var arr6 = [1,2,3,4,5];
        arr6.reverse();
        console.log(arr6);

        // sort：排序，分为升序、降序，返回值是原数组
        var arr7 = [23,-3,2,0,50];
        // 升序：返回a - b
        var arr7_1 = arr7.sort(function(a, b){
            return a - b;
        });
        console.log(arr7_1);
        // 降序：返回b - a
        var arr7_2 = arr7.sort(function(a, b){
            return b - a;
        });
        console.log(arr7_2);
        // 注意：如果不传递函数，数组成员将按照字符串的比较进行排序
        var arr8 = [5, 22, 2, -30, 60, -50];
        var arr8_1 = arr8.sort();
        console.log(arr8_1);

        // slice(m, n)：截取，从原数组中获取某一部分的元素，即获取子数组
        // slice有两个参数，参数一表示子数组的起始位置，参数二表示子数组的终止位置（不包含终止位置的元素）。左闭右开
        // 注意：如果省略终止参数，则会返回从当前位置到数组末尾的所有内容。
        // 在这个方法中，下标可以使用负值来表示倒数的元素
        // 注意：参数二要大于参数一才能截取到元素，否则将是[]
        var arr9 = [1, 2, 3, 4, 5];
        var arr9_1 = arr9.slice(1,4);
        console.log(arr9_1); // 2 3 4 
        var arr9_2 = arr9.slice(2);
        console.log(arr9_2); // 3 4 5
        var arr9_3 = arr9.slice(0,-2);
        console.log(arr9_3); // 1 2 3
        var arr9_4 = arr9.slice(-3);
        console.log(arr9_4); // 3 4 5
        // 如果没有参数，将截取全部
        var arr9_5 = arr9.slice();
        console.log(arr9_5); // 1 2 3 4 5

        // splice()：从任意位置对原数组进行添加、删除元素
        // 参数一表示起始修改位置的数组下标，参数二表示需要删除的元素个数（如果不想删除任何元素就传入0）
        // 如果没有参数二，则表示从第一个参数截取到末尾
        // 注意：在参数一,参数二之后的每一个参数都表示数组的新成员（如果是数组，不用拆分）
        // 返回值是被删除的元素组成的数组，会改变原数组
        // 如果只有一个参数，表示从该下标开始（包括它本身）都删除
        var arr10 = [1, 5, 7];
        console.log(arr10);
        
        var arr10_1 = arr10.splice(1, 0, 2, 3, 4);
        console.log(arr10_1); // 返回[]
        console.log(arr10); // 1 2 3 4 5 7
        
        var arr10_2 = arr10.splice(5, 0, 6);
        console.log(arr10_2); // 返回[]
        console.log(arr10); // 1 2 3 4 5 6 7

        // 删除
        var arr10_3 = arr10.splice(1, 2);
        console.log(arr10_3); // 返回[2, 3]
        console.log(arr10); // 1 4 5 6 7

        // 添加
        var arr10_4 = arr10.splice(2, 1, "a", "b");
        console.log(arr10_4); // 返回[5]
        console.log(arr10); // 1 4 a b 6 7
        var arr10_5 = arr10.splice(1, 0, ["东","南","西","北"], "A", "B");
        console.log(arr10_5); // 返回[]
        console.log(arr10); // 1 [东, 南, 西, 北] A B 4 a b 6 7

        // 修改
        var arr10_6 = arr10.splice(2,1,"A变成了AA");
        console.log(arr10_6); // 返回[A]
        console.log(arr10); // 1 [东, 南, 西, 北] A变成了AA B 4 a b 6 7

        // 如果只有一个参数，表示从该下标开始（包括它本身）都删除
        var arr10_7 = arr10.splice(2);
        console.log(arr10_7); // 返回[A变成了AA B 4 a b 6 7]
        console.log(arr10); // 1 [东, 南, 西, 北] 

        // join()：用于将数组转为字符串
        // 参数是拼接符号，默认是逗号
        // 返回值是拼接完毕后的字符串
        var arr11 = ["a", "b", "c"];
        var str1 = arr11.join();
        console.log(str1); // a,b,c
        var str2 = arr11.join("+");
        console.log(str2); // a+b+c
        var str3 = arr11.join(" ");
        console.log(str3); // a b c

        // 数组搜索：查找的时候用的是全等判定
        var arr12 = ["a", "b", "c", "d", 1, 2, 3, 4];
        // indexOf()：从数组的头部开始搜索，将返回跟所要查找的内容完全相同的第一个元素的下标
        var str4 = arr12.indexOf("d");
        console.log(str4); // 3
        // lastIndexOf()：从数组的头部开始搜索，将返回跟所要查找的内容完全相同的第一个元素的下标
        var str5 = arr12.indexOf(2);
        console.log(str5); // 5
        // 注意：如果没找到，返回-1
        var str6 = arr12.indexOf(10);
        console.log(str6); // -1

        // console.log(null == undefined); // true
        // console.log(null === undefined); // false
        // console.log(null == false); // false
        // console.log(undefined == false); // false

        // toString()：将数组里面的每一个元素都强制类型转换成字符串
        var arr13 = [1, 2, 3, 4];
        console.log(arr13);
        console.log(arr13.toString());
        var arr14 = [1, 2, 3, 4, ["a", "b"]];
        console.log(arr14);
        console.log(arr14.toString());

某个公司采用公用电话传递数据数据是四位的整数，在传递过程中是加密的
加密规则如下：

• 每位数字都加上5
• 然后用除以10的余数代替该数字
• 再将第一位和第四位交换
• 第二位和第三位交换

请编写一个函数，传入原文，输出密文

        var num = +prompt("请输入数据：","");
        function encryption(num){
            var temp;
            // 原文
            // console.log("原文：" + num);
            document.write("原文：" + num + "<br>");

            // 个位数字
            var ge = num % 10;
            // 十位数字
            var shi = parseInt(num / 10) % 10;
            // 百位数字
            var bai = parseInt(num / 100) % 10;
            // 千位数字
            var qian = parseInt(num / 1000);

            // 每位数字都加上5，然后用除以10的余数代替该数字
            ge = (ge + 5) % 10;
            shi = (shi + 5) % 10;
            bai = (bai + 5) % 10;
            qian = (qian + 5) % 10;

            // 第一位和第四位交换
            temp = ge;
            ge = qian;
            qian = temp;

            // 第二位和第三位交换
            temp = shi;
            shi = bai;
            bai = temp;

            // 密文
            // console.log("密文：" + qian + bai + shi + ge);
            document.write("密文：" + qian + bai + shi + ge)
        };
        encryption(num);

定义一个含有30个整型元素的数组，按顺序分别赋予从2开始的偶数；然后按顺序每五个数求出一个平均值，放在另一个数组中并输出。

        function arr_num(){
            var arr1 = [];
            var arr2 = [];
            var sum = 0;
            for (var i = 0; i < 30; i++){
                // 向数组arr1中添加元素
                arr1.push((i+1)*2);
                // 将每次添加到数组的元素相加
                sum += (i+1)*2;
                // 当向数组arr1中添加元素，元素下标能被5整除就求一个平均数
                if((i+1) % 5 === 0){
                    var ave = sum / 5;
                    // 将每五个元素的和的平均数添加到数组arr2中
                    arr2.push(ave);
                    // 将sum清零
                    sum = 0;
                }
            }
            // document.write(arr2);
            console.log(arr2);
        }
        arr_num();

通过循环按行(hang)顺序给一个5×5的二维数组a赋1到25的自然数试编程。

        function fun(){
            var arr1 = [];
            var arr2 = [];
            for(var i = 1; i <= 25; i++){
                // 向二位数组中的每一个一维数组添加元素
                arr2.push(i);
                // 每五个元素组成一个一维数组
                if(i % 5 == 0){
                    // 将一维数组添加到二维数组里面
                    arr1.push(arr2);
                    // 将一维数组清空
                    arr2 = [];
                }
            }
            console.log(arr1);
        }
        fun();