作用域 订阅
作用域(scope),程序设计概念,通常来说,一段程序代码中所用到的名字并不总是有效/可用的,而限定这个名字的可用性的代码范围就是这个名字的作用域。作用域的使用提高了程序逻辑的局部性,增强程序的可靠性,减少名字冲突。对于对象而言(其他也是一样的),在main函数中,对象的作用域为他所在的最近的一对花括号内。在后花括号处析构函数被调用;全局的对象的作用域为声明之后的整个文件,析构函数在最后被调用。另外,临时产生的对象在使用完后立即会被析构。 展开全文
作用域(scope),程序设计概念,通常来说,一段程序代码中所用到的名字并不总是有效/可用的,而限定这个名字的可用性的代码范围就是这个名字的作用域。作用域的使用提高了程序逻辑的局部性,增强程序的可靠性,减少名字冲突。对于对象而言(其他也是一样的),在main函数中,对象的作用域为他所在的最近的一对花括号内。在后花括号处析构函数被调用;全局的对象的作用域为声明之后的整个文件,析构函数在最后被调用。另外,临时产生的对象在使用完后立即会被析构。
信息
外文名
scope
属    于
程序设计语言中非常重要
中文名
作用域
目    的
减少名字冲突
作用域程序设计概念
作用域(scope)作用域在许多程序设计语言中非常重要。通常来说,一段程序代码中所用到的名字并不总是有效/可用的,而限定这个名字的可用性的代码范围就是这个名字的作用域。作用域的使用提高了程序逻辑的局部性,增强程序的可靠性,减少名字冲突。对于对象而言(其他也是一样的),在main函数中,对象的作用域为他所在的最近的一对花括号内。在后花括号处析构函数被调用;全局的对象的作用域为声明之后的整个文件,析构函数在最后被调用。另外,临时产生的对象在使用完后立即会被析构。下面是一个简单的例子。#include using namespace std;class X {public:X() {cout << "X::X()\n";}~X() {cout << "X::~X()\n";}};X f1(X x1) //完全不使用引用{cout << "f1(X f)\n";return x1;}X& f2(X& x2) //完全使用引用{cout << "f2(X f)\n";return x2;}X Globle_X; //全局版本int main(){cout << "--------\n";{X Local_X; //局部版本cout << "--------\n";}cout << "--------\n";X Normal_X;f1(Normal_X);cout << "--------\n";f2(Normal_X);cout << "--------\n";}程序执行结果为:X::X()--------X::X()--------X::~X()--------X::X()f1(X f)X::~X()X::~X()--------f2(X f)--------X::~X()大家对照着就能看出来了……
收起全文
精华内容
下载资源
问答
  • 作用域 本篇主要总结了作用域的定义、作用域作用域链的规则,全局变量和局部变量的关系,利用思维导图代替纯文字描述,提高收获,加油!

    作用域

    作用域的篇幅不会太长,作为自己对Js总结的第三篇文章,主要是承上启下。
    之后会涉及到执行上下文,闭包等相关专题,为了避免内容过多,作用域这一部分单独总结。

    目录

    前言

    在这里插入图片描述

    JavaScript内功系列:

    1. this指向详解,思维脑图与代码的结合,让你一篇搞懂this、call、apply。系列(一)
    2. 从原型到原型链,修炼JavaScript内功这篇文章真的不能错过!系列(二)
    3. 本文

    一、作用域的定义

    一张导图概括本节内容

    在这里插入图片描述

    注意:除了作用域,在此送大家2020最新企业级 Vue3.0/Js/ES6/TS/React/Node等实战视频教程,点击此处免费获取,小白勿进哦

    1.1 常见的解释

    1. 一段程序代码中所用到的名字并不总是有效,而限定它的可用性的范围就是这个名字的作用域;
    2. 作用域规定了如何查找变量,也就是确定当前执行代码对变量的访问权限;
    3. 通俗的讲作用域就是一套规则,用于确定在何处以及如何查找某个变量的规则
    function func(){
    	var a = 100;
    	console.log(a); // 100
    }
    console.log(a) // a is not defined a变量并不是任何地方都可以被找到的
    

    1.2 JavaScript中作用域工作模型

    JavaScript 采用是词法作用域(lexical scoping),也就是静态作用域:

    • 函数的作用域在函数定义的时候就决定了

    与之对应的还有一个动态作用域:

    • 函数的作用域是在函数调用的时候才决定的;

    1.3 全局变量和局部变量

    根据定义变量的方式又可以分为:

    局部变量:只能在函数中访问,该函数外不可访问;

    • 定义在函数中的变量
    function fn(){
    	var name = '余光';
    	console.log(name);
    }
    console.log(name); // ?
    fn(); // ?
    

    全局:任何地方都能访问到的对象拥有全局作用域。

    • 函数外定义的变量
    • 所有末定义直接赋值的变量自动声明为拥有全局作用域
    var a = 100;
    console.log('a1-',a);
    
    function fn(){
    	a = 1000;
    	console.log('a2-',a);
    }
    console.log('a3-',a);
    fn();
    console.log('a4-',a);
    

    注意:在ES6之后又提出了块级作用域,它们之间的区别我们之后再来讨论。

    在这里插入图片描述

    二、理解作用域

    根据第一节的描述,我们一一验证一下

    2.1 理解词法作用域

    var value = 1;
    function foo() {
        console.log(value);
    }
    function bar() {
        var value = 2;
        foo();
    }
    bar();
    

    我们结合定义去分析:

    • 执行bar函数,函数内部形成了局部作用域;
    • 声明value变量,并赋值2
    • 执行foo函数,函数foo的作用域内没有value这个变量,它会向外查找
    • 根据词法作用域的规则,函数定义时,foo的外部作用域为全局作用域
    • 打印结果是1

    如果是动态作用域的话:结果就是2,不知道你是否想明白了?

    2.2 全局变量

    var str = '全局变量';
    function func(){
    	console.log(str+1);
    	function childFn(){
    		console.log(str+2);
    		function fn(){
    			console.log(str+3);
    		};
    		fn();
    	};
    	childFn();
    }
    func();
    // 全局变量1
    // 全局变量2
    // 全局变量3
    

    再来分析下面的代码:

    var a = 100;
    function fn(){
    	a = 1000;
    	console.log('a1-',a);
    }
    console.log('a2-',a);
    fn();
    console.log('a3-',a);
    // a2- 100 // 在当前作用域下查找变量a => 100
    // a1- 1000 // 函数执行时,全局变量a已经被重新赋值
    // a3- 1000 // 全局变量a => 1000
    

    2.3 局部作用域

    局部作用域一般只在固定的代码片段内可访问到,最常见的就是以函数为单位的:

    function fn(){
        var name="余光";
        function childFn(){
            console.log(name);
        }
        childFn(); // 余光
    }
    console.log(name); // name is not defined
    

    三、作用域链

    3.1 当查找变量的时候都发生了什么?

    • 会先从当前上下文的变量对象中查找;
    • 如果没有找到,就会从父级(词法层面上的父级)执行上下文的变量对象中查找;
    • 一直找到全局上下文的变量对象,也就是全局对象;
    • 作用域链的顶端就是全局对象;

    这样由多个执行上下文的变量对象构成的链表就叫做作用域链,从某种意义上很类似原型和原型链。

    3.2 作用域链和原型继承查找时的区别:

    • 查找一个普通对象的属性,但是在当前对象和其原型中都找不到时,会返回undefined
    • 查找的属性在作用域链中不存在的话就会抛出ReferenceError

    3.3 作用域嵌套

    既然每一个函数就可以形成一个作用域(词法作用域 || 块级作用域),那么当然也会存在多个作用域嵌套的情况,他们遵循这样的查询规则:

    • 内部作用域有权访问外部作用域;
    • 外部作用域无法访问内部作用域;(真是是这样吗?)
    • 兄弟作用域不可互相访问;

    在《你不知道的Js》中,希望读者可以将作用域的嵌套和作用域链想象成这样:

    在这里插入图片描述

    四、思考与总结

    4.1 总结

    在这里插入图片描述

    4.2 思考

    最后,让我们看一个《JavaScript权威指南》中的两段代码:

    var scope = "global scope";
    function checkscope1(){
        var scope = "local scope";
        function f(){
            return scope;
        }
        return f(); // 注意
    }
    checkscope1();
    
    var scope = "global scope";
    function checkscope2(){
        var scope = "local scope";
        function f(){
            return scope;
        }
        return f;
    }
    checkscope2()();
    

    两段代码的结果都是"local scope",书中的回答是:JavaScript 函数的执行用到了作用域链,这个作用域链是在函数定义的时候创建的。嵌套的函数 f() 定义在这个作用域链里,其中的变量 scope 一定是局部变量,不管何时何地执行函数 f(),这种绑定在执行 f() 时依然有效。

    但是它们内部经历的事情是一样的吗?

    参考

    写在最后

    JavaScript内功基础部分已经总结到第三篇了,本系列大约会有15篇文章,都是我们在面试最高频的,但工作中常常被忽略的。

    JavaScript内功系列:

    1. this指向详解,思维脑图与代码的结合,让你一篇搞懂this、call、apply。系列(一)
    2. 从原型到原型链,修炼JavaScript内功这篇文章真的不能错过!系列(二)
    3. 本文
    4. 下一篇预发:执行上下文

    关于我

    • 花名:余光
    • 沉迷JS,水平有限,虚心学习中

    其他沉淀

    如果您看到了最后,不妨收藏、点赞、评论一下吧!!!
    持续更新,您的三连就是我最大的动力,虚心接受大佬们的批评和指点,共勉!

    展开全文
  • 深入理解JavaScript作用域作用域

    万次阅读 2019-03-15 09:22:30
    虽然对于许多新手开发者来说,作用域的概念并不是很容易理解,本文我会尽我所能用最简单的方式来解释作用域作用域链,希望大家有所收获! 作用域(Scope) 1.什么是作用域 作用域是在运行时代码中的某些特定部分...

    前言

    JavaScript中有一个被称为作用域(Scope)的特性。虽然对于许多新手开发者来说,作用域的概念并不是很容易理解,本文我会尽我所能用最简单的方式来解释作用域和作用域链,希望大家有所收获!

    想阅读更多优质文章请猛戳GitHub博客,一年五十篇优质文章等着你!

    作用域(Scope)

    1.什么是作用域

    作用域是在运行时代码中的某些特定部分中变量,函数和对象的可访问性。换句话说,作用域决定了代码区块中变量和其他资源的可见性。可能这两句话并不好理解,我们先来看个例子:

    function outFun2() {
        var inVariable = "内层变量2";
    }
    outFun2();//要先执行这个函数,否则根本不知道里面是啥
    console.log(inVariable); // Uncaught ReferenceError: inVariable is not defined
    

    从上面的例子可以体会到作用域的概念,变量inVariable在全局作用域没有声明,所以在全局作用域下取值会报错。我们可以这样理解:作用域就是一个独立的地盘,让变量不会外泄、暴露出去。也就是说作用域最大的用处就是隔离变量,不同作用域下同名变量不会有冲突。

    ES6 之前 JavaScript 没有块级作用域,只有全局作用域和函数作用域。ES6的到来,为我们提供了‘块级作用域’,可通过新增命令let和const来体现。

    2.全局作用域和函数作用域

    在代码中任何地方都能访问到的对象拥有全局作用域,一般来说以下几种情形拥有全局作用域:

    • 最外层函数 和在最外层函数外面定义的变量拥有全局作用域
    var outVariable = "我是最外层变量"; //最外层变量
    function outFun() { //最外层函数
        var inVariable = "内层变量";
        function innerFun() { //内层函数
            console.log(inVariable);
        }
        innerFun();
    }
    console.log(outVariable); //我是最外层变量
    outFun(); //内层变量
    console.log(inVariable); //inVariable is not defined
    innerFun(); //innerFun is not defined
    
    • 所有末定义直接赋值的变量自动声明为拥有全局作用域
    function outFun2() {
        variable = "未定义直接赋值的变量";
        var inVariable2 = "内层变量2";
    }
    outFun2();//要先执行这个函数,否则根本不知道里面是啥
    console.log(variable); //未定义直接赋值的变量
    console.log(inVariable2); //inVariable2 is not defined
    
    • 所有window对象的属性拥有全局作用域

    一般情况下,window对象的内置属性都拥有全局作用域,例如window.name、window.location、window.top等等。

    全局作用域有个弊端:如果我们写了很多行 JS 代码,变量定义都没有用函数包括,那么它们就全部都在全局作用域中。这样就会 污染全局命名空间, 容易引起命名冲突。

    // 张三写的代码中
    var data = {a: 100}
    
    // 李四写的代码中
    var data = {x: true}
    

    这就是为何 jQuery、Zepto 等库的源码,所有的代码都会放在(function(){....})()中。因为放在里面的所有变量,都不会被外泄和暴露,不会污染到外面,不会对其他的库或者 JS 脚本造成影响。这是函数作用域的一个体现。

    函数作用域,是指声明在函数内部的变量,和全局作用域相反,局部作用域一般只在固定的代码片段内可访问到,最常见的例如函数内部。

    function doSomething(){
        var blogName="浪里行舟";
        function innerSay(){
            alert(blogName);
        }
        innerSay();
    }
    alert(blogName); //脚本错误
    innerSay(); //脚本错误
    

    作用域是分层的,内层作用域可以访问外层作用域的变量,反之则不行。我们看个例子,用泡泡来比喻作用域可能好理解一点:

    最后输出的结果为 2, 4, 12

    • 泡泡1是全局作用域,有标识符foo;
    • 泡泡2是作用域foo,有标识符a,bar,b;
    • 泡泡3是作用域bar,仅有标识符c。

    值得注意的是:块语句(大括号“{}”中间的语句),如 if 和 switch 条件语句或 for 和 while 循环语句,不像函数,它们不会创建一个新的作用域。在块语句中定义的变量将保留在它们已经存在的作用域中。

    if (true) {
        // 'if' 条件语句块不会创建一个新的作用域
        var name = 'Hammad'; // name 依然在全局作用域中
    }
    console.log(name); // logs 'Hammad'
    

    JS 的初学者经常需要花点时间才能习惯变量提升,而如果不理解这种特有行为,就可能导致
    bug 。正因为如此, ES6 引入了块级作用域,让变量的生命周期更加可控。

    3.块级作用域

    块级作用域可通过新增命令let和const声明,所声明的变量在指定块的作用域外无法被访问。块级作用域在如下情况被创建:

    1. 在一个函数内部
    2. 在一个代码块(由一对花括号包裹)内部

    let 声明的语法与 var 的语法一致。你基本上可以用 let 来代替 var 进行变量声明,但会将变量的作用域限制在当前代码块中。块级作用域有以下几个特点:

    • 声明变量不会提升到代码块顶部

    let/const 声明并不会被提升到当前代码块的顶部,因此你需要手动将 let/const 声明放置到顶部,以便让变量在整个代码块内部可用。

    function getValue(condition) {
    if (condition) {
    let value = "blue";
    return value;
    } else {
    // value 在此处不可用
    return null;
    }
    // value 在此处不可用
    }
    
    • 禁止重复声明

    如果一个标识符已经在代码块内部被定义,那么在此代码块内使用同一个标识符进行 let 声明就会导致抛出错误。例如:

    var count = 30;
    let count = 40; // Uncaught SyntaxError: Identifier 'count' has already been declared
    

    在本例中, count 变量被声明了两次:一次使用 var ,另一次使用 let 。因为 let 不能在同一作用域内重复声明一个已有标识符,此处的 let 声明就会抛出错误。但如果在嵌套的作用域内使用 let 声明一个同名的新变量,则不会抛出错误。

    var count = 30;
    // 不会抛出错误
    if (condition) {
    let count = 40;
    // 其他代码
    }
    
    • 循环中的绑定块作用域的妙用

    开发者可能最希望实现for循环的块级作用域了,因为可以把声明的计数器变量限制在循环内,例如:

    for (let i = 0; i < 10; i++) {
      // ...
    }
    console.log(i);
    // ReferenceError: i is not defined
    

    上面代码中,计数器i只在for循环体内有效,在循环体外引用就会报错。

    var a = [];
    for (var i = 0; i < 10; i++) {
      a[i] = function () {
        console.log(i);
      };
    }
    a[6](); // 10
    

    上面代码中,变量i是var命令声明的,在全局范围内都有效,所以全局只有一个变量i。每一次循环,变量i的值都会发生改变,而循环内被赋给数组a的函数内部的console.log(i),里面的i指向的就是全局的i。也就是说,所有数组a的成员里面的i,指向的都是同一个i,导致运行时输出的是最后一轮的i的值,也就是 10。

    如果使用let,声明的变量仅在块级作用域内有效,最后输出的是 6。

    var a = [];
    for (let i = 0; i < 10; i++) {
      a[i] = function () {
        console.log(i);
      };
    }
    a[6](); // 6
    

    上面代码中,变量i是let声明的,当前的i只在本轮循环有效,所以每一次循环的i其实都是一个新的变量,所以最后输出的是6。你可能会问,如果每一轮循环的变量i都是重新声明的,那它怎么知道上一轮循环的值,从而计算出本轮循环的值?这是因为 JavaScript 引擎内部会记住上一轮循环的值,初始化本轮的变量i时,就在上一轮循环的基础上进行计算。

    另外,for循环还有一个特别之处,就是设置循环变量的那部分是一个父作用域,而循环体内部是一个单独的子作用域。

    for (let i = 0; i < 3; i++) {
      let i = 'abc';
      console.log(i);
    }
    // abc
    // abc
    // abc
    

    上面代码正确运行,输出了 3 次abc。这表明函数内部的变量i与循环变量i不在同一个作用域,有各自单独的作用域。

    作用域链

    1.什么是自由变量

    首先认识一下什么叫做 自由变量 。如下代码中,console.log(a)要得到a变量,但是在当前的作用域中没有定义a(可对比一下b)。当前作用域没有定义的变量,这成为 自由变量 。自由变量的值如何得到 —— 向父级作用域寻找(注意:这种说法并不严谨,下文会重点解释)。

    var a = 100
    function fn() {
        var b = 200
        console.log(a) // 这里的a在这里就是一个自由变量
        console.log(b)
    }
    fn()
    

    2.什么是作用域链

    如果父级也没呢?再一层一层向上寻找,直到找到全局作用域还是没找到,就宣布放弃。这种一层一层的关系,就是 作用域链 。

    var a = 100
    function F1() {
        var b = 200
        function F2() {
            var c = 300
            console.log(a) // 自由变量,顺作用域链向父作用域找
            console.log(b) // 自由变量,顺作用域链向父作用域找
            console.log(c) // 本作用域的变量
        }
        F2()
    }
    F1()
    

    3.关于自由变量的取值

    关于自由变量的值,上文提到要到父作用域中取,其实有时候这种解释会产生歧义。

    var x = 10
    function fn() {
      console.log(x)
    }
    function show(f) {
      var x = 20
      (function() {
        f() //10,而不是20
      })()
    }
    show(fn)
    

    在fn函数中,取自由变量x的值时,要到哪个作用域中取?——要到创建fn函数的那个作用域中取,无论fn函数将在哪里调用

    所以,不要在用以上说法了。相比而言,用这句话描述会更加贴切:要到创建这个函数的那个域”。
    作用域中取值,这里强调的是“创建”,而不是“调用”
    ,切记切记——其实这就是所谓的"静态作用域"

    var a = 10
    function fn() {
      var b = 20
      function bar() {
        console.log(a + b) //30
      }
      return bar
    }
    var x = fn(),
      b = 200
    x() //bar()
    

    fn()返回的是bar函数,赋值给x。执行x(),即执行bar函数代码。取b的值时,直接在fn作用域取出。取a的值时,试图在fn作用域取,但是取不到,只能转向创建fn的那个作用域中去查找,结果找到了,所以最后的结果是30

    作用域与执行上下文

    许多开发人员经常混淆作用域和执行上下文的概念,误认为它们是相同的概念,但事实并非如此。

    我们知道JavaScript属于解释型语言,JavaScript的执行分为:解释和执行两个阶段,这两个阶段所做的事并不一样:

    解释阶段:

    • 词法分析
    • 语法分析
    • 作用域规则确定

    执行阶段:

    • 创建执行上下文
    • 执行函数代码
    • 垃圾回收

    JavaScript解释阶段便会确定作用域规则,因此作用域在函数定义时就已经确定了,而不是在函数调用时确定,但是执行上下文是函数执行之前创建的。执行上下文最明显的就是this的指向是执行时确定的。而作用域访问的变量是编写代码的结构确定的。

    作用域和执行上下文之间最大的区别是:
    执行上下文在运行时确定,随时可能改变;作用域在定义时就确定,并且不会改变

    一个作用域下可能包含若干个上下文环境。有可能从来没有过上下文环境(函数从来就没有被调用过);有可能有过,现在函数被调用完毕后,上下文环境被销毁了;有可能同时存在一个或多个(闭包)。同一个作用域下,不同的调用会产生不同的执行上下文环境,继而产生不同的变量的值

    给大家推荐一个好用的BUG监控工具Fundebug,欢迎免费试用!

    欢迎关注公众号:前端工匠,你的成长我们一起见证!如果你感觉有收获,欢迎给我打赏,以激励我更多输出优质开源内容

    参考文章和书籍

    展开全文
  • 作用域作用域

    千次阅读 2020-04-13 19:57:09
    作用域作用域链 通常来说,一段程序代码中所用到的名字并不总是有效或可用的,而限定这个名字的可用性的代码范围就是这个名字的作用域scope。当一个方法或成员被声明,他就拥有当前的执行上下文context环境。在有...

    作用域与作用域链

    通常来说,一段程序代码中所用到的名字并不总是有效或可用的,而限定这个名字的可用性的代码范围就是这个名字的作用域scope。当一个方法或成员被声明,他就拥有当前的执行上下文context环境。在有具体值的context中,表达式是可见也都能够被引用。如果一个变量或者其他表达式不在当前的作用域,则将无法使用。作用域也可以根据代码层次分层,以便子作用域可以访问父作用域,通常是指沿着链式的作用域链查找,而不能从父作用域引用子作用域中的变量和引用。

    作用域

    JavaScript作用域为静态作用域static scope,也可以称为词法作用域lexical scope,其主要特征在于,函数作用域中遇到既不是参数也不是函数内部定义的局部变量时,去函数定义时上下文中查。 而与之相对应的是动态作用域dynamic scope则不同,其函数作用域中遇到既不是参数也不是函数内部定义的局部变量时,到函数调用时的上下文中去查。

    var a = 1;
    var s = function(){
        console.log(a);
    };
    
    (function(){
        var a = 2;
        s(); // 1
    })();
    

    调用s()是打印的a1,此为静态作用域,也就是声明时即规定作用域,而假如是动态作用域的话在此处会打印2。现在大部分语言都采用静态作用域,比如CC++JavaPHPPython等等,具有动态作用域的语言有Emacs LispCommon LispPerl等。

    全局作用域

    直接声明在顶层的变量或方法就运行在全局作用域,借用函数的[[Scopes]]属性来查看作用域,[[Scopes]]是保存函数作用域链的对象,是函数的内部属性无法直接访问但是可以打印来查看。

    function s(){}
    console.dir(s);
    /*
      ...
      [[Scopes]]: Scopes[1]
        0: Global ...
    */
    // 可以看见声明的s函数运行的上下文环境是全局作用域
    

    函数作用域

    当声明一个函数后,在函数内部声明的方法或者成员的运行环境就是此函数的函数作用域

    (function localContext(){
        var a = 1;
        function s(){ return a; }
        console.dir(s);
    })();
    /*
      ...
      [[Scopes]]: Scopes[2]
        0: Closure (localContext) {a: 1}
        1: Global ...
    */
    // 可以看见声明的s函数运行的上下文环境是函数localContext的作用域,也可以称为局部作用域
    

    块级作用域

    代码块内如果存在let或者const,代码块会对这些命令声明的变量从块的开始就形成一个封闭作用域。

    {
        let a = 1;
        function s(){return a;}
        console.dir(s);
        /*
          ...
          [[Scopes]]: Scopes[2]
            0: Block {a: 1}
            1: Global ...
        */
    }
    // 可以看见声明的s函数运行的上下文环境是Block块级作用域,也是局部作用域
    

    作用域链

    var a = 1;
    (function s(){
        var a = 2;
        console.log(a); // 2
    })();
    console.log(a); // 1
    
    var a = 1;
    function localContext(){
        var b = 2;
        function localContext2(){
            var c = 3;
            {
                let d = 4;
                function s(){ return a + b + c + d; }
                console.dir(s);
                /*
                  ...
                  [[Scopes]]: Scopes[4]
                    0: Block (localContext2) {d: 4}
                    1: Closure (localContext2) {c: 3}
                    2: Closure (localContext) {b: 2}
                    3: Global ...
                */
            }
        }
        localContext2();
    }
    localContext();
    

    可以通过[[Scopes]]看到s的作用域链,当我们在s中使用d时,在s中不存在d这个参数或者是局部变量,就会到[[Scopes]]中去查找,到Block作用域时查找到了,就获得了d的值,当使用cba时,也是同理在作用域链查找到localContext2作用域、localContext作用域、Global作用域,总结来说,当需要使用函数或者变量时,如果在当前作用域中没有查到值,就会向上级作用域去查,直到查到全局作用域,这样一个查找过程形成的链条就叫做作用域链。

    相关

    闭包 https://github.com/WindrunnerMax/EveryDay/blob/master/JavaScript/JavaScript%E9%97%AD%E5%8C%85.md
    let与const https://github.com/WindrunnerMax/EveryDay/blob/master/JavaScript/let%E4%B8%8Econst.md
    

    参考

    https://www.jianshu.com/p/a198dce5d523
    https://www.cnblogs.com/gaosirs/p/10579059.html
    
    展开全文
  • 1.函数原型作用域: 此作用域为c++程序中最小的作用域,生存周期最短。 例:int func(int i) i为参数,作用域类型为函数原型类型。 2.局部作用域

    1.函数原型作用域:

    此作用域为c++程序中最小的作用域,生存周期最短。

    例:int func(int i) i为参数,作用域类型为函数原型类型。

    2.局部作用域:与C语言类似;

    函数体或某一个模块中的变量,其作用域从声明开始,一直到声明所在的块结束为止。

    3.类的作用域

    类中的数据和函数分为公有类(public),保护类(protected),私有类(private),

    类公有派生类,保护派生类,私有派生类

    类中的成员 在public中 ,可以在其他地方直接使用  使用方法:对象.公用类成员(对象::公用类成员)

    而其他的需要借助公有类函数调用 ,但是在类中可以直接调用 。

    例: class x的对象X的成员m具有类作用域,对m的访问有三种

    (1)如果 在X的成员函数中没有声明 同名 的局部作用域标识符,那么可以在该函数内可以直接访问成员m。

    (2)通过表达式x.m或者x::m。这正是程序中访问对象的最基本的方法

    (3)通过ptr->m这样的表达式,其中ptr为指向x类的一个对象的指针。

    4.命名空间作用域

    命名空间的语法为

    namespace 命名空间名{

    各种声明(class的声明,函数的声明,变量的声明,常量的声明………)}

    如何引用呢? 命名空间名::标识符名

    例:namespace WA{    class A;    }        引用: namespace WA::A;    using namespace WA;  using WA::A;

    命名空间分为三类:1.显示   在某某命名空间中

                                        2.全局命名空间        在using   namespace std;下进行命名,也可以叫做全局变量 为static 储存类型

                                        3.匿名命名空间              例:namespace{   class A;  }

    展开全文
  • 1.ES5只有全局作用域和函数作用域,没有块级作用域 这会带来一些不必要的麻烦 1.由于变量提升而导致内层变量覆盖外层变量 var tmp = new Date(); function f(){ console.log(tmp); if(false){ var tmp = ...
  • 全局作用域和函数作用域

    千次阅读 2019-02-10 17:03:25
    全局作用域和函数作用域 在ES5中,只全局作用域和函数作用域。这会导致函数作用域覆盖了全局作用域;亦或者循环中的变量泄露为全局变量。 例如: // 1.函数作用域覆盖了全局作用域,发生了变量提升,函数声明大于var...
  • 全局作用域: 在任何地方都可以访问到的变量就是全局变量,对应全局作用域。 局部作用域: 只在固定的代码片段内可访问到的变量,最常见的例如函数内部。对应局部作用域(函数作用域) 注意点: 不使用var声明的变量...
  • python作用域,变量作用域

    千次阅读 2019-07-02 20:33:02
    变量作用域 一个程序的所有变量并不是在哪个位置都可以访问的。访问权限取决于这个变量是在哪里赋值的。 变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。 如下为两种最基本的变量的作用域: ...
  • 在被调用函数内赋值的变元和变量,处于该函数的“局部作用域”。 在所有函数之外赋值的变量,属于“全局作用域”。 全局作用域中的代码不能使用任何局部变量; 但是,局部作用域可以访问全局变量; 一个函数的局部作用域...
  • js作用域 作用域链 闭包

    千次阅读 2018-08-23 13:32:42
    作用域 变量 var声明的变量,其作用域是函数体的全部,没有块作用域 let声明的变量拥有块级作用域。 1) 局部变量: 函数内声明的变量为局部变量,为局部作用域,只能在函数内访问; function studentnum()...
  • Spring的 bean有5种作用域分别是:singleton、prototype、request、session和globalSession(不常用)。 其中后三种request、session、global session专用于Web应用程序。 1、singleton 单例 在Spring里,通过容器...
  • 块级作用域与函数作用域

    千次阅读 2018-03-24 10:30:29
    函数作用域:变量在定义的环境中以及嵌套的子函数中处处可见; 块级作用域:变量在离开定义的块级代码后立即被回收。 函数作用域 在ES6之前,js的作用域只有两种:函数作用域和全局作用域。使用var声明的...
  • Js中的作用域作用域链 前言 阅读本文,请先阅读:Js中的函数相关:创建函数的三种方式、函数的形参和实参、返回值、return、break、continue的区别、重载和arguments、匿名函数、回调函数 阅读本文,请千万...
  • 作用域作用域链 精解

    千次阅读 2019-05-24 17:24:58
    **作用域(scope):一个变量的可用范围 2种: 全局作用域 :任何地方都可以访问,反复使用 函数作用域(局部作用域):仅在函数内部可访问,不能反复使用 例子: var a=10; function fun() { var a=100;...
  • 变量的作用域无非就是两种:全局作用域和局部作用域。  全局作用域:  最外层函数定义的变量拥有全局作用域,即对任何内部函数来说,都是可以访问的: &lt;script&gt; var outerVar = "outer&...
  • JavaScript作用域作用域链知多少

    千次阅读 2020-09-12 19:44:33
    作用域就是代码的执行环境,全局执行环境就是全局作用域,函数的执行环境就是函数作用域(私有作用域),他们都是栈内存。全局执行环境是最外围的执行环境,根据ECMAScript所实现的宿主环境不同,表示的执行环境的对象...
  • JavaScript关于作用域作用域链和闭包的理解

    万次阅读 多人点赞 2017-04-29 22:04:30
    作用域先来谈谈变量的作用域 变量的作用域无非就是两种:全局变量和局部变量。 全局作用域: 最外层函数定义的变量拥有全局作用域,即对任何内部函数来说,都是可以访问的: var outerVar = "outer"; function ...
  • JavaScript静态作用域和动态作用域

    千次阅读 2018-03-20 23:50:40
    动态作用域; 静态作用域
  • 函数作用域和块作用域

    千次阅读 2018-10-29 21:31:32
    1.函数中的作用域  1. 无论标识符声明在作用域的何处,这个标识符所代表的变量或函数都将附属于所处作用域的气泡。  2.函数作用域的含义:属于这个函数的全部变量可以在整个函数的范围内使用及复用。 ...
  • JS 作用域作用域

    千次阅读 2018-08-27 16:23:33
    1. 作用域 作用域就是代码的执行环境,全局执行环境就是全局作用域,函数的执行环境就是私有作用域,它们都是栈内存。 执行环境定义了变量或函数有权访问的其他数据,决定了它们各自的行为。每个执行环境都有一个...
  • Android 10适配要点,作用域存储

    万次阅读 多人点赞 2020-04-14 08:42:48
    在Android 10众多的行为变更当中,有一点是非常值得引起我们重视的,那就是作用域存储。这个新功能直接颠覆了长久以来我们一直惯用的外置存储空间的使用方式,因此大量App都将面临着较多代码模块的升级。然而,对于...
  • 作用域设置、作用域作用域描述符Atom支持语言特定的设置。你可以在Markdown文件中软换行,或者在Python中把tab的宽度设置为4。语言特定的设置只是一些东西的子集,我们把它叫做“作用域设置”。作用域设置可以只...
  • var : 在调用函数时创建函数作用域,函数执行完毕,作用域销毁。 在函数作用域中可以访问到全局作用域的变量,而全局的访问不到函数作用域的变 量;函数作用域可以在相同的作用域重复声明一个变量,存在变量...
  • 作用域作用域链知识小结 作用域是JavaScript最重要的概念之一,想要学好JavaScript就需要理解JavaScript作用域作用域链的工作原理。今天我在这里将作用域作用域链做一个小小的总结,希望能帮到大家。 一....
  • Spring中bean的作用域与生命周期

    万次阅读 多人点赞 2017-06-17 22:29:18
    在Spring中,那些组成应用程序的主体及由Spring IoC容器所管理的对象,被称之为bean。简单地讲,bean就是由IoC容器初始化、装配及管理的对象,除此之外,bean就与应用程序中的其他对象没有什么区别了。...
  • Spring中Singleton作用域和Prototype作用域

    千次阅读 多人点赞 2019-04-09 09:19:46
    singleton作用域就是单例模式;用spring容器实现单例模式 而prototype作用域可以理解为多例模式! Singleton作用域例子: 左侧的ref就是右侧bean的id,这里就是把右边的bean通过spring注入到左侧的bean中; ...
  • 作用域作用域链及预解析

    千次阅读 2019-04-08 16:29:36
    局部作用域和全局作用域 js中没有块级作用域—一对括号中定义的变量,这个变量可以在大括号外面使用 函数中定义的变量是局部变量 作用域链:变量的使用,从里向外,层层的搜索,搜索到了就可以直接使用了 层层搜索,搜索到...
  • 作用域作用域

    千次阅读 2016-09-11 16:33:03
    当js中函数包含函数里面函数作用域是什么?
  • 1.全局作用域 用 var 在全局(函数外)声明的所有变量,都具有全局作用域,即: 网页中所有脚本和函数均可使用。 var carName = " Volvo"; // 此处可调用 carName 变量 function myFunction() { // ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 119,761
精华内容 47,904
关键字:

作用域