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

末蓝、 2021-09-18 03:36 297阅读 0赞

1:函数案例

2:函数其他

3：作用域

4：预解析

1：函数案例
    //    1:  求一组数中的最大值，最小值，求和
    //    2:求阶乘
    //    3:判断质数
    //    4：通过函数实现数组的反转
    //    5:求一个数字的阶乘
    //    6:费布那切数列
    //    7:求一个数字的阶乘和
    //    8:冒泡排序
      //    1:  求一组数中的最大值，最小值，求和
        function allNumber(num) {
            var sum = 0;
            var min = Number.MAX_VALUE;
    //        var min = num[0];
    //        var max = num[0];
            var max = Number.MIN_VALUE;
            for (var i = 0; i < num.length; i++) {
                if (min > num[i]) {
                    min = num[i];
                } //end if
                if (max < num[i]) {
                    max = num[i];
                } //end if
                sum += num[i];
            }
            var arr = [min, max, sum];
            return arr;
            //将三个变量用数组的方式返回(返回到函数里面，也就是allNumber())，这是最巧妙的地方
        }
        var result = allNumber([1, 9, 2, 8]);
        console.log("最小值" + result[0] + "最大值" + result[1] + "求和" + result[2]);
        //    2:求阶乘
        function jieCheng(n) {
            var sum = 1;
            for (var i = 1; i <= n; i++) {
                sum *= i;
            }
            return sum;
        }
        console.log(jieCheng(3))
        //    3:判断质数
        function zhiShu(num) {
            for (var i = 2; i < num; i++) {
                if (num % 2 == 0) {
    //    说明有数字整除了，就没有必要往后整除了，验证出不是质数
                    return false;
                }
            }
            return true;
    
        }
        console.log(zhiShu(8) ? "是质数" : "不是质数"); //这里zhiShu(8) 接收的是return true ，含义是是质数
        //    4：通过函数实现数组的反转
        function reverse(arr) {
            for (var i = 0; i < arr.length / 2; i++) {
                var temp;
                temp = arr[i];
                arr[i] = arr[arr.length - 1 - i];//这里是数组的下标，从0开始，所以数组的长度比数组下标少一，
                // 所以length-1；后面的-i，是由于每次比较，最后的哪个是数是变化的，
                // 比如6个数，最后面的个数的小标就是length-1-0,
                // 5个数，最后面的个数的小标就是length-1-1，
                // 4个数，最后面的个数的小标就是length-1-2，
    //            -0,-1,-2,正好符合i的变化规律，所以后面的变量用i代替
                // n个数，最后面的个数的小标就是length-1-i，
                arr[arr.length - 1 - i] = temp;
            }
            return arr;
        }
        console.log(reverse([1, 2, 3, 4, 5, 6, 7, 8, 9]))
        //    5:求一个数字的阶乘
        var f2 = function (num) {
            var sum = 1;
            for (var i = 1; i <= num; i++) {
    //            var sum = 1; 在这里出现了一个问题，将变量赋值，写在了循环里面，输出都是源数字，
    // 每次循环都是重新赋值，所以sum一直都是1，要是把变量放在外面，
    // 外面是1，但是在循环里面每次sum会增加
                sum = sum * i;
            }
            return sum;
        }
        console.log(f2(4))
        //    6:递归费布那切数列
        function f6(n) { //函数声明的形式，一般用于命名函数
            if (n == 1 || n == 2) {
                return 1;
            }
            return f6(n - 1) + f6(n - 2);
        }
        console.log(f6(4));
        var ff6 = function (n) { //函数表达式的形式，一般用于匿名函数
            if (n == 1 || n == 2) {
                return 1;
            }
            return ff6(n - 1) + ff6(n - 2);
        }
        console.log(ff6(4));
        //    6.1普通实现翻番
        function fff6(n) {
            var num1 = 1;
            var num2 = 1;
            var sum;
            if (n == 1 || n == 2) {
                return 1;
            }
            for (var i = 3; i <= n; i++) {
                sum = num1 + num2;  //注意顺序，先进行运算，如果后面换需要继续实现，才从前往后赋值
                num1 = num2;
                num2 = sum;
            }
            return sum;
        }
        console.log(fff6(3))
        //    7:求一个数字的阶乘和,前面有一个函数已经求出单个阶乘，现在只是把他们相加即可
        function factoriala(num1) {
            var sum1 = 0;
            for (var i = 1; i <= num1; i++) {
                sum1 += jieCheng(i);
            }
            return sum1;
        }
        console.log(factoriala(3));
        //    8:冒泡排序
        var f8 = function (array) {
            for (var i = 0; i < array.length; i++) {
                for (var j = 0; j < array.length - 1 - i; j++) {
                    if (array[j] > array[j + 1]) {
                        var temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
    //                array[j] = array[array.length-1];
    //                这里犯了一个错误，把数组反转和冒泡排序混淆
    //                数组反转本书数组就是一个有顺序的数对，是第一个数和最后一个数作比较，以此类推
    //                冒泡排序的数组本本身是无序的，从以一个数开始，依次往后进行排序
    //                array[array.length-1] = temp;
                    }
                }
            }
            return array;
    
        }
        console.log(f8([12, 78, 5, 4, 23, 15, 98, 422, 18, 62]))
    
    2：函数其他
    2.1arguments对象伪数组
    伪数组arguments获取伪数组的值
    var fn = function () {
        var sum = 0;
        for (var i = 0; i < arguments.length; i++) {
            sum += arguments[i];
        }
        return sum;
    }
    console.log(fn(1, 9)) 
    //console.log(fn[(1, 9)]) 
    //这里有个坑，明明是进行进行数组的遍历循环，
    // 但是进行输出的时候，数组的形式[]却不行,原因是arguments可以获取伪数组的值，
    // 但他终归不是数组，所以不能用数组的形式进行传值
    
    2.1函数的其他定义方式
    函数定义有命名函数，匿名函数，函数自定义
    命名函数：定义：function fn(){}  调用fn();
    匿名函数：定义：function (){} ,调用：？没有函数名，该怎么调用？引出了两种方法，一种是函数表达式(定义)var fn = function(){}调用：fn()
    另一种是：函数自定义,声明的时候，直接调用(一次性)
    (function(){})()
    2.2函数也是一种数据类型
    function f1(){
        console.log("哈哈")
    }
    console.log(typeof f1);  //function
    
    2.3：函数作为参数使用
    函数里面的参数可以是任意类型，下面说函数作为参数使用
    function f2(fn) {
        fn();
    }
    function f3() {
        console.log("真神奇");
    }
    f2(f3); //这里有一个注意点；函数作为参数使用，是函数名，还是函数名+();
    // 因为函数作为参数调用的时候，主函数里面的调用是 fn()，缺的是函数代码，
    // 这时候函数作为参数只要提供代码就可以，而函数名里面就是代码，所以传值，只传函数名就可以
    
    2.4函数作为返回值使用
    function f4() {
        console.log("哈哈")
    }
    var ff = f4();
    ff(); 
    
    3：作用域
    //    作用域
    //1:全局变量:用var 声明，如果页面不关闭，那么就不会释放，会占空间，消耗内存
    //2：局部变量：在函数内部定义的变量
    //    3:js没有快级作用域，但是函数除外(这里快级作用域相当于局部作用域)
    //    4：隐式全局变量：变量声明的时候没有var，如果在函数内部定义了一个隐式全局变量，外部是可以访问的
    //    5：全局变量不会被删除，但是隐式全局变量可以被删除
    
    
    4：预解析
    //    首先需要了解的是浏览器遇到js代码，会有js解析器进行两步操作，预解析+执行代码
    //    预解析：就是提前解析代码
    //预解析就两部分：变量声明提前；函数声明提前
    //    先看变量声明
    console.log(num); //undefined
    var num = 10;
    
    //    函数声明提前
        function f1(){
            console.log("我是第一个f1")
        }
        f1();  //我是第二个f1
        function f1(){
            console.log("我是第二个f1")
        }
        f1() //我是第二个f1
    
    //    为什么输出这样的结果，其实是函数声明提前的原因，而且有函数调用在函数声明前的代码，首先会进行函数声明提前，而且如果函数名一样，后面的会覆盖前面的代码
    function f1() {
        console.log("我是第一个f1")
    }
    function f1() {
        console.log("我是第二个f1")
    }
    f1(); //我是第二个f1
    f1() //我是第二个f1
    
    //    函数声明提前和变量声明提前的混合用法
    var num = 10;
    f2()
    function f2() {
        console.log(num)  //10
    }
    
    
    
    //    解释： 函数调用之前，肯定是函数的声明，所以这里是函数声明提前
        var num = 10;
        function f2() {
            console.log(num)  //10
        }
    
        f2()
    
    混淆用法
    
    f3()
    function f3() {
        console.log(num3)  //undefined
    }
    var num3 = 10;
    
    //    下面看执行过程：首先函数声明提前，其次变量声明提前.这里是变量声明，但是没有赋值，所以是ubdefined
    var num3;
    function f3() {
        console.log(num3)  //undefined
    }
    f3()
    
    num3 = 10;
    
    //    函数声明提前和变量声明提前的混合用法
    console.log(a); //代码
    function a() {
        console.log("aaaaaa")
    }
    var a = 1;
    console.log(a); //1
    
    //    解析过程
    
    var a;
    function a() {
        console.log("aaaaaa")
    }
    console.log(a);
    a = 1;
    console.log(a);
    
    //    函数声明提前和变量声明提前的混合用法
    var a = 18;
    f5();
    function f5() {
        var b = 2;
        console.log(b); //2
        console.log(a);//undefined,有自己的就先用自己的，函数里面只要有a这个变量就行，(此时用不着外面的a)别管他(a)是undefined还是什么
        var a = '123';
    }
    
    //    函数声明提前和变量声明提前的混合用法
    f6();
    console.log(a); //报错
    console.log(b); //6
    console.log(c); //6
    function f6() {
        var a = b = c = 6;
        console.log(a); //6
        console.log(b); //6
        console.log(c); //6
    }
    
    
      //    解释
        function f6() {
    //        var a = b = c = 6;
            var a;
            a = 6; //局部变量
            b = 6; //隐式全局变量
            c = 6; //隐式全局变量
            console.log(a); //6
            console.log(b); //6
            console.log(c); //6
        }
        f6();
        console.log(a); //报错 ，a是局部变量，不会跑到函数外面，所以这里a既没有声明，也没有赋值。凭空出现，所以报错
        console.log(b); //6
        console.log(c); //6
    
    f7(); //不能调用,报错
    var f7 = function () {
        console.log(num7);
        var num7 = 7;
    }
    
    //解释,函数表达式，进行变量提升，var f7，下面剩下
    // f7 = function () {
    //console.log(num7);
    //var num7 = 7;
    // } ,所以 var f7； f7()肯定是报错的
    var f7;
    f7();
    f7 = function () {
        console.log(num7);
        var num7 = 7;
    }
    
    这也就从侧面说明，预解析就两方面：
    变量提升
    函数声明提升，
    (函数表达式用的也是变量提升)