数组

数组

一、数组 array

当我们需要处理一组数据时，一定性定义很多变量，比较难处理。这个时候我们就需要用到数组。
1、概念：
数组：一组数据的集合。其中每个数据被称为数组的元素。在数组中存放任意类型的数据。数组是将一组数据存储到单个变量名下的方式。
数组声明
2、三种声明：

• 通过new关键字创建数组。

var arr=new Array(10,5,20,"hello");

• 省略new关键字创建数组

var arr= Array(10,5,20,"hello");

• 字面量赋值

var arr=[10,5,20,"hello"];

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

   var arr=new Array(10,5,20,"hello");
   alert(arr.length);

4、数组的下标
从0开始，数据在数组中的序号。最大值为length-1.
访问数组元素。
格式：数组变量名[下标]
访问数组元素，需要通过下标去访问。

  var arr=new Array(10,5,20,"hello");
   alert(arr[1]);//获取元素5;

5、数组的遍历 （循环）
0-length-1
两种循环遍历方式：

• 普通的for循环。

   var arr=new Array(10,5,20,"hello");
      for(var i=0;i<=arr.length-1;i++)
      document.write(arr[i]);

• for…in 循环 快速遍历法/快速枚举法
  格式：
  for (var key in 数组变量名) {
  }

   var arr=new Array(10,5,20,"hello");
       for (var i in arr) {
        document.write(arr[i])
 }

区别：
1.for in不需要每次都判断，效率更高
2.for in若在遍历过程中，数组发生了变化，可能会出现问题，不安全。

数组的方法

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

var arr = [1, "5", 4, 9, "hello"];
        arr.push(6);
        alert(arr);//1,5,4,9,hello,6
        var i = arr.push();
        alert(i)；//6

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

var arr = [1, "5", 4, 9, "hello"];
        arr.pop();
        alert(arr);//1,5,4,9
        var i = arr.pop();
        alert(i)；//hello

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

var arr = [1, "5", 4, 9, "hello"];
       arr.unshift(6);
       alert(arr);//6,1,5,4,9,hello
       var i = arr.unshift();
       alert(i)；//6

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

var arr = [1, "5", 4, 9, "hello"];
     arr.shift();
     alert(arr);//5,4,9,hello,
     var i = arr.shift();
     alert(i)；//1

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

 var arr = [1, 5, 7];
        var arr2 = [4, 6];
        var newArr = arr.concat(arr2);
        alert(newArr);//1,5,7,4,6

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

  var arr = [1, 5, 7, 8, 15];
      var i = arr.slice(1, 3);
      alert(i);//5,7

7、 splice()
截取
格式：数组.splice(start,length,数据…)
返回值：截取的元素
参数：
start：开始截取的位置
length：截取的长度
第三个参数开始：在start位置开始，插入新元素。
对数组元素的
新增
arr.splice(4,0,“5”);
修改
arr.splice(2,1,4);
删除
arr.splice(2,1);
8、 join()
格式：数组.join(字符串);
功能：将数组中元素用指定的字符串拼接
返回值：拼接好的字符串

 var arr = [1, 5, 7, 8, 15];
      arr.join("~");
      alert(arr.join("~"));

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

	 var arr = [1, 5, 7, 8, 15];
        arr.reverse();
        alert(arr);//15,8,7,5,1

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

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

---------------ES5新增常见方法--------------------
11、 indexof()
功能：在数组中查找第一次出现元素的下标。
格式：数组.index(item,start);
参数：
item：要查找的元素
start：开始查找的位置
返回值：查找到的元素下标，若未查到，则返回-1。
12、 forEach()
格式：数组.forEach(function(item,index,arr)){
}
参数：
item：当前遍历的元素，
index：当前遍历元素的下标
arr：数组

二维数组

二维数组：数组中的元素为数组是，该数组被称为二维数组。

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

数组的排序

1、冒泡排序

<script>
        // 规则：从左到右，数组中相邻的两个元素进行比较。将较大（较小）的数放在后面。
        // 规律:每一轮都可以找出一个最大（最小）值，放在正确的位置上。
        // 比较的轮次：数组的长度-1
        // 每一轮比较的次数：数组长度-当前的轮次
        var arr = [7, 3, 4, 6, 5, 1, 2];
        // 期望：2 4 5 6 7 
        // 2 7 6 4 5
        //2 6 7 4 5 
        // 2 6 4 7 5
        // 2 6 4 5 7
        // 2 6 4 5 7
        // 2 4 6 5 7
        // 2 4 5 6 7
        //比较的轮次
        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);
    </script>

2、选择排序

 //规则：选出一个位置，让这个位置上的数与后面的数比较，如果大于（小于）后面的数，则交换位置。然后对该位置进行下一轮比较。
        // 规律：每一轮，在当前位置找到正确的值。
        //比较的轮次：数组的长度-1
        // 每一轮比较的次数：数组长度-当前的轮次
        var arr = [7,3,4,6,5,1,2];
        //2,7,6,4,5   1轮
        //2,7,6,4,5   2
        //2,7,6,4,5   3
        //2,7,6,4,5   4
        //2,6,7,4,5   第二个位置的第一轮比较
        //2,4,7,6,5   2轮
        //2,4,7,6,5   3轮
        //2,4,6,7,5   第三个位置上的第一轮比较
        //2,4,5,7,6   二轮
        //2,4,5,6,7   第四个位置上的第1轮比较
        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;
                }
            }
        }

    </script>
    <!-- 
        区别：
            冒泡排序是比较相邻的两个数。而选择是按照位置比较，不一定相邻。
            
     -->
</head>