JS 闭包与作用域

小陌很忙

分类: JavaScript 685 0

函数自执行


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
    <style>
        .box{
            width: 100px;
            height: 100px;
            background: red;
        }

        .box2{
            width: 100px;
            height: 100px;
            background: yellow;
        }
    </style>
</head>
<body>
    <div class="box" title="123"></div>
    <div class="box2"></div>
    <script>  
	
		var box = document.querySelector('.box');
		box.onclick = function(){
		    alert(box.title)
		}
		
		var box = document.querySelector('.box2');
		//鼠标移入
		box.onclick= function(){
		    alert(2);
		}
		
    </script>
</body>
</html>

工作中,也许两个事件出自不同的人,这时,就有可能出现重名,这避免的方法就是都使用作用域。


// 作用域
// 在函数内部,它作用域的概念就是局部的函数它只能调用局部作用域的变量
// 这时就可以把函数封装起来自执行 - 避免命名冲突

(function(){})();

// 这样这个var box就是局部变量了,就算外面有相同的命名,也不会影响到当前代码本身的逻辑
(function(){
var box = document.querySelector('.box');
box.onclick = function(){
    alert(box.title)
}

})();

(function(){
var box = document.querySelector('.box2');
//鼠标移入
box.onclick= function(){
    alert(2);
}

})();

// 原生js逻辑基本上就是采用这种方式去分离代码业务的

闭包题思考


    function fn(){
            var n = 0;
            function fn2(){
                n++;

                return n;
            }
            return fn2; //不加括号的函数返回的只是函数体
        }

        var fn3 = fn(); // 这里调用时相当于声明了一个 n 等于 0
        var num = fn3(); // 第二次执行时相当于 n++ 了,就等于 1 ,n++不是变量,所以调用时改变的是 var n的值
        var num2 = fn3();
        var num3 = fn3();

        console.log(num3) //3


    function fn(){
            var n = 0;
            function fn2(){
                n++;

                return n;
            }
            return fn2; //不加括号的函数返回的只是函数体
        }

        var fn3 = fn();
        var num = fn3();
        var num2 = fn3();
        var num3 = fn3();
        console.log(num3) //3


        var fn4 = fn(); // 这里调用时相当于又声明了一个新的 n 等于 0 ,影响的是fn4 这个函数
        var num4 = fn4();
        console.log(num4) //1

return


        function fn(){
            
            function a(){
                alert(1)

                // return 'lalala'; // 如果加了return且写了值,才不会返回undefined
            };
            
            // 局部函数在外部可以调用的原因是它加了return
            return a;
        }

        var n = fn(); // 把函数体存起来

        // 既然n是函数 就可以 n() 去执行
        console.log(n()) // 执行结果,弹出 1 ,然后打印 undefined ,打印undefined的原因是a这个函数里没有return,没return默认就返回undefined

        function a(n1){
            var b = 6;
            function c(n2){
                return n2*2;
            }
            return [c,arguments[0]-c(b)+b]; 
        }

        var n  = a(5)[1];

        console.log(n)

// ----------------------------

        function a(n1){  // 2.这时a(n1)就是a(5)
            var b = 6;
            function c(n2){
                return n2*2;
            }
            return [c,arguments[0]-c(b)+b]; //3. 这里返回的是一个数组,这时就看拿的是第几个数,a(5)[1] 可知要的是第一个,第0个的c不用去管他
            // arguments[0]-c(b)+b
            // arguments[0] 它是 函数a(n1)的不定参列表,第0个就是 n1 ,n1 为 5 
            // c(b) 子函数调用父函数变量 这时c(n2)的 n2 就是 6 ,里面 return n2*2就是return 6*2, 这时的c(b)就是 12
            // b 就是父函数里 var b 的值 6 
            // 5-12+6;
        }

        var n  = a(5)[1];  // 1.遇到函数,首先看在什么地方调用

        console.log(n) // -1

        function a(n1){
            var b = 6; //3. 这时,因为函数里也声明了b,这时返回出来的值同时影响了父级的局部变量 也把它变成了 b =12 
            function c(n2){
                b = n2*2; // 1. 6*2等于12后,赋值给了b
                return b; // 2. 这里返回的 b 就是 12 
            }

            // arguments[0] = 5;
            // c(6) = 12
            // b = 12
            return [c,arguments[0]-c(b)+b]; //5-12+12;
        }

        var n  = a(5)[1];

        console.log(n)  // 5
  • 0人 Love
  • 0人 Haha
  • 0人 Wow
  • 0人 Sad
  • 0人 Angry
JavaScript、return、函数自执行、闭包

作者简介:小陌很忙

学无止境,生命不息,折腾不止!

共 0 条评论关于 “JS 闭包与作用域”

Loading...