JavaScript数组。

数组

当我们需要处理一组数据时，一定性定义很多变量，比较难处理。这个时候我们就需要用到数组。

• 概念：
  数组：一组数据的集合。其中每个数据被称为数组的元素。在数组中存放任意类型的数据。数组是将一组数据存储到单个变量名下的方式。
• 数组声明
  三种声明
  1.通过new关键字创建数组。
  2.省略new关键字创建数组
  3.字面量赋值
  示例：

        var arr = new Array('holle', 10, 8, true, 40);
        var arr = Array('holle', 10, 8, true, 40);
        var arr = ['holle', 10, 8, true, 40];

这三种都是定义一个一样的数组[‘holle’, 10, 8, true, 40]。

【注】前两种方式，若传入参数只有一个，且为number时，这个数字表示声明的数组的长度，而不是存放的数据。

• 数组的长度
  arr.length
  从一开始数。
• 数组的下标
  从0开始，数据在数组中的序号。最大值为length-1。
• 访问数组元素。
  格式：数组变量名[下标]
  访问数组元素，需要通过下标去访问。
• 数组的遍历（循环）
  0——length-1
  两种循环遍历方式：
  1.普通的for循环。
  2…for…in 循环 快速遍历法/快速枚举法
  格式：
  for (var key in 数组变量名) {
  }
  区别：
  1.for in不需要每次都判断，效率更高
  2.for in若在遍历过程中，数组发生了变化，会出现问题，不安全。
  示例：

        // 遍历循环
        var arr = ['holle', 10, 8, true, 40];
        for (i = 0; i <= arr.length - 1; i++) {
            document.write(arr[i] + "   ");
        }

示例2：

        // 快速遍历
        var arr = ['holle', 10, 8, true, 40];
        for (var i in arr) {
            document.write(arr[i] + '  ');
        }

两个都是遍历

数组的方法

• push()
  功能：给数组的末尾添加元素
  格式：数组名.push(参数…)
  返回值：插入元素后的数组长度
  示例：

        // 在数组后面添加元素
        var arr = ['holle', 10, 8, true, 40];
        var a = arr.push(12, 50);
        alert(arr);
        alert(a);

插入元素后的数组长度

• pop()
  功能：在数组的末尾取下一个元素
  格式：数组名.pop()
  返回值：取下的元素。

示例：

        // 在元素末尾取下一个元素。
        var arr = ['holle', 10, 8, true, 40];
        var a = arr.pop();
        alert(arr);
        alert(a);

取下的末尾元素

• unshift()
  功能：从数组的头部添加元素
  格式：数组名.unshift(参数…)
  返回值：插入元素后的数组长度
  示例：

        // 数组的头部添加元素
        var arr = ['holle', 10, 8, true, 40];
        var a = arr.unshift(4, 'css');
        alert(arr);
        alert(a);

插入元素后的数组长度

• shift()
  功能：从数组的头部取下一个元素
  格式：数组名.shift()
  返回值：取下的元素。
  示例：

        // 数组的头部取下一个元素
        var arr = ['holle', 10, 8, true, 40];
        var a = arr.shift();
        alert(arr);
        alert(a);

输出的取下头部数组

• concat()
  功能：合并数组。
  格式：数组名.concat(数组);
  1.copy原数组，生成新数组
  2.将输入的数组中的元素单独拆分出来，添加到新数组中。

示例：

        // 合并数组
        var arr = ['holle', 10, 8, true, 40];
        var a = arr.concat(8, 9);
        alert(a);

生成新数组

• slice()
  功能：获取当前数组指定区域的元素，生成新数组。
  格式：数组名.slice(start,end) 含头不含尾
  start:开始位置的下标
  end：结束位置的下标
  返回值：新数组，原数组不变。
  示例；

        // 含头不含尾
        var arr = ['holle', 10, 8, true, 40];
        var a = arr.slice(1, 3);
        alert(a);

下标为1的数开始到下标为3的前面结束

• splice()
  截取
  格式：数组.splice(start,length,数据…)
  返回值：截取的元素
  参数：
  start：开始截取的位置
  length：截取的长度
  第三个参数开始：在start位置开始，插入新元素。

新增
arr.splice(4,0,“5”);
修改
arr.splice(2,1,4);
删除
arr.splice(2,1);

示例：

        // 修改下标为0的数组改为1
        var arr = ['holle', 10, 8, true, 40];
        arr.splice(0, 1, 1);
        alert(arr);

• join()
  字符拼接
  格式：数组.join(字符串);
  功能：将数组中元素用指定的字符串拼接
  返回值：拼接好的字符串

        // 字符拼接
        var arr = ['holle', 10, 8, true, 40];
        var a = arr.join("-");
        alert(a);

• reverse()
  功能：将数组元素反转。
  格式:数组.reverse();
  该方法会修改原数组。
  示例：

        // 反转
        var arr = ['holle', 10, 8, true, 40];
        arr.reverse();
        alert(arr);

• sort()
  对数组中的元素进行排序

示例：

        // 排序
        var arr = [8, 7, 2, 4, 1, 5]
        arr.sort();
        alert(arr);

• indexof()
  功能：在数组中查找第一次出现元素的下标。
  格式：数组.index(item,start);
  参数：
  item：要查找的元素
  start：开始查找的位置
  返回值：查找到的元素下标，若未查到，则返回-1。

示例：

        // 查找第一次出现的下标(查找的数组,从第几个开始查找)
        var arr = ['holle', 10, 8, true, 40];
        var a = arr.indexOf(8, 0);
        alert(a);

查找数组8的下标

• forEach()
  输出每个元素的下标
  格式：数组.forEach(function(item,index,arr){
  }）
  参数：
  item：当前遍历的元素，
  index：当前遍历元素的下标
  arr：数组
  示例：

        var arr = [10, 1, 52, 25, 52, 34];
        arr.forEach(function(item, index, arr) {
            document.write("元素：" + item + " 下标为：" + index + "<br/>");
        });

二维数组

二维数组：数组中的元素为数组是，该数组被称为二维数组。
数组里面嵌套数组。
示例：

    var arr = new Array(["韩信",20,"打野"],["鲁班",9,"射手"],["不知火舞",24,"法师"]);
    alert( arr[1][1]);

选中数组下标为1的数组中下标为1的数组。

数组的排序

sort:按照Unicode编码比较，类似字符串的比较方式。
示例：

    <script>
        var arr = [1,15,2,23];
        
        arr.sort(function(value1,value2){
            // 从小到大
            // return value1 - value2;
            // 从大到小。
            return value2 - value1;
        });
        alert(arr);
    </script>

看一下从大到小的排序

冒泡排序

规则：从左到右，数组中相邻的两个元素进行比较。将较大（较小）的数放在后面。
规律:每一轮都可以找出一个最大（最小）值，放在正确的位置上。
比较的轮次：数组的长度-1
每一轮比较的次数：数组长度-当前的轮次

示例：

        var arr = [7,3,4,6,5,1,2];
        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]) {
                   var temp = arr[j];
                   arr[j] = arr[j+1];
                   arr[j+1] = temp;
               } 
            } 
        }
        alert(arr);

选择排序

规则：选出一个位置，让这个位置上的数与后面的数比较，如果大于（小于）后面的数，则交换位置。然后对该位置进行下一轮比较。
规律：每一轮，在当前位置找到正确的值
比较的轮次：数组的长度-1
每一轮比较的次数：数组长度-当前的轮次

示例：

        var arr = [7,3,4,6,5,1,2];
        for (var i = 0; i < arr.length - 1; i++) {
            for (var j = i+1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    var temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }
        alert(arr);