Javascript基础之-var,let和const深入解析(一)
作者:小辞 标签:Javascript

es6有许多特别棒的特性,你可能对该语言的整体非常熟悉,但是你知道它在内部是如何工作的吗?当我们知道它的内部原理以后,我们使用起来也会更加的安心一些。这里我们想逐步的引导你,让你对其有一个更深入,更浅显的认识。让我们就先从es6中的变量开始讲起吧。

 

let和const

 

在es6中新引入了两种方式来申明变量,我们仍然可以使用广为传诵的var变量(然而你不应该继续使用它了,继续阅读来了解其中原因),但是现在我们有了两种更牛的工具去使用:let和const。

 

let

 

let和var非常的相似,在使用方面,你可以使用完全相同的方式来声明变量,例如:

let myNewVariable = 2;
var myOldVariable = 3;

console.log(myNewVariable); // 2
console.log(myOldVariable); // 3

 

但是实际上,他们之间有几处明显的不同。他们不仅仅是关键字变了,而且实际上它还让会简化我们的一些工作,防止一些奇怪的bug,其中这些不同点是:

  1. let是块状作用域(我将会在文章后面着重讲一下作用域相关的东西),而var是函数作用域。

  2. let不能在定义之前访问该变量(var是可以的,它确实是js世界中许多bug和困扰的源头)。

  3. let不能被重新定义。

 

在我们讲解这些不同点之前,首先我们看一个更酷的变量:const

 

const

 

const和let非常像(跟var相比来说,他们之间有许多相同点),但是他们有一个主要的不同点:let可以重新赋值,但是const不能。因此const定义的变量只能有一个值,并且这个值在声明的时候就会被赋值。因此我们来看下下面的例子。

const myConstVariable = 2;
let myLetVariable = 3;

console.log(myConstVariable); // 2
myLetVariable = 4; // ok
myConstVariable = 5; //wrong - TypeError thrown

 

但是const是完全不可变的吗?

 

有一个常见的问题:虽然变量不能被重新赋值,但是也不能让他们真正的变为不可变的状态。如果const变量有一个数组或者对象作为其值的话,你可能会像下面的代码一样改变它的值。

const myConstObject = {mutableProperty: 2};

// myConstObject = {}; - TypeError
myConstObject.mutableProperty = 3; //ok
console.log(myConstObject.mutableProperty); // 3
const myConstArray = [1];

// myConstArray = []; - TypeError
myConstArray.push(2) //ok
console.log(myConstArray); // [1, 2]

当然你不能用原始数据类型的值,比如string,number,boolean等,因为他们本质上是不可变的。

 

真正的不可变

如果你想让我们的变量真正的不可变的话,可以使用Object.freeze(), 它可以让你的对象保持不可变。不幸的是,他仅仅是浅不可变,如果你对象里嵌套着对象的话,它依然是可变的。

const myConstNestedObject = {
immutableObject: {
mutableProperty: 1
 }
};

Object.freeze(myConstNestedObject);

myConstNestedObject.immutableObject = 10; // won't change
console.log(myConstNestedObject.immutableObject); // {mutableProperty: 1}
myConstNestedObject.immutableObject.mutableProperty = 10; // ok
console.log(myConstNestedObject.immutableObject.mutableProperty); // 10

 

变量的作用域

 

在介绍了一些基础知识以后,下面我们要进入一个更高级的话题。现在我们要开始讲解es5和es6变量中的第一个不同-作用域

注意:下面的例子都用的是let,它的规则在const上同样也适用

 

全局变量和函数作用域变量

 

在js中,究竟什么是作用域呢?本文不会给出一个关于作用域的完整解释。简单来说,变量的作用域决定了变量的可用位置。从不同的角度来看,可以说作用域是你可以在特定区域内使用的那些变量(或者是函数)的声明。作用域可以是全局的(因此在全局作用域中定义的变量可以在你代码中任何部分访问)或者是局部的。

很显然,局部作用域只能在内部访问。在ES6以前,它仅仅允许一种方式来定义局部作用域 - function,咱们来看一下下面的例子:

 

// global scope
var globalVariable = 10;

function functionWithVariable() {
// local scope
 var localVariable = 5;
console.log(globalVariable); // 10
 console.log(localVariable); // 5
}

functionWithVariable();

//global scope again
console.log(globalVariable); // 10
console.log(localVariable); // undefined

 

上面的例子中,变量globalVariable是全局变量,所以它可以在我们代码中的函数内或者是其他区域内被访问到,但是变量localVariable定义在函数内,所以它只在函数内可访问。

 

因此,所有在函数内创建的内容都可以在函数内被访问到,包括函数内部里所有的嵌套函数(可能会被嵌套多层)。在这里可能要感谢闭包了,但是在文章里我们并不打算介绍它。不过请继续关注,因为我们在未来的博文中,会更多的介绍它。

 

提升

 

简单来说,提升是一种吧所有的变量和函数声明“移动”到作用域的最前面的机制。让我们看一下下面的例子。

 

function func() {
console.log(localVariable); // undefined
 var localVariable = 5;

console.log(localVariable); // 5
}

func();

 

它为什么依然会正常工作呢?我们还没有定义这个变量,但是它依然通过console.log()打印出了undefined。为什么不会报出一个变量未定义的错误呢?让我们再仔细看一下。

 

编译变量

 

Javascript解析器要遍历这个代码两次。第一次被称为编译状态,这一次的话,代码中定义的变量就会提升。在他之后,我们的代码就变成类似于下面的这样子的(我已经做了一些简化,只展示出相关的部分)。

 

function func() {
var localVariable = undefined;

console.log(localVariable); // undefined
 localVariable = 5;

console.log(localVariable); // 5
}

func();

 

我们看到的结果是,我们的变量localVariable已经被移动到func函数的作用域的最前面。严格来说,我们变量的声明已经被移动了位置,而不是声明的相关代码被移动了位置。我们使用这个变量并打印出来。它是undefined是因为我们还没有定义它的值,它默认使用的undefined。

 

提升的例子 - 会出什么问题

 

来让我们看一个令人讨厌的例子,我们的作用域范围对于我们来说,是弊大于利的。也不是说函数作用域是不好的。而是说我们必须要警惕一些由于提升而引起的一些陷进。我们来看看下面的代码:

 

var callbacks = [];
for (var i = 0; i < 4; i++) {
callbacks.push(() => console.log(i));
}

callbacks[0]();
callbacks[1]();
callbacks[2]();
callbacks[3]();

 

你认为输出的值是多少呢?你猜可能是0 1 2 3,是吗?如果是的话,对于你来说,可能会有一些惊喜。实际上,他真实的结果是4 4 4 4。等等,它到底发生了什么?我们来“编译”一下代码,代码现在看起来就像这样:

 

var callbacks;
var i;

callbacks = [];
for (i = 0; i < 4; i++) {
callbacks.push(() => console.log(i));
}

callbacks[0]();
callbacks[1]();
callbacks[2]();
callbacks[3]();

 

你看出问题所在了吗?变量i在整个作用域下都是可以被访问到的,它不会被重新定义。它的值只会在每次的迭代中不断地被改变。然后呢,当我们随后想通过函数调用打印它的值得时候,他实际上只有一个值 - 就是在最后一次循环赋给的那个值。

 

我们只能这样了吗?不是的

 

Let和Const的拯救

 

除了定义变量的新方式以外,还引入了一种新的作用域:块级作用域。块就是由花括号括起来的所有的内容。所以它可以是if,while或者是for声明中的花括号,也可以是单独的一个花括号甚至是一个函数(对,函数作用域是块状作用域)。let和const是块作用域。意味着无论你在块中无论定义了什么变量,什么时候定义的,它都不会跑到块作用域外面去。我们来看一下下面的例子:

 

function func() {
// function scope
 let localVariable = 5;
var oldLocalVariable = 5;

if (true) {
// block scope
   let nestedLocalVariable = 6;
var oldNestedLocalVariable = 6;

console.log(nestedLocalVariable); // 6
   console.log(oldNestedLocalVariable); // 6
 }

// those are stil valid
 console.log(localVariable); // 5
 console.log(oldLocalVariable); // 5
 // and this one as well
 console.log(oldNestedLocalVariable); // 6
 // but this on isn't
 console.log(nestedLocalVariable); // ReferenceError: nestedLocalVariable is not defined

 

你能看出来差别吗?你能看出来怎么使用let来解决早些时候提出问题的吗?我们的for循环包含一组花括号,所以它是块作用域。所以如果在定义循环变量的时候,使用的是let或者是const来代替var的话,代码会转为下面的形式。注意:我实际上已经简化了很多,不过我确定你能理解我的意思。

 

let callbacks = [];
for (; i < 4; i++) {
let i = 0 //, 1, 2, 3
 callbacks.push(() => console.log(i));
}

callbacks[0]();
callbacks[1]();
callbacks[2]();
callbacks[3]();

 

现在的每一次循环都有它自己的变量定义,所以变量不会被重写,我们确信这行代码可以完成让他做的任何事情。

 

这是这一部分结束的例子,但是我们再看一下下面的例子,我相信你明白打印出来的值的原因,以及对应的表现是什么。

 

function func() {
var functionScopedVariable = 10;
let blockScopedVariable = 10;

console.log(functionScopedVariable); // 10
 console.log(blockScopedVariable); // 10
 if (true) {
var functionScopedVariable = 5;
let blockScopedVariable = 5;

console.log(functionScopedVariable); // 5
   console.log(blockScopedVariable); // 5
 }

console.log(functionScopedVariable); // 5
 console.log(blockScopedVariable); // 10
}

func();

 

觉得不错的话,可以关注微信公众号:干货技术,每周都有一篇前端相关原创干货小文章分享

 

本文翻译自:https://blog.pragmatists.com/let-your-javascript-variables-be-constant-1633e56a948d