JavaScript，被嘲为“玩具语言”

 Javascript 堪称世界上被人误解最深的编程语言。虽然常被嘲为“玩具语言”，但在它看似简洁的外衣下，还隐藏着强大的语言特性。 Javascript 目前广泛应用于众多知名应用中，对于网页和移动开发者来说，深入理解 Javascript 就尤为必要。

先从这门语言的历史谈起是有必要的。在1995 年 Netscape 一位名为 Brendan Eich 的工程师创造了 Javascript，随后在 1996 年初，Javascript 首先被应用于 Netscape 2 浏览器上。最初的 Javascript 名为 LiveScript，后来，因为 Sun Microsystem 的 Java 语言兴起，被广泛使用，Netscape 出于宣传和推广的考虑，将它的名字从最初的 LiveScript 更改为 Javascript——尽管两者之间并没有什么共同点。这便是之后混淆产生的根源。

几个月后，Microsoft 随 IE 3 发布推出了一个与之基本兼容的语言 JScript。又过了几个月，Netscape 将 Javascript 提交至 Ecma International（一个欧洲标准化组织）， ECMAScript 标准第一版便在 1997 年诞生了，随后在 1999 年以 ECMAScript 第三版的形式进行了更新，从那之后这个标准没有发生过大的改动。由于委员会在语言特性的讨论上发生分歧，ECMAScript 第四版尚未推出便被废除，但随后于 2009 年 12 月发布的 ECMAScript 第五版引入了第四版草案加入的许多特性。第六版标准已经于 2015 年 6 月发布。

注意： 为熟悉起见，从这里开始，我们将使用 “Javascript” 代替 ECMAScript 。

与大多数编程语言不同，Javascript 没有输入或输出的概念。它是一个在主机环境（host environment）下运行的脚本语言，任何与外界沟通的机制都是由主机环境提供的。浏览器是最常见的主机环境，但在非常多的其他程序中也包含 Javascript 解释器，如 Adobe Acrobat、Adobe Photoshop、SVG 图像、Yahoo! 的 Widget 引擎，Node.js 之类的服务器端环境，NoSQL 数据库（如开源的 Apache CouchDB）、嵌入式计算机，以及包括 GNOME （注：GNU/Linux 上最流行的 GUI 之一）在内的桌面环境等等。

概览

Javascript 是一种多范式的动态语言，它包含类型、运算符、标准内置（ built-in）对象和方法。它的语法来源于 Java 和 C，所以这两种语言的许多语法特性同样适用于 Javascript。Javascript 通过原型链而不是类来支持面向对象编程（有关 ES6 类的内容参考这里Classes，有关对象原型参考见此继承与原型链）。Javascript同样支持函数式编程——因为它们也是对象，函数也可以被保存在变量中，并且像其他对象一样被传递。

先从任何编程语言都不可缺少的组成部分——“类型”开始。Javascript 程序可以修改值（value），这些值都有各自的类型。Javascript 中的类型包括：

• Number（数字）


• String（字符串）


• Boolean（布尔）


• Function（函数）


• Object（对象）


• Symbol（ES2015 新增）

…哦，还有看上去有些…奇怪的 RegExp（正则表达式），这三种类型都是特殊的对象。严格意义上说，Function（函数）也是一种特殊的对象。所以准确来说，Javascript 中的类型应该包括这些：

• Number（数字）


• String（字符串）


• Boolean（布尔）


• Symbol（符号）（ES2015 新增）


• Object（对象）
  
  
  
  • Function（函数）
  
  
  • Array（数组）
  
  
  • Date（日期）
  
  
  • RegExp（正则表达式）
  
  
  
  


• null（空）


• undefined（未定义）

Javascript 还有一种内置的 但是，如果我们继续使用上面的分类，事情便容易得多；所以，现在，我们先讨论上面这些类型。

数字

根据语言规范，Javascript 采用“遵循 IEEE 754 标准的双精度 64 位格式”（"double-precision 64-bit format IEEE 754 values"）表示数字。据此我们能得到一个有趣的结论，和其他编程语言（如 C 和 Java）不同，Javascript 不区分整数值和浮点数值，所有数字在 Javascript 中均用浮点数值表示，所以在进行数字运算的时候要特别注意。看看下面的例子：

Math（数学对象），用以处理更多的高级数学函数和常数：

parseInt() 将字符串转换为整型。该函数的第二个可选参数表示字符串所表示数字的基（进制）：

parseInt()函数会把这样的字符串视作八进制数字；同理，0x开头的字符串则视为十六进制数字。

如果想把一个二进制数字字符串转换成整数值，只要把第二个参数设置为 2 就可以了：

parseInt()不同的地方是，parseFloat() 只应用于解析十进制数字。

单元运算符 + 也可以把数字字符串转换成数值：

NaN（Not a Number 的缩写）：

isNaN() 来判断一个变量是否为 NaN：

Infinity（正无穷）和 -Infinity（负无穷）：

isFinite() 来判断一个变量是否是一个有穷数， 如果类型为Infinity, -Infinity 或 NaN则返回false：

parseInt() 和 parseFloat() 函数会尝试逐个解析字符串中的字符，直到遇上一个无法被解析成数字的字符，然后返回该字符前所有数字字符组成的数字。然而如果使用运算符 "+"， 只要字符串中含有无法被解析成数字的字符，该字符串都将被转换成 NaN。可分别使用这两种方法解析“10.2abc”这一字符串，并比较得到的结果，来理解这两种方法的区别。

字符串

Javascript 中的字符串是一串Unicode 字符序列。这对于那些需要和多语种网页打交道的开发者来说是个好消息。更准确地说，它们是一串UTF-16编码单元的序列，每一个编码单元由一个 16 位二进制数表示。每一个Unicode字符由一个或两个编码单元来表示。

如果想表示一个单独的字符，只需使用长度为 1 的字符串。

通过访问字符串的 length（编码单元的个数）属性，可以得到它的长度。

undefined 是一个“undefined（未定义）”类型的对象，表示一个未初始化的值，也就是还没有被分配的值。我们之后再具体讨论变量，但有一点可以先简单说明一下，Javascript 允许声明变量但不对其赋值，一个未被赋值的变量就是 undefined 类型。还有一点需要说明的是，undefined 实际上是一个不允许修改的常量。

Javascript 包含布尔类型，这个类型的变量有两个可能的值，分别是 true 和 false（两者都是关键字）。根据具体需要，Javascript 按照如下规则将变量转换成布尔类型：

1. false、0、空字符串（""）、NaN、null 和 undefined 被转换为 false


2. 所有其他值被转换为 true

也可以使用 Boolean() 函数进行显式转换：

var：

let 语句声明一个块级作用域的本地变量，并且可选的将其初始化为一个值。

const 允许声明一个不可变的常量。这个常量在定义域内总是可见的。

var 是最常见的声明变量的关键字。它没有其他两个关键字的种种限制。这是因为它是传统上在 Javascript 声明变量的唯一方法。使用 var 声明的变量在它所声明的整个函数都是可见的。

var 声明变量的语句块的例子：

+ 操作符还可以用来连接字符串：

for...of

for...in ：

&& 和 || 运算符使用短路逻辑（short-circuit logic），是否会执行第二个语句（操作数）取决于第一个操作数的结果。在需要访问某个对象的属性时，使用这个特性可以事先检测该对象是否为空：

default 语句是可选的。switch 和 case 都可以使用需要运算才能得到结果的表达式；在 switch 的表达式和 case 的表达式是使用 === 严格相等运算符进行比较的：

You。

for...of 循环，可以用它来遍历可迭代对象，例如数组：

for...in 循环， 然而这并不是遍历数组元素而是数组的索引。注意，如果哪个家伙直接向 Array.prototype 添加了新的属性，使用这样的循环这些属性也同样会被遍历。所以并不推荐使用这种方法遍历数组：

a.toString()
返回一个包含数组中所有元素的字符串，每个元素通过逗号分隔。


a.toLocaleString()
根据宿主环境的区域设置，返回一个包含数组中所有元素的字符串，每个元素通过逗号分隔。


a.concat(item1[, item2[, ...[, itemN]]])
返回一个数组，这个数组包含原先 a 和 item1、item2、……、itemN 中的所有元素。


a.join(sep)
返回一个包含数组中所有元素的字符串，每个元素通过指定的 sep 分隔。


a.pop()
删除并返回数组中的最后一个元素。


a.push(item1, ..., itemN)
将 item1、item2、……、itemN 追加至数组 a。


a.reverse()
数组逆序（会更改原数组 a）。


a.shift()
删除并返回数组中第一个元素。


a.slice(start, end)
返回子数组，以 a[start] 开头，以 a[end] 前一个元素结尾。


a.sort([cmpfn])

依据可选的比较函数 cmpfn 进行排序，如果未指定比较函数，则按字符顺序比较（即使被比较元素是数字）。

从 start 开始，删除 delcount 个元素，然后插入所有的 item。

将 item 插入数组头部，返回数组新长度（考虑 undefined）。

函数

学习 Javascript 最重要的就是要理解对象和函数两个部分。最简单的函数就像下面这个这么简单：

arguments 的内部对象，这个对象就如同一个类似于数组的对象一样，包括了所有被传入的参数。让我们重写一下上面的函数，使它可以接收任意个数的参数：

this。当使用在函数中时，this 指代当前的对象，也就是调用了函数的对象。如果在一个对象上使用点或者方括号来访问属性或方法，这个对象就成了 this。如果并没有使用“点”运算符调用某个对象，那么 this 将指向全局对象（global object）。这是一个经常出错的地方。例如：

new，它和 this 密切相关。它的作用是创建一个崭新的空对象，然后使用指向那个对象的 this 调用特定的函数。注意，含有 this 的特定函数不会返回任何值，只会修改 this 对象本身。new 关键字将生成的 this 对象返回给调用方，而被 new 调用的函数称为构造函数。习惯的做法是将这些函数的首字母大写，这样用 new 调用他们的时候就容易识别了。

不过，这个改进的函数还是和上一个例子一样，在单独调用fullName() 时，会产生相同的问题。

我们的 Person 对象现在已经相当完善了，但还有一些不太好的地方。每次我们创建一个 Person 对象的时候，我们都在其中创建了两个新的函数对象——如果这个代码可以共享不是更好吗？

Person.prototype 是一个可以被Person的所有实例共享的对象。它是一个名叫原型链（prototype chain）的查询链的一部分：当你试图访问一个 Person 没有定义的属性时，解释器会首先检查这个 Person.prototype 来判断是否存在这样一个属性。所以，任何分配给 Person.prototype 的东西对通过 this 对象构造的实例都是可用的。

这个特性功能十分强大，Javascript 允许你在程序中的任何时候修改原型（prototype）中的一些东西，也就是说你可以在运行时(runtime)给已存在的对象添加额外的方法：

apply() 有一个姐妹函数，名叫 call，它也可以允许你设置 this，但它带有一个扩展的参数列表而不是一个数组。

makeAdder 这个名字本身，便应该能说明函数是用来做什么的：它会用一个参数来创建一个新的“adder”函数，再用另一个参数来调用被创建的函数时，makeAdder 会将一前一后两个参数相加。

从被创建的函数的视角来看的话，这两个参数的来源问题会更显而易见：新函数自带一个参数——在新函数被创建时，便钦定、钦点了前一个参数（如上方代码中的 a、5 和 20，参考 makeAdder 的结构，它应当位于新函数外部）；新函数被调用时，又接收了后一个参数（如上方代码中的 b、6 和 7，位于新函数内部）。最终，新函数被调用的时候，前一个参数便会和由外层函数传入的后一个参数相加。

这里发生的事情和前面介绍过的内嵌函数十分相似：一个函数被定义在了另外一个函数的内部，内部函数可以访问外部函数的变量。唯一的不同是，外部函数已经返回了，那么常识告诉我们局部变量“应该”不再存在。但是它们却仍然存在——否则 adder 函数将不能工作。也就是说，这里存在 makeAdder 的局部变量的两个不同的“副本”——一个是 a 等于 5，另一个是 a 等于 20。那些函数的运行结果就如下所示：

x(6); // 返回 11
y(7); // 返回 27

下面来说说，到底发生了什么了不得的事情。每当 Javascript 执行一个函数时，都会创建一个作用域对象（scope object），用来保存在这个函数中创建的局部变量。它使用一切被传入函数的变量进行初始化（初始化后，它包含一切被传入函数的变量）。这与那些保存的所有全局变量和函数的全局对象（global object）相类似，但仍有一些很重要的区别：第一，每次函数被执行的时候，就会创建一个新的，特定的作用域对象；第二，与全局对象（如浏览器的 window 对象）不同的是，你不能从 Javascript 代码中直接访问作用域对象，也没有 可以遍历当前作用域对象中的属性 的方法。

所以，当调用 makeAdder 时，解释器创建了一个作用域对象，它带有一个属性：a，这个属性被当作参数传入 makeAdder 函数。然后 makeAdder 返回一个新创建的函数（暂记为 adder）。通常，Javascript 的垃圾回收器会在这时回收 makeAdder 创建的作用域对象（暂记为 b），但是，makeAdder 的返回值，新函数 adder，拥有一个指向作用域对象 b 的引用。最终，作用域对象 b 不会被垃圾回收器回收，直到没有任何引用指向新函数 adder。

作用域对象组成了一个名为作用域链（scope chain）的（调用）链。它和 Javascript 的对象系统使用的原型（prototype）链相类似。

一个闭包，就是 一个函数 与其 被创建时所带有的作用域对象 的组合。闭包允许你保存状态——所以，它们可以用来代替对象。这个 StackOverflow 帖子里有一些关于闭包的详细介绍。