数组的定义和基本使用

1)数组简介和定义

什么是数组

数组的定义方法1

数组的定义方法2

数组的定义方法3

访问数组项

下标越界

数组的长度

更改数组项

数组的遍历

2)数组类型的检测

数组的常用方法

数组的常用方法1

数组的头尾操作

push()方法

        var arr = [1, 2, 3, 4, 5, 6];
        //方法就是打点调用的函数，所以是打点调用
        arr.push(6);
        arr.push(7,8);
        console.log(arr)

pop()方法

       var arr=[1,2,3,4,5,6,7]
       var item=arr.pop();
       console.log(item);
       console.log(arr);

unshift()方法

shift()方法

        var arr = [1, 2, 3, 4, 5, 6];
        var item = arr.shift();
        console.log(arr);
        console.log(item);

2)数组的常用方法2

splice()方法

slice()方法

3)数组的常用方法3

join()和split()方法

字符串和数组更多相关性

concat()方法

reverse()方法

indexOf()和includes()方法

有关数组排序

数组算法

1)遍历相关算法

题目：求数组中每一项的总和、平均数

        //求数组的总和
        var arr = [3, 4, 5, 6, 7]
        //累加器
        var sum = 0;
        //遍历数组，每遍历一个数字，就要把这个数字累加到累加器中
        for (var i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        console.log(sum);
        console.log(sum/arr.length);

思路：求数组最大值

        //求数组的最大值和最小值
        var arr = [1, 24, 56, 7, 78, 85, 765, 7];
        //定义两个变量，max表示当前寻找到的最大值，默认是arr[0]
        //定义两个变量，Mmin表示当前寻找到的最小值，默认是arr[0]
        var max = arr[0];
        var min = arr[0];
        //遍历数组，从下标为1的项开始
        for (var i = 1; i < arr.length; i++) {
            //如果你遍历的这项，比当前最大值大，那么就让当前最大值成为这个项
            if (arr[i] > max) {
                max = arr[i];
            } else if (arr[i] < min) {
                //如果你遍历的这项，比当前最小值小，那么就让当前最小值成为这个项
                min = arr[i];
            }
        }
        console.log(max, min)

2)数组去重和随机样本

数组去重

        var arr = [1, 24, 56, 7, 78, 85, 7, 765, 7];
        //结果数组
        var result = [];
        //遍历原数组
        for (var i = 0; i < arr.length; i++) {
            //判断遍历到的这项是否在结果数组中，如果不存在就推入
            //includes方法用来判断某项是否在数组中
            if (!result.includes(arr[i])) {
                result.push(arr[i]);
                console.log(result);
            }
        }
        console.log(result);

随机样本

        var arr = [1, 24, 56, 7, 78, 85, 7, 765, 7];
        //结果数组
        var result = [];
        //遍历原数组
        for (var i = 0; i < 3; i++) {
            //随机选择一项的下标，数组的下标0~arr.length-1
            //之前学习过一个random的公式，[a,b]区间的随机数是parseInt(Math.random()*)
            var n=parseInt(Math.random()*arr.length)
            //把这项推入结果数组
            result.push(arr[n]);
            //删除这项，防止重复被随机到
            arr.splice(n,1);
        }
        console.log(result);

3)冒泡排序

        //冒泡排序
        var arr = [2, 35, 5, 5, 45,];
        //一趟一趟比较，趟数字序号就是i
        for (var i = 1; i < arr.length; i++) {
            //内层循环负责两两比较
            for (var j = arr.length - 1; j >= i; j--) {
                //判断项的大小
                if (arr[j] < arr[j - 1]) {
                    //这一项比前一项小了，那么就要交换两个变量的位置
                    var temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                }
            }
        }
        console.log(arr)

4)二维数组

        var matrix = [
            [11, 33, 44], 
            [34, 24, 7], 
            [2, 45, 4]
        ];
        console.log(matrix.length);//4
        for(var i=0;i<matrix.length;i++){
            for(var j=0;j<3;j++){
                console.log(matrix[i][j])
            }
        }

认识引用类型

什么是引用类型

从一个题目开始讲起

基本类型和引用类型

基本类型：number、boolean、string、undefined、null
引用类型：array、object、function、.regexp.…

内存和硬盘

基本类型值变量传值的内存变化

引用类型值变量传值的内存变化

相等判断时的区别

总结一下

深克隆和浅克隆

        var arr1 = [1, 2, 3, 4, 5];
        //结果数组
        var result = [];
        //遍历数组中的每一项，把遍历到的项推入到结果数组中
        for (var i = 0; i < arr1.length; i++) {
            result.push(arr1[i]);
        }
        console.log(result);
        console.log(result == arr1);//期望false，因为引用类型值进行比较的时候，等等比较的是内存地址

       var arr1 = [1, 2, 3, 4, [1,2,3]];
        //结果数组
        var result = [];
        //遍历数组中的每一项，把遍历到的项推入到结果数组中
        for (var i = 0; i < arr1.length; i++) {
            result.push(arr1[i]);
        }
        console.log(result);
        console.log(result == arr1);//期望false，因为引用类型值进行比较的时候，等等比较的是内存地址
        console.log(result[5]==arr1[5]);//藕断丝连