根据ECMAScript 语言规范第 8 章的规定，JavaScript只有六种类型

因此，从技术上讲，构造函数不会引入新的类型，即使它们被认为具有实例。

在语言语义和类型系统的上下文中，静态通常表示“在编译时”或“不运行程序”，而动态表示“在运行时”。

在静态类型语言中，变量、参数和对象成员（JavaScript 将其称为属性）的类型是编译器在编译时知道的。编译器可以使用该信息执行类型检查和优化编译后的代码。

即使在静态类型语言中，变量也有一个动态类型，即变量在运行时给定时间点的值的类型。动态类型可能与静态类型不同。例如（Java）

Object foo = "abc";

foo 的静态类型是 Object；其动态类型是 String。

JavaScript 是动态类型的；变量的类型通常在编译时是未知的。

如果您有类型信息，则可以检查操作中使用的值（调用函数、应用运算符等）是否具有正确的类型。静态类型检查语言在编译时执行这种检查，而动态类型检查语言在运行时执行这种检查。一种语言可以同时进行静态类型检查和动态类型检查。如果检查失败，您通常会收到某种错误或异常。

JavaScript 执行一种非常有限的动态类型检查

> var foo = null;
> foo.prop
TypeError: Cannot read property 'prop' of null

然而，大多数情况下，事情都会默默地失败或成功。例如，如果您访问一个不存在的属性，您将获得值 undefined

> var bar = {};
> bar.prop
undefined

在 JavaScript 中，处理类型不匹配的值的主要方法是将其强制转换为正确的类型。强制转换意味着隐式类型转换。 大多数操作数都会强制转换：

> '3' * '4'
12

JavaScript 的内置转换机制仅支持 Boolean、Number、String 和 Object 类型。没有标准的方法将一个构造函数的实例转换为另一个构造函数的实例。

在这里，我们回顾了 undefined 和 null 出现的各种情况。

> var foo;
> foo
undefined

> function f(x) { return x }
> f()
undefined

> var obj = {}; // empty object
> obj.foo
undefined

> function f() {}
> f()
undefined

> function g() { return; }
> g()
undefined

在以下部分中，我们将回顾如何分别检查 undefined 和 null，或检查两者是否存在。

if (x === null) ...

if (x === undefined) ...

// Does x have a value?
if (x !== undefined && x !== null) {
    ...
}
// Is x a non-value?
if (x === undefined || x === null) {
    ...
}

// Does x have a value (is it truthy)?
if (x) {
    ...
}
// Is x falsy?
if (!x) {
    ...
}

单个非值可以同时扮演 undefined 和 null 的角色。为什么 JavaScript 有两个这样的值？原因是历史原因。

JavaScript 采用了 Java 将值划分为基元和对象的方法。它还使用了 Java 的“非对象”值 null。按照 C（但不是 Java）的先例，如果强制转换为数字，则 null 将变为 0：

> Number(null)
0
> 5 + null
5

请记住，第一个版本的 JavaScript 没有异常处理。因此，必须通过值来指示异常情况，例如未初始化的变量和缺少的属性。null 会是一个不错的选择，但 Brendan Eich 在当时想避免两件事

因此，Eich 将 undefined 作为另一个非值添加到语言中。它会强制转换为 NaN

> Number(undefined)
NaN
> 5 + undefined
NaN

undefined 是全局对象（因此也是全局变量；请参阅全局对象）的属性。在 ECMAScript 3 下，读取 undefined 时必须采取预防措施，因为它很容易意外更改其值。在 ECMAScript 5 下，这不是必需的，因为 undefined 是只读的。

为了防止 undefined 被更改，有两种流行的技术（它们仍然与旧的 JavaScript 引擎相关）

基本类型值（例如 'abc'）与包装器实例（例如 new String('abc')）根本不同：

> typeof 'abc'  // a primitive value
'string'
> typeof new String('abc')  // an object
'object'
> 'abc' instanceof String  // never true for primitives
false
> 'abc' === new String('abc')
false

包装器实例是对象，并且在 JavaScript 中无法比较对象，即使通过宽松的相等运算符 == 也不行（请参阅相等运算符：=== 与 ==）

> var a = new String('abc');
> var b = new String('abc');
> a == b
false

包装对象有一个用例：您想向基本类型值添加属性。然后，您可以包装基本类型并将属性添加到包装对象。在使用该值之前，您需要将其解包。

通过调用包装器构造函数来包装基本类型

new Boolean(true)
new Number(123)
new String('abc')

通过调用方法 valueOf() 来解包基本类型。所有对象都有此方法（如转换为基本类型中所述）

> new Boolean(true).valueOf()
true
> new Number(123).valueOf()
123
> new String('abc').valueOf()
'abc'

将包装对象正确转换为基本类型会提取数字和字符串，但不会提取布尔值：

> Boolean(new Boolean(false))  // does not unwrap
true
> Number(new Number(123))  // unwraps
123
> String(new String('abc'))  // unwraps
'abc'

原因在转换为布尔值中进行了说明。

基本类型没有自己的方法，而是从包装器借用方法

> 'abc'.charAt === String.prototype.charAt
true

松散模式和严格模式以不同的方式处理这种借用。在松散模式下，基本类型会动态转换为包装器

String.prototype.sloppyMethod = function () {
    console.log(typeof this); // object
    console.log(this instanceof String); // true
};
''.sloppyMethod(); // call the above method

在严格模式下，将透明地使用包装器原型中的方法

String.prototype.strictMethod = function () {
    'use strict';
    console.log(typeof this); // string
    console.log(this instanceof String); // false
};
''.strictMethod(); // call the above method

因此，JavaScript 很少会抱怨值的类型错误。例如，程序通常会将用户输入（来自在线表单或 GUI 小窗口）接收为字符串，即使用户输入的是数字也是如此。如果您将数字字符串视为数字，则不会收到警告，只会得到意外的结果。例如

var formData = { width: '100' };

// You think formData.width is a number
// and get unexpected results
var w = formData.width;
var outer = w + 20;

// You expect outer to be 120, but it’s not
console.log(outer === 120);  // false
console.log(outer === '10020');  // true

在上述情况下，您应该尽早转换为适当的类型

var w = Number(formData.width);

以下函数是将值转换为布尔值、数字、字符串或对象的推荐方法：

请注意，Boolean()、Number()、String() 和 Object() 是作为函数调用的。您通常不会将它们用作构造函数。然后，它们会创建自身的实例（请参阅基本类型的包装对象）。

要将值转换为数字或字符串，首先将其转换为任意基本类型值，然后将其转换为最终类型（如转换为 Boolean、Number、String 和 Object 的函数中所述）。

ECMAScript 规范有一个内部函数 ToPrimitive()（无法从 JavaScript 访问），它执行此转换。了解 ToPrimitive() 使您能够配置如何将对象转换为数字和字符串。它具有以下签名

ToPrimitive(input, PreferredType?)

可选参数 PreferredType 指示转换的最终类型：它是 Number 或 String，具体取决于 ToPrimitive() 的结果是转换为数字还是字符串。

如果 PreferredType 是 Number，则执行以下步骤

如果 PreferredType 是 String，则步骤 2 和 3 将交换。也可以省略 PreferredType；然后，对于日期，它被视为 String，对于所有其他值，它被视为 Number。这就是运算符 + 和 == 调用 ToPrimitive() 的方式。

> var empty = {};
> empty.valueOf() === empty
true
> empty.toString()
'[object Object]'

> Number({})
NaN

> var n = { valueOf: function () { return 123 } };
> Number(n)
123
> String(n)
'[object Object]'

> var s = { toString: function () { return '7'; } };
> String(s)
'7'
> Number(s)
7