问题:JavaScript中变量的范围是什么?

javascript中变量的范围是什么?它们在函数内部和外部的作用域是否相同?还是有关系吗?另外,如果变量是全局定义的,这些变量将存储在哪里?

标签:javascript,function,variables,scope,var

回答1:

我认为我能做的最好的事情就是给您提供一些实例进行研究。实际上,JavaScript程序员是根据他们对范围的理解程度来排名的。有时可能会违反直觉。

  1. 全局范围的变量

    // global scope
    var a = 1;
    
    function one() {
      alert(a); // alerts '1'
    }
    
  2. 本地范围

    // global scope
    var a = 1;
    
    function two(a) { // passing (a) makes it local scope
      alert(a); // alerts the given argument, not the global value of '1'
    }
    
    // local scope again
    function three() {
      var a = 3;
      alert(a); // alerts '3'
    }
    
  3. 中级 JavaScript中没有块作用域(ES5; ES6引入了 let const )

    a。

    var a = 1;
    
    function four() {
      if (true) {
        var a = 4;
      }
    
      alert(a); // alerts '4', not the global value of '1'
    }
    

    b。

    var a = 1;
    
    function one() {
      if (true) {
        let a = 4;
      }
    
      alert(a); // alerts '1' because the 'let' keyword uses block scoping
    }
    

    c。

    var a = 1;
    
    function one() {
      if (true) {
        const a = 4;
      }
    
      alert(a); // alerts '1' because the 'const' keyword also uses block scoping as 'let'
    }
    
  4. 中级对象属性

    var a = 1;
    
    function Five() {
      this.a = 5;
    }
    
    alert(new Five().a); // alerts '5'
    
  5. 高级关闭

    var a = 1;
    
    var six = (function() {
      var a = 6;
    
      return function() {
        // JavaScript "closure" means I have access to 'a' in here,
        // because it is defined in the function in which I was defined.
        alert(a); // alerts '6'
      };
    })();
    
  6. 高级基于原型的范围解析

    var a = 1;
    
    function seven() {
      this.a = 7;
    }
    
    // [object].prototype.property loses to
    // [object].property in the lookup chain. For example...
    
    // Won't get reached, because 'a' is set in the constructor above.
    seven.prototype.a = -1;
    
    // Will get reached, even though 'b' is NOT set in the constructor.
    seven.prototype.b = 8;
    
    alert(new seven().a); // alerts '7'
    alert(new seven().b); // alerts '8'
    

  7. 全局+本地一个额外的复杂案例

    var x = 5;
    
    (function () {
        console.log(x);
        var x = 10;
        console.log(x); 
    })();
    

    这将打印出undefined10而不是510,因为JavaScript总是将变量声明(而不是初始化)移到作用域的顶部,从而等效于以下代码的代码:

    var x = 5;
    
    (function () {
        var x;
        console.log(x);
        x = 10;
        console.log(x); 
    })();
    
  8. 捕获子句范围的变量

    var e = 5;
    console.log(e);
    try {
        throw 6;
    } catch (e) {
        console.log(e);
    }
    console.log(e);
    

    这将打印出56 5。在catch子句中,e遮盖了全局变量和局部变量。但是,此特殊作用域仅适用于捕获的变量。如果在catch子句中编写varf;,则与在try-catch块之前或之后定义它完全相同。

回答2:

Javascript使用范围链为给定功能建立范围。通常有一个全局范围,并且定义的每个函数都有其自己的嵌套范围。在另一个函数中定义的任何函数都具有与外部函数链接的局部作用域。始终是源中定义范围的位置。

范围链中的元素基本上是一个Map,带有指向其父范围的指针。

解析变量时,javascript从最内部的范围开始并向外搜索。

回答3:

全局声明的变量具有全局范围。在函数中声明的变量的作用域为该函数,并且阴影全局变量具有相同的名称。

(我确信真正的JavaScript程序员可以在其他答案中指出很多细节。特别是我遇到了此页面随时了解的确切含义。希望这个更具介绍性的链接足以使您入门。)

回答4:

旧式JavaScript

传统上,JavaScript实际上只有两种类型的作用域:

  1. 全局范围:从应用程序(*)
  2. 开始,变量在整个应用程序中都是已知的
  3. 功能范围 函数 在函数(*)
  4. 的开头声明它们

我将不再赘述,因为已经有许多其他答案解释了差异。


现代JavaScript

最新的JavaScript规范< / strong> 现在还允许第三个范围:

  1. 块范围 代码块 ,从它们被声明(**)

如何创建块作用域变量?

传统上,您可以这样创建变量:

var myVariable = "Some text";

像这样创建块作用域变量:

let myVariable = "Some text";

那么功能范围和块范围之间有什么区别?

要了解功能范围和块范围之间的区别,请考虑以下代码:

// i IS NOT known here
// j IS NOT known here
// k IS known here, but undefined
// l IS NOT known here

function loop(arr) {
    // i IS known here, but undefined
    // j IS NOT known here
    // k IS known here, but has a value only the second time loop is called
    // l IS NOT known here

    for( var i = 0; i < arr.length; i++ ) {
        // i IS known here, and has a value
        // j IS NOT known here
        // k IS known here, but has a value only the second time loop is called
        // l IS NOT known here
    };

    // i IS known here, and has a value
    // j IS NOT known here
    // k IS known here, but has a value only the second time loop is called
    // l IS NOT known here

    for( let j = 0; j < arr.length; j++ ) {
        // i IS known here, and has a value
        // j IS known here, and has a value
        // k IS known here, but has a value only the second time loop is called
        // l IS NOT known here
    };

    // i IS known here, and has a value
    // j IS NOT known here
    // k IS known here, but has a value only the second time loop is called
    // l IS NOT known here
}

loop([1,2,3,4]);

for( var k = 0; k < arr.length; k++ ) {
    // i IS NOT known here
    // j IS NOT known here
    // k IS known here, and has a value
    // l IS NOT known here
};

for( let l = 0; l < arr.length; l++ ) {
    // i IS NOT known here
    // j IS NOT known here
    // k IS known here, and has a value
    // l IS known here, and has a value
};

loop([1,2,3,4]);

// i IS NOT known here
// j IS NOT known here
// k IS known here, and has a value
// l IS NOT known here

在这里,我们可以看到变量j仅在第一个for循环中是已知的,而在之前和之后都不是。但是,我们的变量i在整个函数中都是已知的。

此外,请考虑在声明块范围变量之前不知道它们,因为它们没有被提升。您也不允许在同一块中重新声明相同的块范围变量。这使得块范围的变量比全局变量或功能范围的变量更不容易出错,全局变量或功能范围的变量是悬挂的,并且在有多个声明的情况下不会产生任何错误。


今天使用块范围变量安全吗?

今天是否可以安全使用,取决于您的环境:


如何跟踪浏览器支持

在阅读此答案时,有关哪些浏览器支持let语句的最新概述,请参见 我可以使用页面


(*)全局和功能范围的变量可以在声明之前进行初始化和使用,因为JavaScript变量是 吊装 。这意味着声明始终在作用域的顶部。

(**)不提升块范围变量

回答5:

这是一个例子:

<script>

var globalVariable = 7; //==window.globalVariable

function aGlobal( param ) { //==window.aGlobal(); 
                            //param is only accessible in this function
  var scopedToFunction = {
    //can't be accessed outside of this function

    nested : 3 //accessible by: scopedToFunction.nested
  };

  anotherGlobal = {
    //global because there's no `var`
  }; 

}

</script>

您将要研究闭包,以及如何使用闭包作为私有成员

回答6:

据我所知,关键是Javascript具有功能级别范围和更常见的C块范围。

这是一篇有关该主题的好文章。

回答7:

在" Javascript 1.7"(Mozilla对Javascript的扩展)中,还可以使用 let语句

 var a = 4;
 let (a = 3) {
   alert(a); // 3
 }
 alert(a);   // 4

回答8:

最初由 Brendan Eich 设计的JavaScript范围定义思想来自HyperCard 脚本语言 HyperTalk

使用这种语言,显示的过程类似于一堆索引卡。有一个称为背景的主卡。它是透明的,可以看作是底层卡片。此基本卡上的所有内容均与位于其上方的卡共享。放在顶部的每张卡都有自己的内容,该内容优先于前一张卡,但如果需要,仍可以访问前一张卡。

这正是设计JavaScript作用域系统的方式。它只是具有不同的名称。 JavaScript中的卡称为 执行上下文 ECMA < / a> 。这些上下文中的每一个都包含三个主要部分。可变环境,词法环境和this绑定。回到卡片参考,词法环境包含来自堆栈中较低位置的先前卡片的所有内容。当前上下文位于堆栈的顶部,声明的所有内容都将存储在变量环境中。在命名冲突的情况下,可变环境优先。

此绑定将指向包含的对象。有时范围或执行上下文会在不更改包含对象的情况下发生变化,例如在声明的函数中,包含对象可能是window或构造函数。

这些执行上下文是在控制权转移时创建的。当代码开始执行时转移控制权,这主要是从函数执行开始。

这就是技术解释。在实践中,记住这一点很重要

  • 范围从技术上讲是"执行上下文"
  • 上下文构成了存储变量的环境的堆栈
  • 堆栈的顶部优先(底部是全局上下文)
  • 每个函数都会创建一个执行上下文(但并不总是一个新的this绑定)

将此内容应用于此页面上的先前示例之一(5."关闭"),可以遵循执行上下文堆栈。在此示例中,堆栈中有三个上下文。它们由外部上下文定义,由var 6调用的立即调用函数中的上下文,以及在var 6的立即调用函数内部的返回函数中的上下文。

i )外部环境。它具有a = 1的可变环境
ii )IIFE上下文,它具有a = 1的词法环境,但是a = 6的可变环境在堆栈中具有优先权< br> iii )返回的函数上下文,它的词法环境为a = 6,这是调用警报时在警报中引用的值。

回答9:

1)有一个全局范围,一个函数范围以及with和catch范围。通常,变量没有"块"级作用域-with和catch语句将名称添加到其块中。

2)作用域一直由函数嵌套到全局作用域。

3)通过遍历原型链来解析属性。 with语句将对象属性名称带到with块定义的词法范围内。

编辑:ECMAAScript 6(Harmony)被指定为支持let,我知道chrome允许使用" harmony"标志,所以也许它确实支持它。

让我们可以支持块级作用域,但是您必须使用关键字来实现它。

编辑:基于本杰明指出注释中的with和catch语句,我编辑了该帖子,并添加了更多内容。 with和catch语句都将变量引入到它们各自的块中,并且是块作用域。这些变量是传递给它们的对象的属性的别名。

 //chrome (v8)

 var a = { 'test1':'test1val' }
 test1   // error not defined
 with (a) { var test1 = 'replaced' }
 test1   // undefined
 a       // a.test1 = 'replaced'

编辑:澄清示例:

test1的作用域为with块,但别名为a.test1。 " Var test1"在上层词法上下文(函数或全局)中创建一个新变量test1,除非它是-的属性。

赞!小心使用'with'-就像var是noop一样,如果变量已经在函数中定义,就从对象导入的名称而言,它也是noop!对已经定义的名称稍加注意将使此操作更加安全。因此,我个人永远不会使用。

回答10:

我发现,许多JavaScript新手都难以理解,继承默认情况下是该语言可用的,并且函数作用域是迄今为止唯一的作用域。我提供了我在去年年底编写的名为JSPretty的美化工具的扩展。要素颜色在代码中作用域,并且始终将颜色与该作用域中声明的所有变量关联。当一个颜色的变量来自一个范围时,在另一范围中使用闭包进行可视化演示。

在以下位置尝试功能:

查看演示:

在以下位置查看代码:

当前,该功能支持深度为16个嵌套函数,但目前不为全局变量着色。

回答11:

JavaScript只有两种类型的作用域:

  1. 全局范围:全局只不过是窗口级范围。这里,整个应用程序中都存在变量。
  2. 功能范围:使用var关键字在函数中声明的变量具有功能范围。

每当调用一个函数时,都会创建一个变量作用域对象(并包含在作用域链中),随后是JavaScript中的变量。

        a = "global";
         function outer(){ 
              b = "local";
              console.log(a+b); //"globallocal"
         }
outer();

范围链->

  1. 窗口级别-aouter函数在范围链中处于最高级别。
  2. 当外部函数调用一个新的变量范围对象(并包含在范围链中)时,在其中添加了变量b

现在,当需要变量a时,它首先搜索最近的变量作用域,如果变量不存在,则将其移至变量作用域链的下一个对象。在这种情况下,该对象为窗口级。 / p>

回答12:

仅在其他答案中添加作用域,它是所有已声明的标识符(变量)的查找列表,并对当前执行的代码如何访问使用严格的规则集。该查找可能出于分配给变量的目的,这是一个LHS(左侧)引用,也可能出于检索其值的目的,这是一个RHS(右侧)引用。这些查找是JavaScript引擎在编译和执行代码时在内部进行的操作。

因此,从这个角度来看,我认为可以对我在Kyle Simpson的《范围和闭包》电子书中找到的照片有所帮助:

从他的电子书中引用:

建筑物代表了我们程序的嵌套作用域规则集。无论您身在何处,建筑物的第一层都代表您当前正在执行的范围。该建筑的顶层是全球范围。您可以通过查看当前楼层来解析LHS和RHS参考,如果找不到,则将电梯带到下一层,在那儿查看,然后在下一层,依此类推。到达顶层(全局范围)后,您要么找到自己想要的东西,要么没有找到想要的东西。但是无论如何你都必须停下来。

值得一提的是,"一旦找到第一个匹配项,示波器就会停止搜索。"

"作用域级别"的概念解释了为什么如果要在嵌套函数中查找新创建的作用域,则可以更改" this"。以下是进入所有这些详细信息的链接,您想要的一切了解javascript范围

回答13:

运行代码。希望这会为范围界定提供一个思路

Name = 'global data';
document.Name = 'current document data';
(function(window,document){
var Name = 'local data';
var myObj = {
    Name: 'object data',
    f: function(){
        alert(this.Name);
    }
};

myObj.newFun = function(){
    alert(this.Name);
}

function testFun(){
    alert("Window Scope : " + window.Name + 
          "\nLocal Scope : " + Name + 
          "\nObject Scope : " + this.Name + 
          "\nCurrent document Scope : " + document.Name
         );
}


testFun.call(myObj);
})(window,document);

回答14:

全球范围:

全局变量与全局恒星完全一样(成龙,纳尔逊·曼德拉)。您可以从应用程序的任何部分访问它们(获取或设置值)。全局功能就像全局事件(新年,圣诞节)。您可以从应用程序的任何部分执行(调用)它们。

//global variable
var a = 2;

//global function
function b(){
   console.log(a);  //access global variable
}

本地范围:

如果您在美国,可能会认识臭名昭著的名人金·卡戴珊(Kim Kardashian)(她设法制作了小报)。但是美国以外的人不会认出她。她是当地的明星,一定会进入她的领土。

局部变量就像局部恒星。您只能在范围内访问它们(获取或设置值)。局部函数就像局部事件-您只能在该范围内执行(庆祝)。如果您想从范围之外访问它们,则会出现参考错误

function b(){
   var d = 21; //local variable
   console.log(d);

   function dog(){  console.log(a); }
     dog(); //execute local function
}

 console.log(d); //ReferenceError: dddddd is not defined    

查看本文以获得对范围的深入了解

回答15:

几乎只有两种类型的JavaScript范围:

  • 每个var声明的范围都与最直接封闭的函数相关联
  • 如果var声明没有封闭函数,则为全局范围

因此,除功能以外的任何块均不会创建新的作用域。这就解释了为什么for循环会覆盖外部作用域变量:

var i = 10, v = 10;
for (var i = 0; i < 5; i++) { var v = 5; }
console.log(i, v);
// output 5 5

改为使用函数

var i = 10, v = 10;
$.each([0, 1, 2, 3, 4], function(i) { var v = 5; });
console.log(i,v);
// output 10 10

在第一个示例中,没有块作用域,因此最初声明的变量被覆盖。在第二个示例中,由于该函数而有了新作用域,因此最初声明的变量为SHADOWED,并且不会被覆盖。

您几乎需要了解JavaScript范围,除了:

因此,您可以看到JavaScript范围实际上非常简单,尽管并不总是直观的。需要注意的几件事:

  • var声明被提升到作用域的顶部。这意味着无论var声明发生在何处,对于编译器而言,好像var本身都位于顶部
  • 同一范围内的多个var声明被组合

所以这段代码:

var i = 1;
function abc() {
  i = 2;
  var i = 3;
}
console.log(i);     // outputs 1

等效于:

var i = 1;
function abc() {
  var i;     // var declaration moved to the top of the scope
  i = 2;
  i = 3;     // the assignment stays where it is
}
console.log(i);

这似乎与直觉相反,但是从命令式语言设计者的角度来看是有道理的。

回答16:

现代Js,ES6 +,'const'和'let'

您应该对创建的每个变量都使用块作用域,就像大多数其他主要语言一样。 var已过时。这使您的代码更安全,更可维护。

const应该用于 95%的案例。这使得变量 reference 不能更改。数组,对象和DOM节点属性可以更改,并且应该为const

let应该用于希望重新分配的任何变量。这包括在for循环中。如果您在初始化后更改了值,请使用let

块作用域意味着该变量将仅在声明该变量的方括号内可用。这扩展到内部范围,包括在您的范围内创建的匿名函数。

回答17:

在JS中只有函数作用域。不阻止范围!您也可以看到正在起吊的东西。

var global_variable = "global_variable";
var hoisting_variable = "global_hoist";

// Global variables printed
console.log("global_scope: - global_variable: " + global_variable);
console.log("global_scope: - hoisting_variable: " + hoisting_variable);

if (true) {
    // The variable block will be global, on true condition.
    var block = "block";
}
console.log("global_scope: - block: " + block);

function local_function() {
    var local_variable = "local_variable";
    console.log("local_scope: - local_variable: " + local_variable);
    console.log("local_scope: - global_variable: " + global_variable);
    console.log("local_scope: - block: " + block);
    // The hoisting_variable is undefined at the moment.
    console.log("local_scope: - hoisting_variable: " + hoisting_variable);

    var hoisting_variable = "local_hoist";
    // The hoisting_variable is now set as a local one.
    console.log("local_scope: - hoisting_variable: " + hoisting_variable);
}

local_function();

// No variable in a separate function is visible into the global scope.
console.log("global_scope: - local_variable: " + local_variable);

回答18:

尝试这个奇怪的例子。在下面的示例中,如果a是初始化为0的数字,则将看到0,然后是1。除了a是一个对象,然后javascript会将f的指针(而不是其副本)传递给f1。结果是您两次都收到相同的警报。

var a = new Date();
function f1(b)
{
    b.setDate(b.getDate()+1);
    alert(b.getDate());
}
f1(a);
alert(a.getDate());

回答19:

我的理解是,有3个范围:全局范围,全局可用;局部作用域,可用于整个功能,而不受块的影响;和块作用域,仅对使用它的块,语句或表达式可用。全局和局部作用域在函数内或外部用关键字" var"表示,而块作用域用关键字" let"表示。

对于那些相信只有全局范围和局部范围的人,请解释为什么Mozilla会有整个页面描述JS中块范围的细微差别。

https://developer.mozilla.org / en-US / docs / Web / JavaScript / Reference / Statements / let

回答20:

在JavaScript中,作用域有两种类型:

  • 本地范围
  • 全球范围

以下函数具有局部作用域变量carName。而且该变量不能从函数外部访问。

function myFunction() {
    var carName = "Volvo";
    alert(carName);
    // code here can use carName
}

以下类具有全局范围变量carName。而且该变量可以从类中的任何地方访问。

class {

    var carName = " Volvo";

    // code here can use carName

    function myFunction() {
        alert(carName);
        // code here can use carName 
    }
}

回答21:

在EcmaScript5中,主要有两个范围,本地范围全局范围,但是在EcmaScript6中,我们主要有三个范围,本地范围,全局范围和一个称为阻止范围

块范围的示例是:-

for ( let i = 0; i < 10; i++)
{
 statement1...
statement2...// inside this scope we can access the value of i, if we want to access the value of i outside for loop it will give undefined.
}

回答22:

ECMAScript 6引入了let和const关键字。可以使用这些关键字代替var关键字。与var关键字相反,let和const关键字支持在块语句中声明局部作用域。

var x = 10
let y = 10
const z = 10
{
  x = 20
  let y = 20
  const z = 20
  {
    x = 30
    // x is in the global scope because of the 'var' keyword
    let y = 30
    // y is in the local scope because of the 'let' keyword
    const z = 30
    // z is in the local scope because of the 'const' keyword
    console.log(x) // 30
    console.log(y) // 30
    console.log(z) // 30
  }
  console.log(x) // 30
  console.log(y) // 20
  console.log(z) // 20
}

console.log(x) // 30
console.log(y) // 10
console.log(z) // 10

回答23:

ES5及更低版本:

最初,JavaScript中的变量(在ES6之前)在词法函数范围内。词法范围是指您可以通过"查看"代码来查看变量的范围。

使用var关键字声明的每个变量的作用域均在该函数范围内。但是,如果在该函数中声明了其他函数,则这些函数将有权访问外部函数的变量。这称为作用域链。它以以下方式工作:

  1. 当函数试图解析变量值时,它首先会考虑其自身的作用域。这是函数主体,即大括号{}之间的所有内容(其他函数中的变量均在此范围内)。
  2. 如果找不到函数体内的变量,它将爬到链上,并在定义函数的地方查看函数中的变量范围 。这就是词汇作用域的含义,我们可以在代码中看到定义此函数的位置,因此仅查看代码即可确定作用域链。

示例:

// global scope
var foo = 'global';
var bar = 'global';
var foobar = 'global';

function outerFunc () {
 // outerFunc scope
 var foo = 'outerFunc';
 var foobar = 'outerFunc';
 innerFunc();
 
 function innerFunc(){
 // innerFunc scope
  var foo = 'innerFunc';
  console.log(foo);
  console.log(bar);
  console.log(foobar);
  }
}

outerFunc();

当我们尝试将变量foobarfoobar记录到控制台时,会发生以下情况:

  1. 我们尝试将foo登录到控制台,可以在函数innerFunc本身内找到foo。因此,foo的值将解析为字符串innerFunc
  2. 我们尝试将bar登录到控制台,而在innerFunc函数本身内部找不到bar。因此,我们需要攀登范围链。我们首先查看外部函数,其中定义了函数innerFunc。这是函数outerFunc。在outerFunc的范围内,我们可以找到变量bar,其中包含字符串'outerFunc'。
  3. foobar在innerFunc中找不到。 。因此,我们需要将范围链爬到innerFunc范围。在这里也找不到它,我们将爬升到全局范围(即最外部的范围)的另一层。我们在这里找到变量foobar,其中包含字符串" global"。如果在攀登范围链之后找不到变量,则JS引擎将抛出 referenceError

ES6(ES 2015)及更低版本:

词汇范围和作用域链的相同概念仍然适用于ES6。但是,引入了一种声明变量的新方法。有以下内容:

  • let:创建一个块范围变量
  • const:创建一个块范围的变量,该变量必须初始化并且不能重新分配

varlet / const之间的最大区别是var是函数范围的,而let / const是块作用域的。这是一个说明这一点的示例:

let letVar = 'global';
var varVar = 'global';

function foo () {
  
  if (true) {
    // this variable declared with let is scoped to the if block, block scoped
    let letVar = 5;
    // this variable declared with let is scoped to the function block, function scoped
    var varVar = 10;
  }
  
  console.log(letVar);
  console.log(varVar);
}


foo();

在上面的示例中,letVar记录全局值,因为使用let声明的变量是块作用域的。它们不再存在于各自的块外,因此无法在if块外访问变量。

回答24:

前端编码器经常遇到的一个非常常见的问题(尚未描述)是HTML中的内联事件处理程序可见的范围-例如,

<button onclick="foo()"></button>

on*属性可以引用必须的变量范围如下:

  • 全局(工作的内联处理程序几乎总是引用全局变量)
  • 文档的属性(例如,作为独立变量的querySelector将指向document.querySelector;很少)
  • 处理程序附加到的元素的属性(如上;罕见)

否则,调用处理程序时,您将收到ReferenceError。因此,例如,如果内联处理程序引用的是 inside window.onload$(function(){将失败,因为内联处理程序只能引用全局范围内的变量,并且该函数不是全局的:

window.addEventListener('DOMContentLoaded', () => {
  function foo() {
    console.log('foo running');
  }
});

文档的属性和附加到处理程序的元素的属性也可以作为内联处理程序中的独立变量引用,因为内联处理程序是通过在两个with中的 ,其中一个用于document,一个用于元素。这些处理程序中的变量作用域链极其不直观,并且工作的事件处理程序将可能需要。(应该避免使用 )。

由于内联处理程序中的作用域链太奇怪了,并且由于内联处理程序需要全局污染才能起作用,因此避免它们可能更容易。而是使用Javascript(例如,使用addEventListener)而不是HTML标记来附加事件处理程序。

<button onclick="foo()">click</button>


值得一提的是,与在顶级运行的普通

回答25:

JavaScript中有两种作用域。

  1. 全局作用域:在全局作用域中声明的变量可以在程序中的任何位置正常使用。例如:

    var carName = " BMW";
    
    // code here can use carName
    
    function myFunction() {
         // code here can use carName 
    }
    
  2. 功能范围或本地范围:在此范围中声明的变量只能在其自己的函数中使用。例如:

    // code here can not use carName
    function myFunction() {
       var carName = "BMW";
       // code here can use carName
    }
    
回到顶部