根據 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 轉換為數字，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() 是作為函式呼叫的。您通常不會將它們用作建構函式。然後它們會建立它們自己的執行個體（請參閱 基本型別的包裝物件）。

若要 將值轉換為數字或字串，它會先轉換為任意基本型別值，然後再轉換為最終型別（如 轉換為布林值、數字、字串和物件的函式 中所討論）。

ECMAScript 規範有一個內部函式 ToPrimitive()（無法從 JavaScript 存取），它會執行此轉換。了解 ToPrimitive() 可讓您設定如何將物件轉換為數字和字串。它的簽章如下

ToPrimitive(input, PreferredType?)

選用參數 PreferredType 指出轉換的最終類型：根據 ToPrimitive() 的結果會轉換為數字或字串，因此可能是 Number 或 String。

如果 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