(五).JavaScript的数组

1. 数组

1.1 数组的基础

数组：同种或不同数据类型数据的有序集合
功能：同时存储多个数据
数据：常量 变量 表达式 数组 函数 对象
定义方式：字面量定义或者构造函数定义

1. 字面量定义数组（本质上也是使用new Array()创建数组）

       // 1. 定义了一个空的数组
       var arr1 = [];
   
       // 2. 定义一个数组，数组中有一个数据
       var arr2 = [1];
       var arr3 = ['dog'];
   
       // 3. 定义一个数组，数组中有多个数据
       var arr4 = [1, true, '我的世界'];
       /*  结果
           Array(3)
               0: 1
               1: true
               2: "我的世界"
               length: 3
               [[Prototype]]: Array(0)
       */
   

2. 构造函数定义数组

       // 1. 定义了一个空数组
       var arr1 = new Array();
   
       // 2. 定义了一个数组，数组中有一个元素
       var arr2 = new Array('world');
   
       // 3. 定义了一个数组，数组中有多个元素
       var arr3 = new Array('我的世界', 1, 2, true, 1);
       /*
           Array(5)
               0: "我的世界"
               1: 1
               2: 2
               3: true
               4: 1
               length: 5
               [[Prototype]]: Array(0)
       */
   
       // 4. ☆☆☆☆☆☆定义了一个数组，数组长度是5
       // 	5个值为undefined 
       var arr4 = new Array(5);
       /*
           Array(5)
               length: 5
               [[Prototype]]: Array(0)
       */
   

1.2 数组的索引和长度

xxx.yyy：对象.属性

xxx[yyy]：xxx是对象 xxx[yyy]是对象的属性

xxx.yyy()：对象.函数()

1. 长度（数组对象名.length）

       // 1. 查 访问数组长度
       arr.length()
   
       // 2. 删 通过数组长度删除元素
       arr.length = 2;
   
       // 3. 增 (☆☆☆推荐☆☆☆)通过数组长度增加元素
       // 原理：数组的最大索引值 = 数组长度 - 1
       arr[arr.length] = '我是索引为4的元素';
   

2. 索引（数组对象名[索引]）

       // 索引：通过索引操作数组中的指定数据
   		// 数组有序体现在，下标从0开始
       var arr = ['dog', true, 1, 'happy'];
   
       // 语法：数组对象名[索引]
       // 1. 查 拿到索引为1的元素
       console.log(arr[1]);
   
       // 2. 改 修改索引为1的元素值为false
       arr[1] = false;
       console.log(arr[1]);
   
       // 3. 增 通过索引增加元素 '我爱中华'
       //    增加或删除元素时，数组长度自动变化
       arr[4] = '我爱中华';
       console.log(arr);
   
       // 4. 增 特殊情况
       //    当在指定位置添加元素，中间空下的索引位置元素为 undefined
       arr[8] = '我是第九个元素';
       console.log(arr);
       // (9) ['dog', false, 1, 'happy', '我爱中华', 空属性 × 3, '我是第九个元素']
       // 其实可以理解数组就是无限长的，除了用户自定义的其他位置都是undefined
   

1.3 数组的遍历

    // 数组遍历
    var arr = [1, 2, 3, 4];
    for (var i = 0; i < arr.length; i++) {
        console.log(arr[i]);
    }

1.4 数组的案例

1. 数组求和

       var arr = [11, 22, 33, 44, 55];
       var sum = 0;
       for (var index = 0; index < arr.length; index++) {
           sum += arr[index];
       }
       console.log(sum);
   

2. 求数组的最大值，最小值，平均值

       var arr = [11, 22, 33, 44, 55];
       var max = arr[0];
       var min = arr[0];
       var sum = arr[0];
       for (var index = 1; index < arr.length; index++) {
           if (arr[index] < min) {
               min = arr[index];
           }
   
           if (arr[index] > max) {
               max = arr[index];
           }
   
           sum += arr[index];
       }
       console.log('最大值:' + max);
       console.log('最小值:' + min);
       console.log('平均值:' + sum / arr.length);
   

3. 合并数组

       var arr = [11, 22, 33, 44, 55];
       var arr1 = ['aa', 'bb', 'cc', 'dd', 'ee'];
       for (var index = 0; index < arr1.length; index++) {
           // 这里利用数组的长度来实现添加元素
           arr[arr.length] = arr1[index];
       }
       console.log(arr);
   

4. 反转数组

       // 方法1 翻转原先数组本身
       var arr = [11, 22, 33, 44, 55];
       var temp = 0;
       for (var index = 0; index < arr1.length / 2; index++) {
           temp = arr[index];
           arr[index] = arr[(arr.length - 1) - index];
           arr[(arr.length - 1) - index] = temp;
       }
       console.log(arr);
   
       // 方法2 倒序遍历，赋值到新数组
       var arr = [11, 22, 33, 44, 55];
       var newArr = [];
       for (var i = arr.length - 1; i >= 0; i--) {
           newArr[newArr.length] = arr[i];
       }
       console.log(newArr);
   

5. 数组去重

       // 新旧数组 标志位 的思路
       var arr = [11, 22, 11, 44, 22, 55, 66, 11];
       var newArr = [];
       var flag = true;
       for (var i = 0; i < arr.length; i++) {
           for (var j = 0; j < newArr.length; j++) {
               if (arr[i] == newArr[j]) {
                   flag = false;
                   break;
               }
           }
           // 添加元素到新数组
           if (flag) {
               newArr[newArr.length] = arr[i];
           }
           // 重置flag
           flag = true;
       }
       console.log(newArr);
   

6. 冒泡排序

       // 冒泡排序 var arr = [47, 65, 12, 78, 3]
       var arr = [47, 65, 12, 78, 3];
       var temp = 0;
       // 轮次
       for (var i = 0; i < arr.length - 1; i++) {
           // 比较次数
           for (var j = 0; j < arr.length - 1 - i; j++) {
               if (arr[j] > arr[j + 1]) {
                   temp = arr[j];
                   arr[j] = arr[j + 1];
                   arr[j + 1] = temp;
               }
           }
           // console.log(arr);
       }
       console.log(arr);
   

1.5 多维数组

1. 定义：一个数组中某个数组又是一个数组

2. 示例：

       // 二维数组
       var arr = [
           [1, 2],
           ['happy', '我的世界']
       ];
   
       console.log(arr[0][0]); //1
   
       // 三维数组
       var arr = [
           [[1, 2], [3, 4]],
           [['happy', '我的世界'], ['sad', '我的世界']]
       ];
       console.log(arr[1][0][1]); //1