JavaScript学习笔记4：数组

目录

一、数组Array

1.创建数组

2. 访问数组元素

3. 遍历数组

4. 数组中新增元素

案例：

---

一、数组Array

数组是指一组数据的集合，其中每个数据被称为元素，在数组中可以存放任意类型的元素。数组是将一组数据存储在单个变量名下的优雅方式

1.创建数组

• 利用new关键字创建数组；

    var 数组名 = new Array([n]);    //[]代表可选 若写n，则代表数组的长度
    var arr = new Array();         //创建了一个名为 arr 的空数组，注意Array的“A”大写

• 利用数组字面量创建数组（使用最多）

    // 1. 使用数组字面量方式创建空的数组
    var 数组名 = [];       //若写n，则代表数组的长度
    
    //2. 使用数组字面量方式创建带初始值的数组
    //3. 声明数组并赋值称为数组的初始化
    var arr2 = ['fan',true,17.5];    //数组中可以存放任意类型的数据，用逗号隔开

2. 访问数组元素

索引(下标):用来访问数组元素的序号。索引从 0 开始

格式：数组名[索引号]

        var arr1 = [1,2,'pink',true];
        console.log(arr1);       //Array(4) [ 1, 2, "pink", true ]
        console.log(arr1[2]);    //pink
        console.log(arr1[4]);    //underfined
            
             // 如果访问数组时没有和索引值对应的元素(数组越界)，
             //返回值为undefined

3. 遍历数组

遍历就是把数组中的元素从头到尾都访问一次。

数组的长度：数组名.length

        //遍历数组
        var arr = ['red','green','blue'];
        for (var i = 0 ; i < 3 ; i++) {     //3即arr.length
            console.log(arr[i]);
        }

// 数组的长度,默认情况下等于元素的个数
 // 当我们数组里面的元素发生了变化，length属性跟着一起变
 // 如果设置的length属性值大于数组的元素个数，则会在数组末尾出现空白元素empty；
 // 如果设置的length属性值小于数组的元素个数，则会把超过该值的数组元素删除
  var arr = ["red", "blue", "green"];
  for (var i = 0; i < arr.length; i++) {
    console.log(arr[i]);
  }
  
  arr.length = 2;
  console.log(arr);// red blue
  arr.length = 5;
  console.log(arr);

案例1：求数组中的最大值

        //求数组[2,6,1,77,52,25,7]中的最大值
        //声明一个保存最大元素的变量max
        //遍历这个数组，把里面的每个数组元素和max相比较
        var arr = [2,6,1,77,52,25,7];
        var max = arr[0];
        for (var i = 1 ; i < arr.length ; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
      
        console.log(max);

4. 数组中新增元素

1）可通过修改length长度来实现数组扩容的目的

2）数组中可以通过以下方式在数组的末尾插入新元素;

新增数组元素，修改索引号。若索引号没有被占用，则追加数组元素；若被占用，则修改数组元素

        //1.可以通过修改length长度来实现数组扩容的目的
        //length属性是可读写的
        var arr = ['red','blue','yellow','pink'];
        alert(arr.length);   // 4
        arr.length = 5;
        console.log(arr);   //Array(5) [ "red", "blue", "yellow", "pink", <1 empty slot> ]
        console.log(arr[3]);  //pink
        console.log(arr[4]);  //undefined

        //2.新增数组元素，修改索引号。若索引号没有被占用，则追加数组元素；若被占用，则修改数组元素
        arr1 = ['red','blue','yellow','pink'];
        arr1[3] = 'orange';
        console.log(arr1);    //Array(4) [ "red", "blue", "yellow", "orange" ]
        arr1[4] = 'white';
        console.log(arr1);    //Array(5) [ "red", "blue", "yellow", "orange", "white" ]

数组案例：

1.数组转化为分割字符串

        //要求：将数组['red','green','blue','pink']转换为字符串，并且用|或其他符号分割
        //输出：red|green|blue|pink|
        //1.需要一个新变量用于存放转换完的字符串str
        //2.遍历原来的数组，分别将里面数据取出来，加到字符串里面
        //3.同时在后面多加一个分隔符
        var arr = ['red','green','blue','pink'];
        var str = '';
        for (var i = 0;i < arr.length;i++) {
            str += arr[i] + '|';
        }
        console.log(str);     //red|green|blue|pink|

2.翻转数组  ； 删除指定元素

        // 1.数组反转
        // 要求：将数组['red','green','blue','pink','purple']的内容反过来存放
        //输出：
        var arr = ['red','green','blue','pink','purple'];
        var arr1 = [];
        for (var i = arr.length - 1; i >= 0 ; i--) {
            arr1[arr1.length] = arr[i];
        }
        console.log(arr1);  //Array(5) [ "purple", "pink", "blue", "green", "red" ]


         // 2.删除指定元素
        // 要求：将数组[2,0,6,1,77,0,52,0,25,7]中的0去掉后，形成一个不包含0的数组
        var arr = [2,0,6,1,77,0,52,0,25,7];
        var arr1 = [];
        var j = 0;
        for (var i=0 ; i < arr.length ; i++) {
            if (arr[i] != 0) {
                arr1[j] = arr[i];
                j++;
            }
        }
        console.log(arr1);  //Array(7) [ 2, 6, 1, 77, 52, 25, 7 ]

3.交换两个变量； 数组排序（冒泡排序）；降序

        // 例：交换两个变量（需引进第三个变量） 
        var num1 = 10;
        var num2 = 20;
        var temp;   //临时变量
        temp = num1;
        num1 = num2;
        num2 = temp;
        console.log(num1,num2);  //20 10
        
        //数组排序（冒泡排序）
        //冒泡排序：是一种算法，把一系列的数据按照一定的顺序进行排列显示（从小到大或从大到小）
        /* 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母
        从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行，直到没有相邻元素需要交换，
        也就是说该元素列已经排序完成。 */
        // 升序
        var arr = [6,2,4,8,3,1];
        for (var i = 0; i <= arr.length - 1;i++) {  //外层循环管趟数 第一轮走访 第一趟交换5次
            for (var j = 0; j <= arr.length - i - 1;j++) {   //里层循环管每趟交换的次数
                //内部交换两个变量的值 前一个和后一个数组元素相比较
                if (arr[j] > arr[j+1]) {   //当j=0时，arr[0]=6,arr[1]=2
                    var temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        console.log(arr);  //Array(6) [ 1, 2, 3, 4, 6, 8 ]

        //降序
        var arr = [6,2,4,8,3,1];
        for (var i = 0; i <= arr.length - 1;i++) {  //外层循环管趟数 第一轮走访 第一趟交换5次
            for (var j = 0; j <= arr.length - i - 1;j++) {   //里层循环管每趟交换的次数
                //内部交换两个变量的值 前一个和后一个数组元素相比较
                if (arr[j] < arr[j+1]) {   //当j=0时，arr[0]=6,arr[1]=2
                    var temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        console.log(arr); //Array(6) [ 8, 6, 4, 3, 2, 1 ]