第七章 javascript数组（array）的介绍和使用

一、数组的概念和特点

1. 数组是对象的一种，数组内的数据会按照顺序进行排列，是一种有序集合
   • 数据按照顺序被标记，序号，也叫索引，从0开始
     • arr[0]
   • 数组拥有length属性，用来表示自身有多少个数据
     • arr.length
   • 因为索引的规律为从0开始递增，通过length属性标记数据总数，所以可以通过循环语句遍历数组

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

二、数组的创建

1. 字面量：var arr1 = [数据1, 数据2, 数据3, ...];
2. 创建函数：var arr2 = new Array(数据1, 数据2, 数据3, ...);
3. 区别：当有且只有一个数值型数据时，字面量创建就是作为一个数据，构造函数创建会作为数组的长度，每个位置为undefined

三、数组的操作

1. 索引+长度操作
   • 原生操作，底层操作，所有数组操作功能的基础
   • 查：arr[索引]
   • 改：arr[索引] = "新值"
   • 增：默认只能在数组的最后增加
     • 需要配合数组数据位置的移动，完成所需的指定位置的增加
   • 删：默认只能从数组的最后开始删除
     • 删除数据的原理：减少长度
     • 需要配合数组数据位置的移动，完成所需的指定位置的删除
   • 数组长度可修改
     • 比原始长度大时，多出来的位置，用empty补齐，读取时为undefined
     • 原始长度小时，从数组最后开始删除
2. 方法操作：将数组作为对象，其自身的函数，叫数组的方法
   • arr.push()：最后一位新增
   • arr.pop()：删除最后一位
   • arr.shift()：删除第一位
   • arr.unshift()：第一位新增
   • arr.reverse()：翻转数组中的数据
   • arr.join()：根据指定字符连接数组中所有数据
   • arr.concat()：合并数组
   • arr.slice()：截取
   • arr.splice()：删除并替换
   • arr.sort()：排序
   • 推荐阅读：数组方法大全

四、数组排序

1. 冒泡排序：依次对数组中相邻数字进行比较(两两比较)，大的放后面

var arr = [5,99,2,9,1,5,67,7,10,23];       // 定义一个杂乱的数组
for(var i=0; i<arr.length-1; i++){
    
             // 外层循环，用于遍历数组每个元素
    for(var j=0; j<arr.length-i-1; j++){
    
       // 内层循环，用于将数组中的某个元素与其它所有元素相比较
        var x;                             // 声明一个变量，当作第三个空瓶子
        if(arr[j] > arr[j+1]){
    
                 // 判断当前元素和后一个元素的大小，如果当前元素比后一个元素大
            x = arr[j+1];                  // 将后一个元素（小元素）放在空瓶子里
            arr[j+1] = arr[j];             // 将当前元素（大元素）放在后一个元素的位置
            arr[j] = sum;                  // 将小元素从空瓶子中拿出来，放在当前元素的位置
        }
    } 
}
console.log(arr);                          // 完成循环之后，初始数组的顺序已经发生改变

2. 选择排序：从左向右依次，取数组中的一个数据和后面所有数据做比较，拿到最小的之后，再和当前位置交换

var arr = [5,99,2,9,1,5,67,7,10,23];  	 // 定义一个杂乱的数组
for(var i=0; i<arr.length-1; i++){
    
           // 外层循环，需要比对的次数
    var min = arr[i];                    // 假定一个最小值
    var minIndex = i;                    // 假定最小值的索引
    for(var j=i+1; j<arr.length; j++){
    
       // 内层循环，每次需要比对的次数
        if(min > arr[j]){
    
                    // 判断最小值是否为真的最小值
            min = arr[j];                // 获取真正的最小值
            minIndex = j;                // 获取真正最小值的索引
        }
    }
    arr[minIndex] = arr[i];              // 将当前元素放在最小值的位置
    arr[i] = min;                        // 将最小值放在当前元素的位置
}
console.log(arr);                        // 打印排序好的数组

五、ES5新增的数组方法

1. arr.indexOf()
2. arr.forEach()
3. arr.map()
4. arr.filter()
5. arr.some()
6. arr.every()
7. arr.reduce()
8. arr.includes()
9. 推荐阅读：数组方法大全

六、练习

1. 封装 计算任意两个个位数之间所有数字，两两组合，能组合成哪些奇数，放在数组中，返回出来 函数
   • 1，3
   • 1，2，3
   • 11,12,13,21,22,23,31,32,33
   • xxx(1, 3);
   • [11, 13, 21, 23, 31, 33]
2. 封装 将数组内所有数据增加30%的 函数

• [1, 2, 3, 4]
• map(arr);
• [1.3, 2.6, 3.9, 5.2]

3. 有一个全是数值的数组，封装函数，计算总和
4. 有一个全是数值的数组，封装函数，计算平均值
5. 封装函数：从100~999中取出所有的水仙花数，并返回到函数外部
6. 封装函数：判断一个数组是不是回文数组（对称）
   • [1,2,3,2,1]
   • [1,2,3,3,2,1]
7. 封装函数：将一个杂乱的数据，从大到小排序
8. 封装函数，根据指定数据，查询数组中是否存在该数据，如果存在，返回true，如果不存在，返回false some indexOf
   • [3, 4, 5, 6, 5, 4, 6, 5, 3, 2]
   • count(arr, 5); // 3
   • count(arr, 7); // false
9. 封装 数组去重的 函数
   • 不允许修改原数组
   • [3, 5, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]
   • noRepeat(arr);
   • [3, 5, 2, 4, 6, 1]
10. 现有一个排好序的都是数值的数组，插入一个新数据，要求不影响原排序，封装函数实现

• [1, 3, 4, 6, 9]
• insert(arr, 5);
• [1, 3, 4, 5, 6, 9]

11. 封装函数，根据指定数据，查询数组中是否存在该数据，如果存在，返回出现次数，如果不存在，返回false
12. 已知数组

var arr = [{
    
    
  name: "张三",
  age: 19,
  sex: "男",
  hobby: ["篮球", "喝酒", "乒乓球"],
  integral: 90
},{
    
    
  name: "大张四",
  age: 25,
  sex: "男",
  hobby: ["抽烟", "足球", "乒乓球"],
  integral: 80
},{
    
    
  name: "王五",
  age: 22,
  sex: "女",
  hobby: ["篮球", "烫头", "唱歌"],
  integral: 100
},{
    
    
  name: "张六",
  age: 18,
  sex: "女",
  hobby: ["跳舞", "足球", "rap"],
  integral: 85
}];

1. 筛选出所有喜欢打篮球的人员，以新数组存放
2. 计算所有人员的总分，数值
3. 按照年龄升序排序，以新数组存放
4. 给所有的男性的积分（integral）+10分，修改原数组
5. 不允许使用循环语句：for，while，do-while