前端全栈学习第十二天-js第三天-基础

叁歲伎倆 2021-09-18 02:30 391阅读 0赞

1：数组 ---冒泡排序

2：函数

1：数组
    1）:数组的作用，可以一次存储多个数据
    2）创建数组有两种方式
    通过构造函数创建一个数组
    var arr = new Array(5)//数组长度为5，空数组
    Var arr1 = new Array(5,1)//数组长度为2，里面有5,1两个元素
    通过字面量创建一个数组
    Var arr  =[5]//数组长度为1，元素为5
    3）for循环遍历数组
    var arr3 = [45, 12, 56, 23, 1, 48]
    for (var i =0; i < arr3.length; i++) {
        console.log(arr3[i])
    }
    数组案例
    //    案例1：求数组中所有元素的和
    //    案例2：求数组中所有元素的平均值
    //    案例3：求数组中所有元素的最大值
    //    案例4：求数组中所有元素的最小值
    //    案例5：倒循环遍历数组
    //    案例6：把数组中的每一个元素用|拼接到一起产生一个字符串，并输出
    //    案例7：去掉数组中重复的0,把其他的数据放在新的数组中
    //    案例8：反转数组
    //    案例9：冒泡排序
    //    案例10：将1-4案例写成一个方法
    //    案例1：求数组中所有元素的和
        var arr = [1, 9, 2, 8];
        var sum = 0;
        for (var i = 0; i < arr.length; i++) {
            sum += arr[i]
        }
        console.log(sum);
        //    案例2：求数组中所有元素的平均值
        var arr = [1, 9, 2, 8];
        var sum = 0;
        for (var i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        console.log(sum / arr.length);
    
        //    案例3：求数组中所有元素的最大值,写的时候，涉及到返回值
        var arr = [1, 9, 2, 8];
        var max = Number.MIN_VALUE;
        for (var i = 0; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
    
        }
        console.log(max);
        //    案例4：求数组中所有元素的最小值
        var arr = [1, 9, 2, 8];
        var min = Number.MAX_VALUE;
        var min = arr[0];
        for (var i = 0; i < arr.length; i++) {
            if (min > arr[i]) {
                min = arr[i];
            }
        }
        console.log(min);
        //    案例5：倒循环遍历数组
        var arr = [1, 2, 3, 4, 5];
        for (var i = arr.length; i >= 0; i--) {
            console.log(arr[i]);
        }
    
        //    案例6：把数组中的每一个元素用,拼接到一起产生一个字符串，并输出
        var arr = [1, 2, 3, 4, 5];
        var str = ""; //空字符串
        for (var i = 0; i < arr.length - 1; i++) {
            str += arr[i] + ",";
        }
        console.log(str + arr[arr.length - 1]) //最后一个元素的索引=所有元素的长度-1
        //    案例7：去掉数组中所有的0,把其他的数据放在新的数组中
        var arr = [12, 0, 45, 89, 0, 23, 0, 12, 45, 4];
        var str = [];
        for (var i = 0; i < arr.length; i++) {
            if (arr[i] != 0) {
                str[str.length] = arr[i];
            }
        }
        console.log(str);
    
        //    案例8：反转数组
        var arr = [7, 6, 5, 4, 3, 2, 1];
        var temp;
        //循环的目的是控制交换的次数
        for (var i = 0; i < arr.length / 2; i++) {
            temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
        console.log(arr);
        //    案例9：冒泡排序
        var arr = [12, 45, 78, 5, 3, 21, 19, 82, 43]
        //    循环控制比较的行数(有6个数，就比较五行，所以是length-1)
        for (var i = 1; i <= arr.length - 1; i++) {
    //        控制每一行比较的次数
            for (var j = 0; j < arr.length - i; j++) {
    //            开始比较
                if (arr[j] > arr[j + 1]) {
                    var temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        console.log(arr);
        //    案例10：将1-4案例写成一个方法
        var sum = 0;
        var min = Number.MAX_VALUE;
        var max = Number.MIN_VALUE;
        var arr = [1, 9, 2, 8];
        for (var i = 0; i < arr.length; i++) {
    //        求最小值
            if (min > arr[i]) {
                min = arr[i];
            } // end if
    //        求最大值
            else if (max < arr[i]) {
                max = arr[i];
            }
            //end if
            sum += arr[i];
            var allArr = [min, max, sum]
    
        } //end for
        console.log("最小值" + allArr[0] + "最大值" + allArr[1] + "求和" + allArr[2])
    2函数
    1）为什么要使用函数
    把一堆代码进行封装，需要的时候拿来直接用，减少代码的重复量
    2）函数先定义后调用，有参数有返回值的函数
    3）函数没有返回值，但是在调用的时候接收了，结果是undefined
    4）函数形参大于实参，结果是NaN
    5）实参可以是变量，也可以是具体的值
    6)案例
    // 1:求两个数字的和
        function sum2(a, b) {
            return a + b;
        }
        console.log(sum2(1, 2));
    
        // 2：求三个数字的和
        function sum3(a, b, c) {
            return a + b + c;
        }
        console.log(sum3(1, 2, 3));
        // 3：求两个数字的最大值
        function max(a, b) {
            return a > b ? a : b;
        }
        console.log(max(5, 3));
        // 4：求1-100所有数字的和
        function sum4(n) {
            var sum = 0;
            for (var i = 1; i <= n; i++) {
                sum += i;
            }
            return sum;
        }
        console.log(sum4(100));
        // 5：求1-100所有偶数的和
        function oddSum(n) {
            var sum = 0;
            for (var i = 0; i <= n; i++) {
                if (i % 2 == 0) {
                    sum += i;
                }
            }
            return sum;
    
        }
        console.log(oddSum(100))
        // 5：求1-100所有偶数的和
        function oddSum2(n) {
            var sum = 0;
            for (var i = 0; i <= n; i++) {
                if (i % 2 == 0) {
                    sum += i;
                }
            }
            console.log(sum)
    
        }
        oddSum2(100)
        // 5：求一个数组的和
        function arrAy(arr) {
            var sum = 0;
            for (var i = 0; i < arr.length; i++) {
                sum += arr[i]
            }
    //        return sum;
            console.log(sum); //一个函数，计算和，输出和，一个函数只做一个功能，这时候把结果返回，在函数调用的时候输出和
        }
    
        //    console.log(arrAy([1,9,2,8]))
        arrAy([1, 2, 3])
        //    7：求n-m之间所有数字的和
        function sum7(n, m) {
            var sum = 0;
    
            for (var i = n; i <= m; i++) {
                sum += i;
    
            }
            return sum;
        }
        console.log(sum7(1, 100))
        //    8：圆的面积
        function area(r) {
            return Math.PI * r * r;
        }
        console.log(area(2))
        //    9：求两个数的最大值
        function twoMax(a, b) {
            return a > b ? a : b;
        }
        console.log(twoMax(1, 2))