亲宝软件园·资讯

展开

JS变量声明

​ Shrimpsss   ​ 人气:0

前言

ECMAScript 变量是松散类型的,变量可以用于保存任何类型的数据,每个变量只不过是一个用于保存任意值的命名占位符。

本文主要讲述 Javascript 中三大变量声明的用法与写法,有 3 个关键字可以声明变量:varconst 和 let。其中,var 在ECMAScript 的所有版本中都可以使用,而 const 和 let 只能在 ECMAScript 6 及更晚的版本中使用。(现在最新版为 ECMAScript 12

Var

var 操作符用于定义变量(var 也是一个关键字),后跟变量名(即标识符)

基础写法

声明未定义值

这里定义了一个名为test的变量,可以用它保存任何类型的值

 var test;

注意: 不初始化的情况下,变量会保存一个特殊值 undefined

声明定义值

ECMAScript 实现变量初始化,因此可以同时定义变量并设置它的值,如下:

 // 声明定义值
 var test = "good job"; 

像这样的初始化变量不会将它标识为字符串类型,随时可以改变保存的值,从而改变值的类型。

不推荐写法

在下面这个例子中,变量 test 首先被定义为一个保存字符串值的变量,然后又被重写为保存了数值:

 var test = "good job";  
 test = 299;  //合法,但不推荐
 /* 像这种单独的变量可以直接赋值就没必要另起去改了 没必要 */

虽然不推荐改变变量保存值的类型,但这在 ECMAScript 中是完全有效的。

var 声明作用域

使用 var 定义的变量会成为包含它的函数的局部变量,简称为作用域变量。

局部作用域

使用 var 在一个函数内部定义一个变量,就意味着该变量将在函数退出时被销毁,如下:

 function fun() { 
  var test = "Hello World"; // 局部变量
 } 
 fun(); 
 console.log(test); // 出错!

这里,test 变量是在函数内部使用 var 定义的,函数为 fun(),调用它会创建这个变量并给它赋值;调用之后变量随即被销毁,因此示例中的最后一行会导致错误。

全局作用域

在函数内定义变量时省略 var 操作符,可以创建一个全局变量,如下

 function fun() { 
  test = "Hello World"; // 局部变量
 } 
 fun(); 
 console.log(test); // "Hello World"

去掉之前的 var 操作符之后,test 就变成了全局变量;只要调用一次函数 fun(),就会定义这个变量,并且可以在函数外部访问到。

注意:虽然可以通过省略 var 操作符定义全局变量,但不推荐这么做。

在严格模式下,如果像这样给未声明的变量赋值,则会导致抛出 ReferenceError。

便捷语法

如果需要定义多个变量,可以在一条语句中用逗号分隔每个变量(及可选的初始化),如下:

 var name = "hey~~", 
     name = "shrimpsss", 
     age = 99;

这里定义并初始化了 3 个变量,因为 ECMAScript 是松散类型的,所以使用不同数据类型初始化的变量可以用一条语句来声明; 虽然插入换行和空格缩进并不是必需的,但这样有利于阅读理解。

注意: 在严格模式下,不能定义名为 eval 和 arguments 的变量,否则会导致语法错误。

var 声明提升

var 这个关键字在函数中声明变量时会自动提升到函数作用域顶部,如下:

 function foo() { 
  console.log(age); 
  var age = 26; 
 } 
 foo(); // undefined 

之所以不会报错,是因为 ECMAScript 运行时把它看成等价于如下代码:

 function foo() { 
  var age; 
  console.log(age); 
  age = 26; 
 } 
 foo(); // undefined 

这就所谓的“提升”(hoist),也就是把所有变量声明都拉到函数作用域的顶部。

Let

let 跟 var 的作用差不多,但 let 声明的范围是块作用域(var 声明的范围是函数作用域)

块作用域是函数作用域的子集,因此适用于 var 的作用域限制同样也适用于 let

let 作用域

let 作用域只能在块作用域里访问,不能跨块访问,也不能跨函数访问

两者的对比会更加凸显不一,如下:

 // --- var ---
 if (true) { 
  var name = 'king'; 
  console.log(name); // Matt 
 } 
 console.log(name); // Matt
 ​
 // --- let ---
 if (true) { 
  let age = 26; 
  console.log(age); // 26 
 } 
 console.log(age); // ReferenceError: age 没有定义

在这里,age 变量之所以不能在 if 块外部被引用,是因为它的作用域仅限于该块内部。

冗余声明

let 不允许同一个块作用域中出现冗余声明

 var name; 
 var name; 
 let age; 
 let age; // SyntaxError;标识符 age 已经声明过了

冗余声明的报错不会因混用 let 和 var 而受影响。

这两个关键字声明的并不是不同类型的变量,它们只是指出变量在相关作用域如何存在,如下:

 var name; 
 let name; // SyntaxError 
 let age; 
 var age; // SyntaxError

JavaScript 引擎会记录用于变量声明的标识符及其所在的块作用域,因此嵌套使用相同的标识符不会报错。

暂时性死区

let 与 var 的另一个重要的区别,就是 let 声明的变量不会在作用域中被提升

 // name 会被提升
 console.log(name); // undefined 
 var name = 'vito'; 
 ​
 // age 不会被提升
 console.log(age); // ReferenceError:age 没有定义
 let age = 26

在解析代码时,JavaScript 引擎也会注意出现在块后面的 let 声明,只不过在此之前不能以任何方式来引用未声明的变量。

在 let 声明之前的执行瞬间被称为“暂时性死区”(temporal dead zone),在此阶段引用任何后面才声明的变量都会抛出 ReferenceError

全局声明

与 var 关键字不同,使用 let 在全局作用域中声明的变量不会成为 window 对象的属性

 /* window.xx:在window对象中查找此属性(元素)*/
 var name = 'vito'; 
 console.log(window.name); // 'vito' 
 ​
 let age = 26; 
 console.log(window.age); // undefined

但 let 声明仍然是在全局作用域中发生的,所以相应变量会在页面的生命周期内存续。

条件声明

因为 let 的作用域是块,所以不可能检查前面是否已经使用 let 声明过同名变量,同时也就不可能在没有声明的情况下声明它,没有与var 一样的声明提升。

 /* 方便理解: 把两个<script>代码块看做一个代码块 */
 ​
 <script> 
  var name = 'Nicholas'; 
  let age = 26; 
 </script> 
 ​
 <script> 
  // 假设脚本不确定页面中是否已经声明了同名变量
  // 那它可以假设还没有声明过
  var name = 'Matt'; 
  // 这里没问题,因为可以被作为一个提升声明来处理
  // 不需要检查之前是否声明过同名变量
  let age = 36; 
  // 如果 age 之前声明过,这里会报错
 </script>

为此, let 这个新的 ES6 声明关键字,不能依赖条件声明模式

注意: let 不能进行条件式声明是件好事,因为条件声明是一种反模式,它让程序变得更难理解

for 循环中的 let

在 let 出现之前,for 循环定义的迭代变量会渗透到循环体外部。

常见for循环

如下,用 var 示例:

 for (var i = 0; i < 5; ++i) { 
  // 循环逻辑 
 } 
 console.log(i); // 5 

改成使用 let 就不会有这个问题了,因为 let 迭代变量的作用域仅限于 for 循环块内部:

 for (let i = 0; i &lt; 5; ++i) { 
  // 循环逻辑
 } 
 console.log(i); // ReferenceError: i 没有定义
复制代码

for循环套定时器

在使用 var 的时候,最常见的问题就是对迭代变量的奇特声明和修改,如下:

 for (var i = 0; i < 5; ++i) { 
  setTimeout(() => console.log(i), 0) 
 } 
 // 实际上会输出 5、5、5、5、5 

怎么样,是不是以为会输入 0、1、2、3、4 ?

之所以会这样,是因为在退出循环时,迭代变量保存的是导致循环退出的值:5。在之后执行超时逻辑时,所有的 i 都是同一个变量,因而输出的都是同一个最终值。

而在使用 let 声明迭代变量时,JavaScript 引擎在后台会为每个迭代循环声明一个新的迭代变量

 for (let i = 0; i < 5; ++i) { 
  setTimeout(() => console.log(i), 0) 
 } 
 // 会输出 0、1、2、3、4 

每个 setTimeout 引用的都是不同的变量实例,所以 console.log 输出的是我们期望的值,也就是循环执行过程中每个迭代变量的值。

这种每次迭代声明一个独立变量实例的行为适用于所有风格的 for 循环,包括 for-in 和 for-of循环。

const

const跟 let 的行为差不多,但区别是用它声明变量时必须同时初始化变量,且尝试修改 const 声明的变量会导致运行时错误(一致性)

const 限制

 const age = 26; 
 age = 36; // TypeError
 const name = 'Lisa'; 
 const name = 'Vito'; // SyntaxError
 const name = 'apple'; 
 if (true) { 
  const name = 'avocado'; 
 } 
 console.log(name); // apple 

const 声明的限制只适用于它指向的变量的引用。 换句话说,如果 const 变量引用的是一个对象,那么修改这个对象内部的属性并不违反 const 的限制,如下:

 const person = {}; 
 person.name = 'vito'; // ok 

怎么样,是不是很神奇 o( ̄▽ ̄)d

for 循环中的 const

JavaScript 引擎会为 for 循环中的 let 声明分别创建独立的变量实例,虽然 const 变量跟 let 变量很相似,但是不能用 const 来声明迭代变量(因为迭代变量会自增):

 for (const i = 0; i < 10; ++i) {}  // TypeError 类型错误

不过,如果你只想用 const 声明一个不会被修改的 for 循环变量,那也是可以的。

每次迭代只是创建一个新变量,这对 for-of 和 for-in 循环特别有意义的,如下:

 let i = 0; 
 for (const j = 7; i < 5; ++i) { 
  console.log(j); 
 } 
 // 7, 7, 7, 7, 7 
 ​
 for (const key in {a: 1, b: 2}) { 
  console.log(key); 
 } 
 // a, b 
 ​
 for (const value of [1,2,3,4,5]) { 
  console.log(value); 
 } 
 // 1, 2, 3, 4, 5 

声明风格及最佳实践

ECMAScript 6 增加 let 和 const 为这门语言更精确地声明作用域和语义提供了更好的支持

有了 let 和 const,大多数开发者会发现自己不再需要 var 了。限制自己只使用 let 和 const 有助于提升代码质量,因为变量有了明确的作用域、声明位置,以及不变的值。

使用 const 声明可以让浏览器运行时强制保持变量不变,也可以让静态代码分析工具提前发现不合法的赋值操作。因此,应该优先使用 const 来声明变量,只在提前知道未来会有修改时,再使用 let。

总结

加载全部内容

相关教程
猜你喜欢
用户评论