摘要：數(shù)據(jù)類型最新的標準定義了種數(shù)據(jù)類型種原型數(shù)據(jù)類型變量未定義時的屬性。布爾值，和表示數(shù)字，例如或者。函數(shù)，可以將其他類型的值轉(zhuǎn)換為布爾類型。值可以顯式轉(zhuǎn)為字符串布爾值，但是不能轉(zhuǎn)為數(shù)值。首先是動態(tài)數(shù)據(jù)類型的語言，很多類型檢查是不必要的。

最新的 ECMAScript 標準定義了 7 種數(shù)據(jù)類型：

6種原型數(shù)據(jù)類型（primitive type）:

undefined. 變量未定義時的屬性。

null. 一個表明 null 值的特殊關(guān)鍵字。 JavaScript 是大小寫敏感的，因此 null 與 Null、NULL或其他變量完全不同。

Boolean. 布爾值，true 和 false.

Number. 表示數(shù)字，例如： 42 或者 3.14159。

String. 表示字符串，例如："Howdy"

Symbol ( 在 ECMAScript 6 中新添加的類型).。一種數(shù)據(jù)類型，它的實例是唯一且不可改變的。

以及 Object 對象。（complex type 復雜類型）

Undefined類型只有一個值undefined，表示"缺少值"，就是此處應該有一個值，但是還沒有定義。主要的用法：

（1）變量被聲明了，但沒有賦值時，就等于undefined。
（2)  調(diào)用函數(shù)時，應該提供的參數(shù)沒有提供，該參數(shù)等于undefined。
（3）對象沒有賦值的屬性，該屬性的值為undefined。
（4）函數(shù)沒有返回值時，默認返回undefined。
   PS: 值 undefined 并不同于未定義的值。但是，typeof 運算符并不真正區(qū)分這兩種值。

var i;
console.log(i) ; // undefined

function f(x){console.log(x)}
f();  // undefined

var  o = new Object();
console.log(o.p);  // undefined

var func = f();
console.log(func);  // undefined

console.log(typeof y); //"undefined"

null類型的默認值是null，從邏輯角度講，是表示一個空對象指針，表示"沒有對象"，即該處不應該有值。主要用法：

（1） 作為函數(shù)的參數(shù)，表示該函數(shù)的參數(shù)不是對象。
（2） 作為對象原型鏈的終點。

Object.getPrototypeOf(Object.prototype)  // null

區(qū)別undefined：

當一個變量聲明后，未初始化，則該值為undefined，如果這個值是為了保存對象，則修改其默認初始化的值，改為null。 所以當檢測其類型時，會顯示類型為object。

typeof null        // object (歷史原因，不是"null")
typeof undefined   // "undefined"
null === undefined // false
null  == undefined // true
null === null // true
null == null // true
!null // true
Number(null) // 0
Number(undefined) // NaN
isNaN(1 + null) // false
isNaN(1 + undefined) // true

布爾類型，該類型有兩個值：true false。Bloolean()函數(shù)，可以將其他類型的值轉(zhuǎn)換為布爾類型。同時也存在隱式類型轉(zhuǎn)換。

這里區(qū)分一下Truthy類型和Falsy類型值。
Falsy類型值包括："", 0, null, undefined, NaN, false。
除了Falsy類型值以外的都被稱為Truthy類型值，它們會被轉(zhuǎn)換為 true。

Boolean(null)         // false
Boolean("hello")      // true 
Boolean("0")          // true 
Boolean(" ")          // true 
Boolean([])           // true 
Boolean(function(){}) // true

根據(jù) ECMAScript 標準，JavaScript 中只有一種數(shù)字類型：基于 IEEE 754 標準的雙精度 64 位二進制格式的值（-(263 -1) 到 263 -1）。它并沒有為整數(shù)給出一種特定的類型。除了能夠表示浮點數(shù)外，還有一些帶符號的值：+Infinity，-Infinity 和 NaN (非數(shù)值，Not-a-Number)。
整數(shù)可以用十進制（基數(shù)為10）、十六進制（基數(shù)為16）、八進制（基數(shù)為8）以及二進制（基數(shù)為2）的字面值來表示。

0, 117 and -345 (十進制, 基數(shù)為10)
015, 0001 and -0o77 (八進制, 基數(shù)為8) 
0x1123, 0x00111 and -0xF1A7 (十六進制, 基數(shù)為16或"hex")
0b11, 0b0011 and -0b11 (二進制, 基數(shù)為2)

浮點數(shù)（有趣的一點是，在計算前其存儲為字符串）所占據(jù)的內(nèi)存空間是整數(shù)的兩倍。
語法：[(+|-)][digits][.digits][(E|e)[(+|-)]digits]

3.14      
-.2345789 // -0.23456789
-3.12e+12  // -3.12*1012
.1e-23    // 0.1*10-23=10-24=1e-24

NaN:
1、即非數(shù)值，是一個特殊的值，這個數(shù)值用于表示一個本來要返回數(shù)值的操作數(shù)，未返回數(shù)值的情況。比如任何數(shù)值除以0，本是不符合規(guī)范的，js里，這樣的操作返回NaN（但是實際上，只有0除以0時返回NaN，其他則無窮值）。

2、NaN有兩個不同尋常的特點：任何涉及NaN的操作都會返回NaN，NaN值與任何值都不相等，包括本身。
3、isNaN()函數(shù)，這個函數(shù)可以判斷，傳遞的參數(shù)是否“不是數(shù)值”這里涉及數(shù)值轉(zhuǎn)換的問題，例如“10”這個字符串就可以轉(zhuǎn)換為10，但是“blue”這個字符串則無法轉(zhuǎn)換為數(shù)字，所以isNaN("blue")==true 。

+0 === -0  //true
42 / +0; // Infinity
42 / -0; // -Infinity
NaN == NaN //false

+Infinity，-Infinity:
要檢查值是否大于或小于 +/-Infinity，你可以使用常量 Number.MAX_VALUE 和 Number.MIN_VALUE。另外在 ECMAScript 6 中，你也可以通過 Number.isSafeInteger() 方法還有 Number.MAX_SAFE_INTEGER 和 Number.MIN_SAFE_INTEGER 來檢查值是否在雙精度浮點數(shù)的取值范圍內(nèi)。 超出這個范圍，JavaScript 中的數(shù)字不再安全了，也就是只有 second mathematical interger 可以在 JavaScript 數(shù)字類型中正確表現(xiàn)。

這個算是比較熟悉的了這里引用一下MDN的描述。
JavaScript的字符串類型用于表示文本數(shù)據(jù)。它是一組16位的無符號整數(shù)值的“元素”。在字符串中的每個元素占據(jù)了字符串的位置。第一個元素的索引為0，下一個是索引1，依此類推。字符串的長度是它的元素的數(shù)量。
不同于類 C 語言，JavaScript 字符串是不可更改的。這意味著字符串一旦被創(chuàng)建，就不能被修改。但是，可以基于對原始字符串的操作來創(chuàng)建新的字符串。
主要強調(diào)一下ES2015的模板字符串：

// Basic literal string creation
`In JavaScript "
" is a line-feed.`

// Multiline strings
`In JavaScript this is
 not legal.`

// String interpolation
var name = "Bob", time = "today";
`Hello ${name}, how are you ${time}?`

// Construct an HTTP request prefix is used to interpret the replacements and construction
POST`http://foo.org/bar?a=${a}&b=$
     Content-Type: application/json
     X-Credentials: ${credentials}
     { "foo": ${foo},
       "bar": ${bar}}`(myOnReadyStateChangeHandler);
       

String()函數(shù)可以將任何類型的值轉(zhuǎn)換為字符串，包括null轉(zhuǎn)換為"null"、undefined轉(zhuǎn)換為"undefined"。

語法：Symbol([description])
1、每個從Symbol()返回的symbol值都是唯一的。
直接使用Symbol()創(chuàng)建新的symbol類型，并用一個字符串（可省略）作為其描述。以下代碼創(chuàng)建了三個新的symbol類型。 字符串 “foo” 的作用僅為描述，它每次都會創(chuàng)建一個新的 symbol類型：

var sym1 = Symbol();
var sym2 = Symbol("foo");
var sym3 = Symbol("foo");
Symbol("foo") === Symbol("foo"); // false

還可以使用Symbol.for方法創(chuàng)建新的symbol類型，和前者區(qū)別Symbol.for()會把symbol值以一個key值登記到全局環(huán)境中，Symbol()就不會。Symbol.for()不會每次調(diào)用就返回一個新的 Symbol 類型的值，而是會先檢查給定的key是否已經(jīng)存在，如果不存在才會新建一個值。比如，如果你調(diào)用Symbol.for("cat")30 次，每次都會返回同一個 Symbol 值，但是調(diào)用Symbol("cat")30 次，會返回 30 個不同的 Symbol 值。查看登記的Symbol值可以使用Symbol.keyFor方法，該方法返回一個已登記的 Symbol 類型值的key。

let sym1 = Symbol("foo");
let sym2 = Symbol("foo");
let sym3 = Symbol.for("foo");
let sym4 = Symbol.for("foo");
sym1 === sym2  //false
sym3 === sym4  //true
Symbol.keyFor(sym1) //undefined
Symbol.keyFor(sym3) //"foo"

2、 不再支持new 運算符的語法：

var sym = new Symbol(); // TypeError

這會阻止創(chuàng)建一個顯式的 Symbol 包裝器對象而不是一個 Symbol 值。圍繞原始數(shù)據(jù)類型創(chuàng)建一個顯式包裝器對象從 ECMAScript 6 開始不再被支持。 然而，現(xiàn)有的原始包裝器對象，如 new Boolean、new String以及new Number因為遺留原因仍可被創(chuàng)建。

3、特殊的類型轉(zhuǎn)換
Symbol 值不能與其他類型的值進行運算。
Symbol 值可以顯式轉(zhuǎn)為字符串、布爾值，但是不能轉(zhuǎn)為數(shù)值。

4、用于對象屬性名（主要）
Symbol 值作為對象屬性名時，不能用點運算符。一般通過方括號結(jié)構(gòu)和Object.defineProperty，將對象的屬性名指定為一個 Symbol 值。

let sym1 = Symbol();
let sym2 = Symbol();
let sym3 = Symbol();

let a = {
  [sym1]: "Symbol1";
};
a[sym2] = "Symbol2";
Object.defineProperty(a, sym3, { value: "Symbol3" });

a.sym1 = "Hello!";
a[sym1] // "Symbol1"
a["sym1"] // "Hello!"

Symbol 作為屬性名，該屬性不會出現(xiàn)在for...in、for...of循環(huán)中，也不會被Object.keys()、Object.getOwnPropertyNames()、JSON.stringify()返回。但是，它也不是私有屬性，有一個Object.getOwnPropertySymbols方法，返回一個數(shù)組，成員是當前對象的所有用作屬性名的 Symbol 值。

更多的Symbol相關(guān)內(nèi)容參考這篇文章——傳送門

在計算機科學中, 對象是指內(nèi)存中的可以被標識符引用的一塊區(qū)域。
對象屬于復雜數(shù)據(jù)類型，也可以說是引用類型（邏輯上等價于class/類）。相對于原始數(shù)據(jù)類型的直接存?。?nèi)存），復雜數(shù)據(jù)類型的存儲方式為引用（堆內(nèi)存，棧內(nèi)存保存對應的指針）。

ECMAScript 中的所有對象都由這個對象繼承而來，Object 對象中的所有屬性和方法都會出現(xiàn)在其他對象中，所以理解了 Object 對象，就可以更好地理解其他對象。
本文主要介紹以下幾點：

Object()作為函數(shù)以及Object()構(gòu)造函數(shù)

Object靜態(tài)方法

Object實例方法

1、Object()與new Object()
Object函數(shù)可以把任意值轉(zhuǎn)換為對象；new Object()則是生成新對象，可以簡寫為{}。除語義上的不同外，兩者的用法相同，以下以Object()為例：

var obj = Object();
var obj = Object(undefined);
var obj = Object(null);
//以上語句等效，返回空對象
obj instanceof Object // true

var obj = Object(1);
obj instanceof Object // true
obj instanceof Number // true

var obj = Object("foo");
obj instanceof Object // true
obj instanceof String // true

var obj = Object(true);
obj instanceof Object // true
obj instanceof Boolean // true

如果參數(shù)本來就是一個對象便不需要轉(zhuǎn)換，直接返回該對象：

var arr = [];
var obj = Object(arr); // 返回原數(shù)組
obj === arr // true

var value = {};
var obj = Object(value) // 返回原對象
obj === value // true

var fn = function () {};
var obj = Object(fn); // 返回原函數(shù)
obj === fn // true

2、Object靜態(tài)方法
所謂“靜態(tài)方法”，是指部署在Object對象自身的方法。例如：Object.key = value、{key:value}。
一般使用Object.keys方法和Object.getOwnPropertyNames方法來遍歷對象的屬性。區(qū)別在于后者可以列舉不可枚舉的屬性名，例如數(shù)組的length。

var a = ["Hello", "World"];

Object.keys(a) // ["0", "1"]
Object.getOwnPropertyNames(a) // ["0", "1", "length"]

其他靜態(tài)方法：(傳送門)
1）對象屬性模型的相關(guān)方法

Object.getOwnPropertyDescriptor()：獲取某個屬性的描述對象。

Object.defineProperty()：通過描述對象，定義某個屬性。定義key為Symbol的屬性的方法之一。

Object.defineProperties()：通過描述對象，定義多個屬性。

2）控制對象狀態(tài)的方法

Object.preventExtensions()：防止對象擴展。

Object.isExtensible()：判斷對象是否可擴展。

Object.seal()：禁止對象配置。

Object.isSealed()：判斷一個對象是否可配置。

Object.freeze()：凍結(jié)一個對象。

Object.isFrozen()：判斷一個對象是否被凍結(jié)。

3）原型鏈相關(guān)方法

Object.assign(target, ...sources)：用于將所有可枚舉屬性的值從一個或多個源對象復制到目標對象。它將返回目標對象。

Object.create()：該方法可以指定原型對象和屬性，返回一個新的對象。

Object.getPrototypeOf()：獲取對象的Prototype對象。

3、Object實例方法
定義在Object.prototype的·對象稱為實例方法，所有Object的實例對象都繼承了這些方法。
Object實例對象的方法，主要有以下六個。

Object.prototype.valueOf()：返回當前對象對應的值。

Object.prototype.toString()：返回當前對象對應的字符串形式。檢測對象類型。

Object.prototype.toLocaleString()：返回當前對象對應的本地字符串形式。

Object.prototype.hasOwnProperty()：判斷某個屬性是否為當前對象自身的屬性，還是繼承自原型對象的屬性。

Object.prototype.isPrototypeOf()：判斷當前對象是否為另一個對象的原型。

Object.prototype.propertyIsEnumerable()：判斷某個屬性是否可枚舉。

之所以會說到這個判斷問題，主要原因是typeof是不太靠譜的。首先JavaScript是動態(tài)數(shù)據(jù)類型的語言，很多類型檢查是不必要的。在具體實現(xiàn)上的問題，在實際的項目應用中，typeof也只有兩個用途，就是檢測一個元素是否為undefined，或者是否為function。由下面的表格可見一斑：

Value               function   typeof
-------------------------------------
"foo"               String     string
new String("foo")   String     object
1.2                 Number     number
new Number(1.2)     Number     object
true                Boolean    boolean
new Boolean(true)   Boolean    object
new Date()          Date       object
new Error()         Error      object
[1,2,3]             Array      object
new Array(1, 2, 3)  Array      object
new Function("")    Function   function
/abc/g              RegExp     object
new RegExp("meow")  RegExp     object
{}                  Object     object
new Object()        Object     object 

如果還是要判斷的話，公認的靠譜解法是 Object.prototype.toString.call(x) === "[object type]"。具體實現(xiàn)可以參考jQuery.type()源碼。另外通過構(gòu)造函數(shù)創(chuàng)建的對象都可以用 instanceof 檢查。

http://www.ruanyifeng.com/blo...

https://zhuanlan.zhihu.com/p/...

https://developer.mozilla.org...

https://developer.mozilla.org...

https://javascript.ruanyifeng...

https://segmentfault.com/q/10...