JavaScript高级:函数进阶-3.5闭包

最新推荐文章于 2024-10-18 17:51:23 发布

前端小趴菜~时倾

最新推荐文章于 2024-10-18 17:51:23 发布

阅读量108

点赞数

分类专栏： JavaScript 文章标签： javascript 前端开发语言

本文链接：https://blog.csdn.net/shiqing4387/article/details/127899144

版权

JavaScript 专栏收录该内容

19 篇文章 1 订阅

订阅专栏

3.5.1 变量作用域

变量根据作用域的不同分为两种：全局变量和局部变量。

函数内部可以使用全局变量。
函数外部不可以使用局部变量。
当函数执行完毕，本作用域内的局部变量会销毁。

3.5.2 什么是闭包

闭包（closure）指有权访问另一个函数作用域中变量的函数。 ----- JavaScript 高级程序设计
简单理解就是，一个作用域可以访问另外一个函数内部的局部变量。

<script>
	function fn1(){ // fn1 就是闭包函数
		var num = 10;
		function fn2(){
			console.log(num); // 10
		}
		fn2()
	}
fn1();
</script>

练习:10-什么是闭包

<script>
        // 闭包（closure）指有权访问另一个函数作用域中变量的函数。
        // 闭包: 我们fun 这个函数作用域 访问了另外一个函数 fn 里面的局部变量 num
        function fn() {
            var num = 10;


            function fun() {
                console.log(num);


            }
            fun();
        }
        fn();
    </script>

3.5.3 在 chrome 中调试闭包

打开浏览器，按 F12 键启动 chrome 调试工具。
设置断点。
找到 Scope 选项（Scope 作用域的意思）。
当我们重新刷新页面，会进入断点调试，Scope 里面会有两个参数（global 全局作用域、local 局部作用域）。
当执行到 fn2() 时，Scope 里面会多一个 Closure 参数，这就表明产生了闭包。

3.5.3 闭包的作用

提问：我们怎么能在 fn() 函数外面访问 fn() 中的局部变量 num 呢？

<script>
	function fn() {
		var num = 10;
		return function {
			console.log(num); // 10
		}
	}
var f = fn();
f()
	</script>

闭包作用：延伸变量的作用范围。

练习:11-闭包的作用

<script>
        // 闭包（closure）指有权访问另一个函数作用域中变量的函数。
        // 一个作用域可以访问另外一个函数的局部变量 
        // 我们fn 外面的作用域可以访问fn 内部的局部变量
        // 闭包的主要作用: 延伸了变量的作用范围
        function fn() {
            var num = 10;
            // function fun() {
            //     console.log(num);
            // }
            // return fun;
            return function() {
                console.log(num);
            }
        }
        var f = fn();
        f();
        // 类似于
        // var f = function() {
        //         console.log(num);
        //     }
        // var f =  function fun() {
        //         console.log(num);
        //     }
    </script>

3.5.5 闭包案例

1. 循环注册点击事件。

<body>
    <ul class="nav">
        <li>榴莲</li>
        <li>臭豆腐</li>
        <li>鲱鱼罐头</li>
        <li>大猪蹄子</li>
    </ul>
    <script>
        // 闭包应用-点击li输出当前li的索引号
        // 1. 我们可以利用动态添加属性的方式
        var lis = document.querySelector('.nav').querySelectorAll('li');
        for (var i = 0; i < lis.length; i++) {
            lis[i].index = i;
            lis[i].onclick = function() {
                // console.log(i);
                console.log(this.index);


            }
        }
        // 2. 利用闭包的方式得到当前小li 的索引号
        for (var i = 0; i < lis.length; i++) {
            // 利用for循环创建了4个立即执行函数
            // 立即执行函数也成为小闭包因为立即执行函数里面的任何一个函数都可以使用它的i这变量
            (function(i) {
                // console.log(i);
                lis[i].onclick = function() {
                    console.log(i);


                }
            })(i);
        }
    </script>
</body>

2. 循环中的 setTimeout()。

<body>
    <ul class="nav">
        <li>榴莲</li>
        <li>臭豆腐</li>
        <li>鲱鱼罐头</li>
        <li>大猪蹄子</li>
    </ul>
    <script>
        // 闭包应用-3秒钟之后,打印所有li元素的内容
        var lis = document.querySelector('.nav').querySelectorAll('li');
        for (var i = 0; i < lis.length; i++) {
            (function(i) {
                setTimeout(function() {
                    console.log(lis[i].innerHTML);
                }, 3000)
            })(i);
        }
    </script>
</body>

3. 计算打车价格。

<!DOCTYPE html>
<html lang="en">


<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>


</head>


<body>
    <script>
        // 闭包应用-计算打车价格 
        // 打车起步价13(3公里内),  之后每多一公里增加 5块钱.  用户输入公里数就可以计算打车价格
        // 如果有拥堵情况,总价格多收取10块钱拥堵费
        // function fn() {};
        // fn();
        var car = (function() {
            var start = 13; // 起步价  局部变量
            var total = 0; // 总价  局部变量
            return {
                // 正常的总价
                price: function(n) {
                    if (n <= 3) {
                        total = start;
                    } else {
                        total = start + (n - 3) * 5
                    }
                    return total;
                },
                // 拥堵之后的费用
                yd: function(flag) {
                    return flag ? total + 10 : total;
                }
            }
        })();
        console.log(car.price(5)); // 23
        console.log(car.yd(true)); // 33


        console.log(car.price(1)); // 13
        console.log(car.yd(false)); // 13
    </script>
</body>


</html>

3.5.6 闭包总结

1. 闭包是什么？

闭包是一个函数（一个作用域可以访问另外一个函数的局部变量）

2. 闭包的作用是什么？

延伸变量的作用范围

练习:15-思考题

<script>
        // 思考题 1：


        // var name = "The Window";
        // var object = {
        //     name: "My Object",
        //     getNameFunc: function() {
        //         return function() {
        //             return this.name;
        //         };
        //     }
        // };


        // console.log(object.getNameFunc()())//The Window  没闭包
        //拆解
        // var f = object.getNameFunc();
        // // 类似于
        // var f = function() {
        //     return this.name;
        // }
        // f();


        // 思考题 2：


        var name = "The Window";
        var object = {
            name: "My Object",
            getNameFunc: function () {
                var that = this;
                return function () {
                    return that.name;
                };
            }
        };
        console.log(object.getNameFunc()())//My Object 有闭包
        // //拆解object.getNameFunc()
        // var f = object.getNameFunc();
        // //类似于
        // var f = function () {
        //     return that.name;
        // };
        // //第二个()相当于调用了一下f
        // f()
    </script>