8000 字读完《JavaScript 语言精粹(修订版)》

8,054 阅读26分钟

iShot2023-01-28 19.15.00.png

脑图点击这里获取

视频版点击此处播放

↑↑↑↑↑↑ 脑图镇楼 ↑↑↑↑↑↑

Hello,各位小伙伴大家好。

今天我们来为大家讲一本书,就是这个《JavaScript 语言精粹修订版》,作者是:道格拉斯·克罗克福德

image.png

我手里的这本是《2017年10月第16次印刷版本》,距离现在已经有 5 年多了。但是这本书依然被奉为《讲解 JavaScript 的一本神书》,特别适合 初级、中级 前端工程师进行阅读。

但是大家要注意,虽然说这本书是 2017年 印刷的,但是书中提到的概念、定义并没有 考虑 ES6 相关的东西,也就是说它是 纯粹的、ES6 之前的 JavaScript 精华的讲解

整本书中所有的内容,我把它分为 4 大块:

  1. 前言部分
  2. 核心部分
  3. 其他部分
  4. 附录部分

在讲解完这四部分之后,我们会分析一下这本书在当下时间段针对国内开发者的优缺点,也就是最后的总结。

好,那么废话不多说,下面我们来看一下本书中的内容:

前言

在前言部分,作者提到了一个非常有意思的事情,那就是《为什么一定要使用 JavaScript》,他说:因为你没得选。

针对于 web浏览器而言,JavaScript 是唯一的编程语言,同时它也是世界上最被轻视的语言之一。

我们知道, JavaScript 是 布蘭登·艾克 花了 10 天的时间开发并且设计完成的,所以它内部必然包含了很多的优秀想法与糟糕的想法。

那么都有什么优秀的方法呢? 作者认为:

  1. 函数
  2. 弱类型
  3. 动态对象
  4. 对象字面量
  5. ...

这些东西,都可以被认为是优秀的想法,也就是 精华

但是同时,内部也有很多糟糕的想法,也就是 糟粕,比如:基于全局变量的编程模型。

所以:JavaScript 是一个反差鲜明的语言,它的糟粕和精华一样显眼

而本书,将主要讲解: JavaScript 的精华部分,至于 糟粕,将会在附录部分进行说明。

核心

那么下面我们就进入到本书的核心精华部分,整个精华部分被分为 6 块,分别是:

  1. 语法
  2. 对象
  3. 函数
  4. 继承
  5. 数组
  6. 方法

那么首先,咱们先来看语法部分。

语法:

整个语法部分涉及到的是整个 JavaScript 的基础语法。

注释

首先针对于注释而言,作者提出 JavaScript 中的注释主要分为两种:

  1. 单行注释
  2. 多行注释

单行注释是 两个 / ,这个在日常开发中是比较常见的。

而针对于多行注释来说,作者主要提供了一种,就是: **双斜杠中间,放入两个 *** ,这种多行注释的形式,作者并 不推荐 使用。

/*
  多行注释内容
*/

但是大家要注意,在咱们现在的日常开发中,多行注释,除了作者提到了这一种之外,其实还有另外一种,那就是:

/**
* 多行注释内容
/

这种注释形式用在 函数上 还是非常指的推荐的。

标识符

接下来是标识符,所谓标识符指的就是:JavaScript 中的保留字。

书中列举出来了一分部,但是除此之外,还有一些其他的保留字大家需要注意。

这些保留字 不可以 被当做 变量名 使用。

数字

针对于很多编程语言来说,都提供了多种的数字类型。比如: java 就提供了 int、long、double、float 等 多种数字类型。

但是针对于 JavaScript 来说,它只有一种数字类型,就是 number,除此之外再无其他。

字符串

而对于 JavaScript 中的字符串类型而言,书中主要从两个方面进行了描述:

  1. 首先是字面量:所谓字面量指的就是 快速创建某种类型的方式。对于字符串来说,它有两种字面量形式: 单引号和双引号。在日常开发中,我们更推荐使用 单引号 的字面量形式。

  2. 第二个叫做特性:这里的特性主要有三个:

    1. 首先第一个叫做 可拼接:多个字符串是可以通过 + 的形式进行拼接的。
    2. 第二个叫做 可 length:咱们可以通过 字符串.length 的形式,获取字符串的长度
    3. 第三个叫做 有方法:JavaScript 中的字符串提供了非常多的方法,这个咱们把它放到 方法 这一大块中再去说就可以。

语句

JavaScript 被称作是一个图灵完备的编程语言。所以它必然要具备 变量声明、逻辑判断 等语句。

JavaScript 中的语句可以写在 <script> 标签 中,每一对花括号中间就可以被叫做一组语句。

书中把 JavaScript 的语句分为 4 大块:

  1. 首先是声明语句:JavaScript 想要声明变量主要有三种形式

    1. 第一种是 var :它是在 ES6 之前唯一的声明变量的方式,现在已经不推荐使用了。
    2. 第二种是 let:在 ES6 之后可以通过它来定义变量
    3. 最后是 const:在 ES6 之后可以通过它来定义常量
  2. 其次是条件语句:JavaScript 中的条件语句主要有两个

    1. 第一个是 if
    2. 第二个是 switch

    这两种条件判断形式,在很多的编程语言中都是存在的。但是 JavaScript 中判断条件有些不太一样的地方。

    JavaScript任何表达式 都可以被作为判断条件,并且 有且仅有 6 个值 在条件判断中会被作为 ,它们分别是: false、null、undefined、空字符串、数字 0 、NaN。除此之外,其他的所有值都会被判断为

  3. 再往后就是循环语句:JavaScript 中循环语句主要有三种

    1. 第一个是 for 循环
    2. 第二个是 while 循环
    3. 第三种是 do...while 循环

    同时,针对于 for 循环来说,又可以被分为: 普通 for 循环 和 forIn 循环

  4. 最后就是强制跳转语句,所谓强制跳转语句指的是: 会强制更改程序执行顺序的语句,这些语句在日常开发中也是被经常使用的:

    1. 比如 break:它会让程序 退出循环 || 退出 switch 语句
    2. continue:会让程序 终止当前循环
    3. 然后是 renturn:它会终止函数的执行
    4. throw:会通过 抛出异常的形式,终止程序执行
    5. try...catch:会通过 捕获异常 的形式,让程序强制跳转到其他的逻辑中

表达式

说完语句之后,下面就是表达式。

作者对表达式进行了明确的定义,指的是: 一组代码的集合,并且返回一个值

JavaScript 中的表达式 5 个,分别为:

  1. 算数表达式
  2. 字符串表达式
  3. 逻辑值表达式
  4. 左值表达式
  5. 基本表达式

字面量(对象)

在前面咱们说到了 JavaScript 中存在字面量的概念。我们可以通过字面量的形式直接定义 字符串

同时,字面量也有很多其他的使用场景,比如:可以使用字面量定义对象或数组,而不需要像其他的语言一样,必须先 new 一下。

函数

整个语法部分,最后一块就是函数,但是在书中针对 语法部分函数 的讲解比较粗糙,所以这一块咱们放到后面单独的函数模块进行说明。

对象

语法部分说完之后,接下来咱们来看下书中 对象 的部分。

对象在 JavaScript 中是一个非常特殊的概念。

定义

JavaScript 中数据类型主要被分为两种:

  1. 简单数据类型:有 number、string、boolean、null、undefined、symbol、bigint
  2. 除了简单数据类型之外,其他的都被叫做 复杂数据类型,有: 数组、函数、正则表达式、对象。 而 JavaScript 中,所有的复杂数据类型,都被统称为 对象

字面量

对象有字面量的创建形式,这个在刚才已经有介绍了,所以这里就不在多复述了。

检索与更新

同时对于对象来说,它可以 获取值(检索) ,也可以 修改值(更新)

JavaScript 中提供了两种检索与更新的形式:

  1. 第一种是通过 . 语法:这种方式最为简单易懂,是大多数情况下推荐使用的方式
  2. 第二种是通过 [] 语法[] 内部可以放一个变量,适用于 根据变量取值的情况

原型

同时 JavaScript 中提供了原型的概念,基于原型还延伸出了原型继承的概念。

而对于对象的原型,咱们放到 继承 这里,再进行详细说明。

反射

然后咱们来看 反射。可以很多小伙伴看到反射这个词的时候,会比较懵。

其实在 JavaScript 里面,没有反射的明确定义。大家就把它作为是 作者的一个称呼即可

反射这一块里面,主要包含了两部分:

  1. 利用 typeof 获取变量的类型
  2. 利用 hasOwnProperty 判断 对象自身属性中是否具有指定的属性,具有则返回 true,否则则是 false

枚举

hasOwnProperty 这个方法在 “枚举” 的时候会非常有用。

和反射一样,JavaScript 中同样没有枚举的明确概念。它一样是作者的一个称呼。

书中的枚举指的主要是: 遍历一个对象并且获取该对象自身的所有属性

遍历可以直接通过 forIn 循环执行,而判断是否为对象自身属性,则需要借助 hasOwnProperty 方法

删除

最后,针对于对象模块,作者还提到了 删除 的概念。

我们可以利用 delete 关键字,直接删除对象中的指定属性。这也是很方便的。

函数

在对象说完之后,下面咱们就进入到了一个 大块 了,那就是函数!

函数 这一章里面,存在很多的 落后性描述的偏差,同时也有很多的 精华

具体是什么,咱们往下看就知道了。

精华

在函数这一章的开篇,作者有一句话我非常喜欢,它描述了整个编程的本质,咱们一起来读一下:所谓编程,就是将一组需求分解成一组函数与数据结构的技能

在这句话中,把函数的作用推到了一个非常重要的位置。

事实也同样如此。

所以书中花费了非常大的章节来介绍函数,大家看脑图也可以看的出来。

那么下面,咱们就进入到函数的内容之中。

函数对象

咱们之前说过,在 JavaScript 中除了基本数据类型之外,其他的都是对象。

所以函数本质上也是一个对象。只不过它拥有一个叫做 “调用” 的属性,可以被调用而已。

函数字面量

而如果想要定义函数,那么可以通过 函数字面量 的形式来进行定义。

所谓的函数字面量,其实就是咱们平时定义函数的方式,一共分为两种:

  1. 命名函数:function f (a, b) { ... }
  2. 匿名函数:const f = function (a, b) { ... }

调用

而在函数调用时,书中一共分为两部分去说:

  1. 首先第一部分是 函数可以调用其他函数:这个只要大家使用过编程语言,那么应该都很好理解。这种方式会 暂停当前函数执行,传递控制权和参数给新的函数

  2. 第二种是 附加参数:在 JavaScript 的函数中,存在两个附加参数:

    1. 第一个是 this:它的值取决于调用的模式。书中把调用模式分成了 4 大类:

      1. 前三大类 方法调用、函数调用、构造器调用this 指向调用方
      2. 最后一大类 apply 调用 中, this 指向 指定值
    2. 第二个 arguments:它表示函数得到的所有实际参数

构造器模式

函数除了可以被直接 调用 之外,还可以被当做 构造器使用,也就是所谓的 构造器模式。

关于 构造器模式,书中主要明确了四个方面,分别是:

  1. JavaScript 是一门基于原型继承的语言,这就意味着 对象可以直接从其他对象中继承属性。 关于继承的话题,咱们在后面单独说
  2. 第二个是: 构造器本身就是函数
  3. 第三就是: 构造器不通过小括号的形式直接调用,而是要 配合 new 关键字 使用
  4. 最后就是:根据 约定,构造器它的 首字母要大写

这四块是非常重要的,哪怕是在当下时间段依然是行之有效的。

apply 调用模式

在前面,咱们提到了 apply 调用模式,咱们知道所谓的 apply 调用模式 实际上是分为三个方法的,分别是:

  1. apply
  2. call
  3. bind

这三个方法的核心作用,就是 改变 this 指向

参数

参数 这个小节里面,同样书中主要提到的就是 arguments,这个咱们在前面也说过了,它主要是获取 所有实际参数 的。

返回值

再往后,书中对 函数的返回值 进行了一些说明。

大家需要知道的,主要是有三点:

  1. 首先第一点: 函数必然存在返回值。如果你什么都不返回,那么函数默认返回 undefined
  2. 然后: 可以通过 renturn 让函数提前返回指定的值,并且中止执行
  3. 第三:函数也可以配合 new 使用,这样会返回 this

看到这大家有没有发现,书中讲过的很多东西,咱们在日常开发中大部分都是知道的。

但是书中把开发的一些 “经验” ,变成了一套具体的 1、2、3 。

我在看的过程中,有时候确实会有一种: “哦~ 原来如此” 或者是 “嗯,确实是这样” 的一种感觉

异常

那么下面咱们继续来往下看

书中专门在函数中,对异常进行了一个说明。

但是说明的重点依然是 throw 语句,抛出异常。在抛出异常的,它可以终止函数的执行。

扩充类型的功能

作者把基于原型继承称为: 扩充类型的功能

但是本质上还是 原型继承,这个咱们依然还是在 继承 模块中去说就可以。

递归

递归是函数调用非常常见并且复杂的场景。

书中也对 递归 进行了详细说明,说明的方式是通过两部分:

  1. 第一个就是什么叫递归,所谓递归指的就是: 直接或间接调用自身的函数
  2. 接下来是递归的场景: 递归把一个复杂问题分解为一组相似的子问题,每一个都用一个寻常解去解决,这是典型的美式语言。同时作者还通过一个 汉诺塔游戏 的案例,进行了举例说明

作用域

接下来作者提到了作用域的概念。

但是这一块,明显具备非常大的局限性,因为作者的很多观念完全是基于 ES6 之前的逻辑去说的。

比如,作者提到: JavaScript 中不存在块级作用域。

这个在当前场景下明显是不对的。

所以我看的这本书,虽然是 2017 年 印刷的,但是内容感觉更加偏老一些。

闭包

接下来是闭包的逻辑。

这里作者对闭包进行了定义: 内部函数可以访问定义他们的外部函数的参数和变量 ,这样的函数就是闭包。

我针对于这句话加上我个人的理解,也总结了一句: 可以访问其它函数作用域中变量的函数 ,就是闭包。

大家可以看看哪个好理解,就理解哪一句就可以。

这里我列举了一段代码:

function a () {
  const name = '张三'
  return function b () {
    return name
  }
}
​
console.log(a()()) // 张三

在这段代码中, b函数 就是闭包函数

回调

在往下是 回调 的概念。

这里其实主要就是说明了一点: 函数可以作为参数进行回调使用

模块

结合 闭包回调 ,作者提到了 模块 这样的概念。

使用函数和闭包 时,可以构造一个模块。

那么什么是模块呢? 作者同样给出了定义: 模块是一个提供接口却隐藏状态与实现的函数或对象

只看概念,非常难以理解,咱们通过这个代码来去看:

let name = '张三' // 此时 name 为全局变量,可以被任意修改
function a () {
  // 此时 name 为函数作用域变量
  // 通过 const b = a() 得到 b 函数,然后进行调用
  // name 不可以被外界修改
  let name = '张三' 
  return function b () {
    return name
  }
}

通过这种模块的方式,来缓解 基于全局变量的编程模式 所带来的问题。

级联

所谓 级联,是作者的称呼。

咱们更喜欢把它叫做 链式调用,明确了概念大家应该就知道是什么了。

柯里化

作者专门讲解了 柯里化,他对柯里化是这样定义的,他说: 把函数与传递给它的参数相结合,产生一个新的函数。 这叫做柯里化。

这个定义和咱们的平常认知不同,在咱们的认知中,柯里化指的应该是: 柯里化是一种函数的转换,它是指将一个函数从可调用的 f(a, b, c) 转换为可调用的 f(a)(b)(c)

因为这本书原本是英文的,咱们拿到的都是 转译之后的译本,所以关于一些定义,大家客观看待就可以了。

记忆

整个函数最后一块,提到了一个 记忆 的词汇。

这个在咱们日常开发中不会这里称呼,这里的记忆指的其实就是: 把函数的操作结果,保存到一个对象中,从而避免重复运算

书中也拒了一些例子,但是本质上应该是一个类似算法的概念。

总结

那么到这里,关于函数这一章咱们就说完了。

从函数这一章中,其实咱们就可以明确的感受出来: 书中的内容具备一定的落后性(比如:块级作用域)译文导致的一些描述的偏差(比如:柯里化) ,但是 其中也有很多的精华(比如:返回值、递归、闭包)

所以这本书,咱们再去看的时候,一定要客观分析一下才可以。

继承

那么下面咱们来看 继承 这个章节

这个章节的内容不算特别多,至少相比于 函数 是这样的。

书中并没有详细的讲解 JavaScript 中所有继承的方式,以及代码。

更多的还是从理念的层次来去说的。同时 依然包含很多落后性

精华

首先本章一开始先明确了 JavaScript 的继承方式: JavaScript 是弱类型的语言,提供了多种继承的模式,而非传统的类继承

伪类

然后作者提到了 伪类 这样的一个词汇

这个伪类,说白了就是 构造函数,也就是: 首字母大写的普通函数

对象说明符

这里作者又提到了一个新的词汇:对象说明符。

并且列举出来了一个场景: 当一个函数接收多个参数时,记住参数的顺序非常困难

比如:

maker(f, l, m, c, s)

所以,与其这么写,倒不如这样写:

maker({
  first: f,
  middle: m,
  last: l,
  state, s,
  city: c
})

简单来说,也就是: 把多个参数,合并成一个用对象表示的参数

作者把这样的一种方式叫做: 对象说明符

原型

原型是继承中非常重要的概念。

但是因为书中的字数限制,作者并没有对原型展开了详细说,而只是明确了两点:

  1. 首先第一点是基于原型继承的概念: 一个新对象可以继承一个旧对象的属性

  2. 第二个是差异化继承:继承本质上需要具备差异,通过一个小的 demo 进行了明确

    const person = {
      name: '张三',
      age: 18
    }
    const newPerson = Object.create(person)
    newPerson.name = '李四'
    

    这样,就完成了一个简单的差异化继承。

函数化

在讲完了原型之后,作者提到了一个 函数化 的概念。

作者提出: 原型的继承模式会导致没有私有变量

如果大家使用过 ts 或者其他的 强类型编程语言(比如:java) 那么可以就知道所谓私有变量是什么意思了。

同时作者也通过一段代码来描述了 如何在原型继承的模式下具备私有变量

这段代码比较复杂,也有点难以理解。但是在当下的场景中,因为 ES6 之后提出了 class 的概念,所以现在咱们其实是有了更简单的方式定义私有变量的。

所以这段代码的意义就不大了。

部件

整个继承最后一块就是 部件

所谓部件指的就是: 对象(这里是函数)的属性或方法

每一个属性或方法都可以被称作是一个部件。

总结

整个继承的章节,内容并不多。

书中也没有大书特书的写关于原型继承的代码。

所以整个继承章节看下来,不会很累,概念性的东西居多。

数组

继承讲解完成之后,新的一个章节叫做 数组

定义

这里作者对于数组的定义比较有意思,他拿传统数组和 JavaScript 数组 进行了对比:

  1. 针对于传统数组来说:数组是一段线性分配的内存,它通过整数计算偏移并访问其中的元素

  2. 但是 JavaScript 中的数组不同:

    1. 首先: JavaScript 中并不存在数组一样的数据结构
    2. JavaScript 只不过是提供了 类数组特性的对象

    咱们之前说过 js 中除了基本数据类型,其他的都是对象,这里就能够呼应上了。

数组字面量

这个比较简单,就是通过 [] 定义数组

长度

想要获取数组长度,通过 .length 属性获取

删除

想要删除数组的元素,书中提到了两种方式:

  1. 因为数组本质上是对象,所以依然可以使用 delete 关键字删除。但是这种删除方式,会导致原来的位置留下 “空洞”
  2. 而第二种方式,是咱们比较常用的,那就是通过 splice 进行删除

枚举

所谓的枚举,其实指的就是咱们常说的 遍历

而数组的遍历常用的方式主要是两种:

  1. forIn 循环,但是这样无法保证顺序
  2. 第二种是 普通的 for 循环,这也是咱们常用的方式

其实除了这两种方式之外,大家应该还能想到别的,比如: forEach 方法。

容易混淆的地方

书中专门花了一个小节来去定义 数组与对象 容易混淆的地方。

其中核心就是当使用 typeof 的时候,typeof 无法区分出 对象和数组。

所以作者给出了一个方式来进行区分:

function is_array (value) {
  return Object.prototype.toString.apply(value) === '[object Array]'
}

这种方式放到现在依然可用。

除此之外,其实还有另外一种比较常用的方式,作者没有提到,那就是 instanceof

方法

数组中提供了一些被继承的方法,这些方法,咱们放到 方法 这一章去说就可以了。

指定初始值

书中关于数组的最后一个小节讲解了 数组初始值 相关的一些东西,主要是有两点:

  1. 第一点就是: 数组没有预设值。通过 [] 定义数组后,会是一个空数组(本来难道不应该是这样吗?)
  2. 第二点就是:JavaScript 中本质上没有多维数组的概念,所谓的多维数组不过是 以数组为元素 产生的

总结

整个数组的环节,内容还是比较简单的。

相当于把 JavaScript 中数组的一些核心特性进行了讲解。

方法

再往后就是书中核心部分的最后一块了,也就是 方法

书中对于方法的讲解主要是通过两部分:

  1. 第一部分是对方法进行了定义,所谓方法指的是:当一个函数被保存为对象的一个属性时,那么这个函数就被叫做是方法。

  2. 第二部分类似于一个 API 文档。详细的介绍了:

    1. Array
    2. Function
    3. Object
    4. Srting

    这四大类的一些原型继承方法。

这些方法,在 MDN 文档中都可以直接查看,咱们这里就不去详细说了。

核心部分总结

核心部分讲解完成之后,其实书中绝大部分 精华 咱们就已经全部梳理完成了。

其他

除了大部分的精华之外,书中还提到了一些 其他 的东西,比如:

  1. 正则表达式
  2. 代码风格
  3. 优美的特性

咱们一个一个去说。

正则表达式

首先针对于正则表达式来说。

因为本书并不是一个专门讲解正则表达式的书籍,所以书中关于正则的内容并不多。很多地方也并不详细。

所以我并不是很推荐大家去看本书中关于正则的部分。

如果大家想要了解正则,倒不如到 MDN 文档 中进行查看。

代码风格和优美的特性

针对于 代码风格和优美的特性 这两块,因为 作者对 JavaScript 语法规范的理解,但并不完全适合于国内环境,所以这两部分对于咱们的参考意义也不是很大。

但是这里有一句话写的很好,我摘抄了下来,咱们可以一起看一下

我们喜欢简单,追求简洁易用,但是当产品缺乏这种特性时,就需要自己去创造它。

附录

最后就是整本书的 附录 部分。

这部分主要是分成了 5 块。

其中前两块:

  1. 毒瘤
  2. 糟粕

比较有意思,咱们可以一起来看一下。

至于后三块:

  1. JSLint
  2. 语法图
  3. JSON

不在咱们本次的探讨范围之内。

毒瘤

作者把 JavaScript 中非常差劲的特性叫做 毒瘤。意思是: 不除不快

这里面涉及到的语法非常的多,咱们简单过一下即可:

  1. 全局变量:中大型项目中,全局变量可以被任意修改,会使得程序的行为变得极度复杂
  2. 作用域:无块级作用域
  3. 自动插入分号:不合时宜的自动插入
  4. 保留字:大量的保留字不可以被用作变量名
  5. unicodeunicode 把一对字符视为一个单一的字符,而JavaScript认为一对字符是两个不同的字符
  6. typeoftypeof 的返回总是很 “奇怪”
  7. parseInt:遇到非数字时会停止解析,而不是抛出一个错误
  8. +:既可以让数字相加,也可以链接字符串
  9. 浮点数:二进制的浮点数不能正确的处理十进制的小数
  10. NaNNaN 表示不是一个数字,同时它的一些运算也会让人感到奇怪
  11. 伪数组:JavaScript 中没有真正的数组,却又存在伪数组的概念
  12. 假值:0、NaN、''、false、null、undefined 在逻辑判断中都会被认为假
  13. hasOwnPropertyhasOwnProperty 是一个方法而不是运算符,所以在任何对象中,他可以被替换掉
  14. 对象:JavaScript 中的对象永远不会是真的空对象,因为它们可以从原型链中取得成员属性

糟粕

作者把一些不符合规范,但是可以使用的代码,叫做 糟粕

主要有:

  1. ==:不判断类型,所以尽量不要使用它
  2. with:改变一段语句的作用域链
  3. eval:传递字符串给 JavaScript 编译器,会使得代码更加难以阅读
  4. continue:作者发现移除 continue 之后,性能会得到改善
  5. switch 穿越:必须明确中断 case,否则会穿越到下一个
  6. 缺少块的语句
  7. ++ --:这两个运算符鼓励了一种不够谨慎的编程风格
  8. 位运算符:JavaScript 执行环境一般不接触硬件,所以执行非常慢
  9. function 语句对比 function 表达式:多种定义方式让人困惑
  10. 类型的包装对象:你应该从来没有使用过 new Boolean(false)。所以作者认为:这是完全没有必要,并且令人困惑的语法

总结

OK,那么到这里整本书中所有的内容,咱们就已经全部讲解完了。

针对于《JavaScript 语言精粹修订版》来说,它的优点是非常明确的:

  1. 体量小
  2. 初、中级工程师可以通过它快速理清 JavaScript 语言精粹

但是它的缺点也是非常突出:

  1. 内容偏老,针对 ES6 之前的语法
  2. 内容多为直译,导致有时候一定定义和词汇可能会让人很困惑
  3. 书中包含大量的作者主观表述,可能并不一定那么精准,大家需要客观看待。(比如: vue 中就大量的使用到了“糟粕”