数组

数组：可以存放多个数据

作用:把一组数据放到一起，并且提供了方便的访问方式

本质：一组有序数据的集合

创建数组的两种方式

1、new Array（）；

  var arr1= new Array（）；
//  new Array ()数组  把它复制给了一个变量arr1  arr 1 就是数组的名字

2、使用数组字面量创建数组 [ ]

  var arr2=[ ]; // 这是声明创建了一个空数组
  var arr=[1,2,3,4]
  // 数组  可以使用一个变量名，就可以存储多个值
   //  数组里面的值可以是任意的数据类型
  var arr3=[ 1,'abc',true];

使用数组 数组名[下标]

数组元素就是数组中的数据

下标（索引）：数组中元素的编号（从0开始）

 var arr=['佩奇','社会','人'];
console.log(arr);
console.log(arr[0]);

``

#####修改某个元素的值

```html
arr[0]='小猪';
console.log(arr[0]);

数组的长度: 就是数组元素的个数 arr.length

var arr=[0,1,5,'abc'];
console.log(arr.length);    // 结果是4

依次输出数组中的每一个元素

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

遍历数组：就是把数组元素从头到尾访问一次

var arr=[0,1,5,'abc'];
console.log(arr.length);    // 结果是4

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

注意点：

i在循环里i代表计数器 在数组里 for 里面的i 代表索引号

arr[i] 是数组arr里面第i个元素

求数组的最大值：

首先需要一个存放最大值的变量

把数组第一个值取出来 放到最大值变量里去

开始用第二个元素和最大值变量作比较

如果第二个元素比最大值变量大，将第二个元素赋值给最大变量，后面依次比较。

var arr=[23,5,12,48,92,11,55,44,46,85];
        var max=arr[0];
        for (i=1;i<arr.length;i++){
            if (arr[i]>max){
                max=arr[i];
            }
        }
        console.log(max);

将数组中的元素转换为字符串 用 | 或其他符号分割

var arr=['red','blue','green'];
        var str='';
        for (i=0;i<arr.length;i++){
            str=str+arr[i]+' | ';
        }
        console.log(str);

新增数组元素即给数组追加元素:

1、借助索引号

var arr=['小猪','佩奇'];
arr[2]='社会人';     // 如果这个下标没有就是追加的元素
console.log(arr);

注意：

一定 要用 数组加下标的方式 追加数组元素， 不能直接给数组名赋值， 否则会覆盖掉以前的数据

2、用length增加数组容量

var arr=['小猪','佩奇'];
arr.length='4;     
console.log(arr);   //  (4)?["小猪", "佩奇", empty × 2]
console.log(arr[2]);  //  未赋值所以为undefined
console.log(arr[3]);

案例：遍历原来的数组 找出 大于等于10的元素

var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
// 声明新的空数组
var newArr = [];
// 定义一个变量 用来计算 新数组的索引号
var j = 0;
for (var i = 0; i < arr.length; i++) {
    // 找出 大于 10 的数
    if (arr[i] >= 10) {
        // 给新数组
        newArr[j] = arr[i];
        // 索引号 不断自加
        j++;
    }
}
console.log(newArr);

根据数组的长度是动态变化（推荐使用这种）

var arr=[1,5,6,8,12,52,41,2,3,6,85];
        var newArr=[];  //声明新的数组
        console.log(newArr.length);  
        for(var i=0;i<arr.length;i++){
            if (arr[i]>=10){
                newArr[newArr.length]=arr[i];  
            }
        }
        console.log(newArr);

翻转数组

翻转数组不涉及筛选，所以旧数组和新数组的索引号都是连续的

旧数组是输出方，新数组接收方

新数组中的索引号恰巧是 循环中的 i

旧数组去元素的索引号 是数组长度-i-1得到的

      var arr=['red','blue','pink','black'];
        var newArr=[];
        for (var i=0;i<arr.length;i++){
            newArr[i]=arr[arr.length-i-1];
        }
        console.log(newArr);

也可以倒着遍历

       var arr=['red','blue','pink','black'];
        var newArr=[];
        for( i=arr.length-1;i>=0;i--){
            newArr[newArr.length]=arr[i]
        }
        console.log(newArr);

冒泡排序

是一种算法，将数据排列按照一定的顺序将数据排列

 var arr = [5, 4, 3, 2, 1];

        // 5个元素，跑了4趟

        // 第1趟，先找最大值，并移动到最后，比较了 4次
        for (var i = 0; i < 4; i++) {
            // 开始比较
            if (arr[i] > arr[i + 1]) {
                // 交换值
                var temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        console.log(arr);
        // [4, 3, 2, 1, 5]

        // 第2趟，比较了3次
        for (var i = 0; i < 3; i++) {
            // 判断，交换
            if (arr[i] > arr[i + 1]) {
                // 交换值
                var temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }

        }
        console.log(arr);
        // [3, 2, 1, 4, 5]
        // 第3趟，比较了 2次
        for (var i = 0; i < 2; i++) {
            // 判断，交换
            if (arr[i] > arr[i + 1]) {
                // 交换值
                var temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        console.log(arr);
        // [2, 1, 3, 4, 5]
        // 第4趟，比较了1次
        for (var i = 0; i < 1; i++) {
            // 判断，交换
            if (arr[i] > arr[i + 1]) {
                // 交换值
                var temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        console.log(arr);

外层for循环 是一共需要的趟数（以前的行） 一共走多少趟？ 数组的长度-1

里层循环控制每一趟的次数 每一趟的交换次数不同 数组的长度-i-1

从小到大排序：

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

从大到小排序：

    var arr=[5,9,3,8,11];
        for (var i=0;i<arr.length;i++){
            for(var j=0;j<arr.length;j++){
                if (arr[i]>arr[j]){
                    var temp=arr[j];
                    arr[j]=arr[i];
                    arr[i]=temp;
                }
            }
        }
       console.log(arr);