摘要：的數據類型，共有六種。通常，數值字符串布爾值這三種類型，合稱為原始類型的值，即它們是最基本的數據類型，不能再細分了。運算符返回一個布爾值，表示某個對象是否為指定的構造函數的實例。

以下內容摘自阮一峰-JavaScript-標準參考教程

JavaScript 語言的每一個值，都屬于某一種數據類型。JavaScript 的數據類型，共有六種。（ES6 又新增了第七種 Symbol 類型的值）

數值（number）：整數和小數（比如1和3.14）
字符串（string）：文本（比如Hello World）。
布爾值（boolean）：表示真偽的兩個特殊值，即true（真）和false（假）
undefined：表示“未定義”或不存在，即由于目前沒有定義，所以此處暫時沒有任何值
null：表示空值，即此處的值為空。
對象（object）：各種值組成的集合。

通常，數值、字符串、布爾值這三種類型，合稱為原始類型（primitive type）的值，即它們是最基本的數據類型，不能再細分了。對象則稱為合成類型（complex type）的值，因為一個對象往往是多個原始類型的值的合成，可以看作是一個存放各種值的容器。至于undefined和null，一般將它們看成兩個特殊值。

對象是最復雜的數據類型，又可以分成三個子類型。

對象（object）

數組（array）

函數（function)

JavaScript 有三種方法，可以確定一個值到底是什么類型。

typeof運算符

instanceof運算符

Object.prototype.toString方法

typeof運算符可以返回一個值的數據類型。

數值、字符串、布爾值分別返回number、string、boolean。

typeof 123 // "number"
typeof "123" // "string"
typeof false // "boolean"

函數返回function。

function f() {}
typeof f
// "function"
      

undefined返回undefined

typeof undefined
// "undefined"

這個特點通常用在判斷語句

if (typeof v === "undefined") {
  // ...
}  
  

對象返回object。

typeof window // "object"
typeof {} // "object"
typeof [] // "object"*

null返回object。

 `typeof null // "object"

instanceof運算符可以區分數組和對象。
instanceof運算符返回一個布爾值，表示某個對象是否為指定的構造函數的實例。

var o = {};
var a = [];

o instanceof Array // false
a instanceof Array // true

var v = new Vehicle();
v instanceof Vehicle // true

上面代碼中，對象v是構造函數Vehicle的實例，所以返回true。

instanceof運算符的左邊是實例對象，右邊是構造函數。它會檢查右邊構建函數的原型對象（prototype），是否在左邊對象的原型鏈上。因此，下面兩種寫法是等價的。

 v instanceof Vehicle
// 等同于
Vehicle.prototype.isPrototypeOf(v)
    

由于instanceof對整個原型鏈上的對象都有效，因此同一個實例對象，可能會對多個構造函數都返回true。

var d = new Date();
d instanceof Date // true
d instanceof Object // true

上面代碼中，d同時是Date和Object的實例，因此對這兩個構造函數都返回true。

instanceof的原理是檢查原型鏈，對于那些不存在原型鏈的對象，就無法判斷。

Object.create(null) instanceof Object // false

上面代碼中，Object.create(null)返回的新對象的原型是null，即不存在原型，因此instanceof就認為該對象不是Object的實例。

除了上面這種繼承null的特殊情況，JavaScript 之中，只要是對象，就有對應的構造函數。因此，instanceof運算符的一個用處，是判斷值的類型。

var x = [1, 2, 3];
var y = {};
x instanceof Array // true
y instanceof Object // true

上面代碼中，instanceof運算符判斷，變量x是數組，變量y是對象。

注意，instanceof運算符只能用于對象，不適用原始類型的值。

var s = "hello";
s instanceof String // false

上面代碼中，字符串不是String對象的實例（因為字符串不是對象），所以返回false。

此外，對于undefined和null，instanceOf運算符總是返回false。

undefined instanceof Object // false
null instanceof Object // false

利用instanceof運算符，還可以巧妙地解決，調用構造函數時，忘了加new命令的問題。

function Fubar (foo, bar) {
  if (this instanceof Fubar) {
    this._foo = foo;
    this._bar = bar;
  }
  else {
    return new Fubar(foo, bar);
  }
}

上面代碼使用instanceof運算符，在函數體內部判斷this關鍵字是否為構造函數Fubar的實例。如果不是，就表明忘了加new命令。

toString方法的作用是返回一個對象的字符串形式，默認情況下返回類型字符串。

var o1 = new Object();
o1.toString() // "[object Object]"

var o2 = {a:1};
o2.toString() // "[object Object]"

上面代碼表示，對于一個對象調用toString方法，會返回字符串[object Object]，該字符串說明對象的類型。
字符串[object Object]本身沒有太大的用處，但是通過自定義toString方法，可以讓對象在自動類型轉換時，得到想要的字符串形式。

var obj = new Object();

obj.toString = function () {
  return "hello";
};

obj + " " + "world" // "hello world"

上面代碼表示，當對象用于字符串加法時，會自動調用toString方法。由于自定義了toString方法，所以返回字符串hello world。

數組、字符串、函數、Date 對象都分別部署了自定義的toString方法，覆蓋了Object.prototype.toString方法。

[1, 2, 3].toString() // "1,2,3"

"123".toString() // "123"

(function () {
  return 123;
}).toString()
// "function () {
//   return 123;
// }"

(new Date()).toString()
// "Tue May 10 2016 09:11:31 GMT+0800 (CST)"

上面代碼中，數組、字符串、函數、Date 對象調用toString方法，并不會返回[object Object]，因為它們都自定義了toString方法，覆蓋原始方法。

**toString() 的應用：判斷數據類型
Object.prototype.toString方法返回對象的類型字符串，因此可以用來判斷一個值的類型。**

var obj = {};
obj.toString() // "[object Object]"

上面代碼調用空對象的toString方法，結果返回一個字符串object Object，其中第二個Object表示該值的構造函數。這是一個十分有用的判斷數據類型的方法。

由于實例對象可能會自定義toString方法，覆蓋掉Object.prototype.toString方法，所以為了得到類型字符串，最好直接使用Object.prototype.toString方法。通過函數的call方法，可以在任意值上調用這個方法，幫助我們判斷這個值的類型。

Object.prototype.toString.call(value)

上面代碼表示對value這個值調用Object.prototype.toString方法。

不同數據類型的Object.prototype.toString方法返回值如下。

數值：返回[object Number]。
字符串：返回[object String]。
布爾值：返回[object Boolean]。
undefined：返回[object Undefined]。
null：返回[object Null]。
數組：返回[object Array]。
arguments 對象：返回[object Arguments]。
函數：返回[object Function]。
Error 對象：返回[object Error]。
Date 對象：返回[object Date]。
RegExp 對象：返回[object RegExp]。
其他對象：返回[object Object]。

這就是說，Object.prototype.toString可以看出一個值到底是什么類型。

Object.prototype.toString.call(2) // "[object Number]"
Object.prototype.toString.call("") // "[object String]"
Object.prototype.toString.call(true) // "[object Boolean]"
Object.prototype.toString.call(undefined) // "[object Undefined]"
Object.prototype.toString.call(null) // "[object Null]"
Object.prototype.toString.call(Math) // "[object Math]"
Object.prototype.toString.call({}) // "[object Object]"
Object.prototype.toString.call([]) // "[object Array]"

利用這個特性，可以寫出一個比typeof運算符更準確的類型判斷函數。

    var type = function (o){
      var s = Object.prototype.toString.call(o);
      return s.match(/[object (.*?)]/)[1].toLowerCase();
    };
    
    type({}); // "object"
    type([]); // "array"
    type(5); // "number"
    type(null); // "null"
    type(); // "undefined"
    type(/abcd/); // "regex"
    type(new Date()); // "date"

在上面這個type函數的基礎上，還可以加上專門判斷某種類型數據的方法。

var type = function (o){
  var s = Object.prototype.toString.call(o);
  return s.match(/[object (.*?)]/)[1].toLowerCase();
};

["Null",
 "Undefined",
 "Object",
 "Array",
 "String",
 "Number",
 "Boolean",
 "Function",
 "RegExp"
].forEach(function (t) {
  type["is" + t] = function (o) {
    return type(o) === t.toLowerCase();
  };
});

type.isObject({}) // true
type.isNumber(NaN) // true
type.isRegExp(/abc/) // true

null與undefined都可以表示“沒有”，含義非常相似。將一個變量賦值為undefined或null，老實說，語法效果幾乎沒區別。

在if語句中，它們都會被自動轉為false，相等運算符（==）甚至直接報告兩者相等。

if (!undefined) {
  console.log("undefined is false");
}
// undefined is false

if (!null) {
  console.log("null is false");
}
// null is false

undefined == null
// true

null是一個表示“空”的對象，轉為數值時為0；undefined是一個表示”此處無定義”的原始值，轉為數值時為NaN

Number(null) // 0
5 + null // 5

Number(undefined) // NaN
5 + undefined // NaN

null,undefined 用法
對于null和undefined，大致可以像下面這樣理解。

null表示空值，即該處的值現在為空。調用函數時，某個參數未設置任何值，這時就可以傳入null，表示該參數為空。比如，某個函數接受引擎拋出的錯誤作為參數，如果運行過程中未出錯，那么這個參數就會傳入null，表示未發生錯誤。

undefined表示“未定義”，下面是返回undefined的典型場景。

// 變量聲明了，但沒有賦值
var i;
i // undefined

// 調用函數時，應該提供的參數沒有提供，該參數等于 undefined
function f(x) {
  return x;
}
f() // undefined

// 對象沒有賦值的屬性
var  o = new Object();
o.p // undefined

// 函數沒有返回值時，默認返回 undefined
function f() {}
f() // undefined

布爾值代表“真”和“假”兩個狀態。“真”用關鍵字true表示，“假”用關鍵字false表示。布爾值只有這兩個值。

下列運算符會返回布爾值：

兩元邏輯運算符： && (And)，|| (Or)
前置邏輯運算符： ! (Not)
相等運算符：===，!==，==，!=
比較運算符：>，>=，<，<=

如果 JavaScript 預期某個位置應該是布爾值，會將該位置上現有的值自動轉為布爾值。轉換規則是除了下面六個值被轉為false，其他值都視為true。

undefined
null
false
0
NaN
""或""（空字符串）

布爾值往往用于程序流程的控制，請看一個例子。

if ("") {
  console.log("true");
}

// 沒有任何輸出
上面代碼中，if命令后面的判斷條件，預期應該是一個布爾值，所以 JavaScript 自動將空字符串，轉為布爾值false，導致程序不會進入代碼塊，所以沒有任何輸出。

注意，空數組（[]）和空對象（{}）對應的布爾值，都是true。

if ([]) {
  console.log("true");
}
// true

if ({}) {
  console.log("true");
}
// true