本文共 8067 字，大约阅读时间需要 26 分钟。

三、数组数据类型Array

• 复杂数据类型，存储一堆数据
  => 不是按照键值对存储
  => 按照索引进行存储的(序号)

3.1 数组的创建

1. 字面量创建[ ]

//创建一个空数组var arr = [];

创建的时候直接添加成员	=> 直接写在中括号中，多个数据使用逗号(,)隔开

// 字面量创建直接添加数据  var arr = ['hello','world','你好','世界'];  console.log(arr);

注：可以观察到数组也是有length属性的，也有索引，从0开始。

2. 内置构造函数Array()创建

创建的时候直接添加成员，分为3种情况：		1.不传递函数			=> 创建一个空数组		2.传递一个正整数			=> 这个参数表示数组的长度		3.传递多个数据			=> 每一个数据都是放在数组里面的数据			=> 没有表示长度的数据

// 1. 不传递函数，创建一个空数组var arr = new Array();console.log(arr);

// 2. 传递一个数字var arr = new Array(100);console.log(arr);

// 3. 传递多个数据var arr = new Array(10, 20, 30);console.log(arr);

3.2 数组的操作

+ 数组有一个 length 属性	=> 索引也是一个读写的属性		=> 读：获取数组的长度		=> 写：设置数组的长度			-> 当你设置的比本身长度小，那么就相当于截取			-> 当你设置的比本身长度大，那么多出来的就是用空补齐

var arr = ['你好','世界'];	// console.log(arr.length);   // 2		// 相当于只保留第一个数据，剩下的删除    arr.length = 1;	console.log(arr);

// 把数组的长度强制设置成 100， 不够的用空补齐arr.length = 100;console.log(arr);

+ 数组的排列	=> 按照索引进行排列的	=> 索引：		-> 从 0 开始，依次 +1		-> 最后一位的索引，就是 length - 1	=> 索引也是一个读写的属性		=> 读：获取到指定索引位置的数据			-> 如果数组确实有这个索引位置，那么就是这个位置的数据			-> 如果数组没有这个索引位置，那么就是undefined		=> 写：设置指定索引位置的数据			-> 如果有这个索引位置，那就是给这个索引位置设置			-> 如果没有这个索引位置，就是添加			-> 如果这个数字超出length，那么中间的位置用空补齐

// 使用索引读取数组中的数据console.log(arr[0]);  //因为数组有[0]数据位置,所以得到的是'你好'console.log(arr[99]);  //没有，undefined        arr[1] = 'world';arr[2] = '新来的';arr[20] = '最后一个';console.log(arr);

+ 数组的遍历	=> 因为数组是按照索引进行排列的	=> for 循环能给我们提供一组有规律的数字	=> 使用 for 循环遍历一个数组+ 数组也是一个对象	=> 数组除了可以按照索引排列一些数据	=> 还可以当作对象使用，使用 点语法 存储一些数据	=> 你把数组当作对象使用，使用for循环来遍历的时候，他的成员是不占用 length 位置的	=> 你把数组当作对象使用，使用for in循环来遍历的时候		-> 里面的每一个索引位置，每一个 key 都会被遍历出来	=> 一般不会用它当作对象用

// 数组当作对象  // 当一个数组创建好后，他这个名字就可以当做对象使用存储数据  var arr = ['你好','世界'];    arr.age = 18;  arr.gender = '男';  // age 和 gender 成员不影响循环遍历数组  for(var i = 0; i < arr.length; i++){
          console.log(arr[i]);  }  console.log(arr);

var arr = ['你好','世界'];    arr.age = 18;  arr.gender = '男';  // for in 循环  for(var key in arr){
         console.log(key);  }  console.log(arr);

console.log(arr[key]);

3.3 逻辑思维锻炼-排序方法

冒泡排序

把一个乱序的数组按照一定的算法结构排序好

口诀

1. 学会交换数组里面两个数据的位置  => 假设 [0] 和 [1] 位置的数据交换  2. 先遍历循环数组  => 让前一个数字和后一个数字比较大小  => 如果前一个比后一个大，就交换位置  => 执行一遍后，最大的数字一定在最后  3. 让步骤二重复执行  => 如果有 9 个数字，八遍  => 如果有 100 个数字，99遍

// 准备一个数组var arr = [9, 2, 6, 4, 3, 8, 5, 7, 1];// 让步骤二重复执行for(var j = 0; j < arr.length; j++){
       // 循环遍历数组    for(var i = 0; i < arr.length; i++){
           // 判断前一个位置和后一个位置的大小        if(arr[i] > arr[i+1]){
               var tmp = arr[i];            arr[i] = arr[i + 1];            arr[i + 1] = tmp;        }    }}

优化1:     + 单独看步骤二遍历数组     for(var i = 0; i < arr.length; i++){     // 判断前一个位置和后一个位置的大小     if(arr[i] > arr[i+1]){         var tmp = arr[i];         arr[i] = arr[i + 1];         arr[i + 1] = tmp;     }     + 代码执行     + 数组的 length 是 9       => 最后一位的索引是 8       => 最后一次的比较 [8] > [9]       => [9] 是 undefined       => 实际上比较的是 数字 > undefined       => 最后一次的比较是没有意义的优化2:      + 两个步骤一起看      for(var j = 0; j < arr.length - 1; j++){      // 循环遍历数组      for(var i = 0; i < arr.length - 1; i++){          // 判断前一个位置和后一个位置的大小          if(arr[i] > arr[i+1]){              var tmp = arr[i];              arr[i] = arr[i + 1];              arr[i + 1] = tmp;          }      }  }      + 外层循环        => 表示把步骤 2 重复多少回        => 重复第一回，把最大的数字放在最后一位        => 重复第二回，倒数第二次是把倒数第二大的放在倒数第二位          -> 最后一次，是倒数第二大和倒数第一大在比较，-1次        => 重复第三回，倒数第三次是把倒数第三大的放在倒数第三位          -> 倒数第二次，是倒数第三和倒数第二比较，-1次          -> 最后一次，是倒数第二和倒数第一比较，-1次      + 规律        + 重复第 1 回，j === 0，减少 0 次        + 重复第 2 回，j === 1，减少 1 次        + 重复第 3 回，j === 2，减少 2 次        + 重复的过程中，外层变量是几，就减少几次

// 准备一个数组var arr = [9, 2, 6, 4, 3, 8, 5, 7, 1];// 让步骤二重复执行for(var j = 0; j < arr.length - 1; j++){
       // 循环遍历数组    for(var i = 0; i < arr.length - 1 - j; i++){
           // 判断前一个位置和后一个位置的大小        if(arr[i] > arr[i+1]){
               var tmp = arr[i];            arr[i] = arr[i + 1];            arr[i + 1] = tmp;        }    }}console.log(arr);

计数排序countSort

+ 利用数组的索引+ 因为数组的索引也是一个数字

注： 缺点：空间复杂度(位置变化的程度)大，最好的情况下，计数排序的时间复杂度比冒泡排序低

/*1. 准备一个数组    => arr = [100, 87, 69, 93, 23, 12, 12, 89,  56, 33];2. 遍历原始数组    => 准备一个新的空数组    => 遍历原始数组    => 把原始数组里面的每一个数字当作索引填充到新数组里面3. 把临时数组反馈到原始数组里面    => 遍历临时数组*/// 1. 准备一个数组var arr = [100, 87, 66, 92, 35, 35, 24, 11, 2, 3, 87, 91];// 空数组var tmpArr = [];// 2. 遍历原始数组// 思路：// 第一个数字是 100// 在我创建的 tmpArr 里面 [100]位置添加一个数据// tmpArr[100] = 1;// tmpArr[87] = 1;// tmpArr[35] = 1;// // 每次添加的时候看一次，如果当前这个索引位置没有数据，设置为1// // 如果该索引位置有数据，++// // 第二次遇到[35]位置的时候// tmpArr[35]++;for(var i = 0; i < arr.length; i++){
       // 给tmpArr添加数据，但是我要先判断    if(tmpArr[arr[i]] !== undefined){
           tmpArr[arr[i]]++;    }else{
           tmpArr[arr[i]] = 1;    }}// 3. 遍历临时数组arr.length = 0;for(var i = 0; i < tmpArr.length; i++){
       // 3-1. 判断当前这个是不是undefined    if(tmpArr[i] === undefined)    continue;    // console.log(i, tmpArr[i]);    // i 就是数组需要排序的数字    // tmpArr[i] 是这个数字有多少个    // 有多少个，就该循环多少次    for(var j = 1; j <= tmpArr[i]; j++){
           arr[arr.length] = i;    }}console.log(arr);

选择排序

+ 每次选择一个最小的数字放在前面

/*1. 如何找到数组例最小的数字  => 循环遍历数组  => 假设数字[0]位置最小  => 如果哪一个数字比我还小，那就用那个小的数字的索引，把我假设的索引替换掉  => 那就找到了一个最小的数字的索引  => 假设的是 [0]，我找到的最小的是 [8]  => 我就让 [0] 和 [8] 交换位置2. 重复第一个步骤  => 但是重复的时候，需要一些变化  => 第二次假设 [1] 是最小的  => 重复 8 遍  => 规律：        第 1 遍 j === 0, 假设 [0], 开始 1，交换 [0]        第 2 遍 j === 1, 假设 [1], 开始 2，交换 [1]        第 3 遍 j === 2, 假设 [2], 开始 3，交换 [2]        第 4 遍 j === 3, 假设 [3], 开始 4，交换 [3]        第 8 遍 j === 7, 假设 [7], 开始 8，交换 [7]*/var arr = [9, 2, 6, 4, 3, 8, 5, 7, 1];// // 1. 找到最小的数字的索引// // 假设的不是数字，是索引// var minIndex = 0;// for(var i = 1; i < arr.length; i++){
   //     if(arr[i] < arr[minIndex]){
   //         minIndex = i;//     }// }// // console.log(minIndex);// // 最小数字的索引是8// var tmp = arr[0];// arr[0] = arr[minIndex];// arr[minIndex] = tmp;// 2. 重复执行步骤1for(var j = 0; j < arr.length - 1; j++){
       // 1. 找到最小的数字的索引    // 假设的不是数字，是索引    var minIndex = j;    for(var i = j + 1; i < arr.length; i++){
           if(arr[i] < arr[minIndex]){
               minIndex = i;        }    }    // 最小数字的索引是8    var tmp = arr[j];    arr[j] = arr[minIndex];    arr[minIndex] = tmp;}console.log(arr);

// 书写一个函数，判断数组里是否有某个成员 function fn(arr, num){
        //遍历数组     for(var i = 0; i < arr.length; i++){
            // 判断         if(num === arr[i]){
                return true;         }     }     return false; } var res = fn([20, 10, 30, 40], 10); console.log(res);

// 书写一个函数，对数组里每一个数字扩大30%放在一个新数组里面返回// function map(arr){
   //     var newArr = [];//     for(var i = 0; i < arr.length; i++){
   //         newArr[i] = arr[i] * 1.3;//     }//     return newArr;// }// console.log(map([10, 100, 1000]));  // [13, 130, 1300]function map(arr){
       for(var i = 0; i < arr.length; i++){
           arr[i] *= 1.3;    }    return arr;}console.log(map([10, 100, 1000]));  // [13, 130, 1300]

// 准备一个包含三十个整型元素的数组，数字是从 2 开始的 偶数？// 把这个数组里面的每五个数字求一个平均值，放在新数组里?// 第一问：// 方案 1    // 准备一个长度为30的数组    // 从 0 开始循环，根据索引计算一个数字，把偶数添加到该数组var arr = new Array(30);for(var i = 0; i < arr.length; i++){
       arr[i] = (i + 1) * 2;}// 方案 2    // 准备一个空数组    // 从 2 开始循环，每次叠加 2， 到 60 截止    // 把每一个数字追加到数组的后面// var arr = [];// for(var i = 2; i <= 60; i += 2){
   //     arr[arr.length] = i;// }// 方案 3    // 条件：长度为 30    // 只要不到 30，那么一定得有一段代码重复执行 while    // 准备一个变量用于叠加数字，从 2 开始依次叠加    // 只要长度不到 30，把这个变量追加到数组末尾var arr = [];var num = 2;while(arr.length < 30){
       arr[arr.length] = num;    num += 2;}console.log(arr);/* 第二问：每五个求一个平均值，放到新数组里    方案1：    1. 创建一个新数组    2. 循环遍历原始数组     => 把每次的数字向 sum 上叠加     => 利用计数器来计算你叠加了多少个数字     => 一旦计数器记够5个了，就求一个平均值*/// var newArr = [];// var sum = 0;// var count = 0;// for(var i = 0; i < arr.length; i++){
   //     sum += arr[i];//     count++;//     if(count % 5 === 0){
   //         newArr[newArr.length] = sum / 5;//         sum = 0;//     }// }// console.log(newArr);/*方案2    1. 创建一个新数组    2. 循环遍历原始数组     => 循环过程中 i 就可以取代计数器的作用*/var newArr = [];var sum = 0;for(var i = 0; i < arr.length; i++){
       sum += arr[i];    if((i + 1) % 5 === 0){
           newArr[newArr.length] = sum / 5;        sum = 0;    }}console.log(newArr);

转载地址：https://blog.csdn.net/Xiaolei233/article/details/117931628 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！