摘要：返回如下仔細(xì)分析下面的圖，將會加深你的理解和我們有一個類對象有一個屬性，其指向構(gòu)造器的原型是一個類構(gòu)造器是之后產(chǎn)生的。

ES6 之前 ECMAScript 中有 5 種簡單數(shù)據(jù)類型（也稱為【基本數(shù)據(jù)類型】）：Undefined、Null、Boolean、Number和 String。

還有一種復(fù)雜的【引用數(shù)據(jù)類型】Object。

ES6引入了一種新的原始數(shù)據(jù)類型 Symbol，表示獨一無二的值。它是 JavaScript 語言的第七種數(shù)據(jù)類型。它也是基本數(shù)據(jù)類型。

特點

基本數(shù)據(jù)類型的值是按值訪問的
基本類型的值是不可變的
基本類型的比較是它們的值的比較
基本類型的變量是存放在棧內(nèi)存（Stack）里的

引用類型的值是按引用訪問的
引用類型的值是可變的
引用類型的比較是引用的比較
引用類型的值是保存在堆內(nèi)存（Heap）中的對象（Object） 與其他編程語言不同，JavaScript 不能直接操作對象的內(nèi)存空間（堆內(nèi)存）

圖解：

typeof

適合判斷基本數(shù)據(jù)類型和function的判斷

typeof "sss" ===> "string"
typeof 123 ===> "Number"
typeof [1,2,3] ===> "object"
typeof new Date() ===> "object"
typeof function(){alert("111");}  ===> "function"
typeof undefined ===> "undefined"
typeof NaN ===> "number"
typeof null ===> "object"

instanceof

判斷已知的對象類型或者是自定義的對象

目標(biāo)對象 + instanceof + 函數(shù)構(gòu)造器[可以理解為是某個對象是否是某個構(gòu)造器的實例]

原理： 判斷左邊的對象的原型鏈上是否有右側(cè)的構(gòu)造函數(shù)的prototype屬性

[1,3] instanceof Array === true
new Array("1, 3,4") instanceof Array === true
new Object() instanceof Object === true
new String("string") instanceof String === true
function(){this.name="22";} instanceof Function === true

// 定義一個構(gòu)造函數(shù)
function Person(){
    
}
// 定義一個構(gòu)造函數(shù)
function Student(){

}
// 每一個構(gòu)造函數(shù)都有一個prototype對象屬性， 這個對象屬性將會作為通過new Person()創(chuàng)建的對象的一個原型。
// 也就是當(dāng)我們在new 一個對象的時候，這個對象的原型就指向了這個構(gòu)造函數(shù)的prototype。

Student.prototype = new Person(); // student繼承至person

var bson = new Student();
bson instanceof Student
// false

bson instanceof Person
// true

Object.prototype.toString.apply()

判斷基本數(shù)據(jù)類型和內(nèi)置對象

Object.prototype.toString.apply([]) === "[object Array]"
Object.prototype.toString.apply(function(){}) === "[object Function]"

Object.prototype.toString.apply(new Function); // "[object Function]"
Object.prototype.toString.apply(new Object);       // "[object Object]"
Object.prototype.toString.apply(new Date);         // "[object Date]"
Object.prototype.toString.apply(new Array);        // "[object Array]"
Object.prototype.toString.apply(new RegExp);       // "[object RegExp]"
Object.prototype.toString.apply(new ArrayBuffer);  // "[object ArrayBuffer]"
Object.prototype.toString.apply(Math);             // "[object Math]"
Object.prototype.toString.apply(JSON);             // "[object JSON]"
var promise = new Promise(function(resolve, reject) {
    resolve();
});
Object.prototype.toString.apply(promise);          // "[object Promise]"
Object.prototype.toString.apply(124)
// "[object Number]"
Object.prototype.toString.apply("222")
// "[object String]"
Object.prototype.toString.apply(true)
// "[object Boolean]"
Object.prototype.toString.apply(null)
// "[object Null]"
Object.prototype.toString.apply(null) === "[object Null]"   // 在IE6/7/8下存在有兼容性問題

使用 Object 構(gòu)造函數(shù)創(chuàng)建

// 對象實例的創(chuàng)建
var obj = new Object() 
obj.key = "value"   //使用構(gòu)造函數(shù)創(chuàng)建一個空對象，并賦值

使用對象字面量表示法創(chuàng)建

//使用字面量創(chuàng)建一個對象
var obj = {
    key1: "value1",
    key2: "value2"
}  

ES6中還有更簡潔的

var age = 20
var sex = "sexy"
 
var a = {
    name: "jack",
 
    // 簡潔表示法，等同于 age: age
    age, 
 
    // 簡潔表示法，等同于 sayName: function() {}
    sayName(){}, 
 
    // 屬性名表達(dá)式，等同于 lover: "rose"
    ["lo" + "ver"]: "rose", 
 
    // 屬性名表達(dá)式，等同于 sexy: "male"
    [sex]: "male"
}

var createPerson (name, age){
    var o = {};
    o.name = name;
    o.age = age;
    o.sayName = function(){
        console.log(this);
    }
    return o;
}

var a = createPerson ("zjj", 20);
var b = createPerson ("zmf", 30);

工廠模式雖然解決多創(chuàng)建多個相似對象的問題，但卻沒有解決對象識別的問題（即怎樣知道一個對象的類型）。

構(gòu)造函數(shù)模式

function Person (name, age) {
    this.name = name;
    thia.age = age;
    this.sayName = function() { alert(this.age) }
}
Person.prototype.count = 2;
var a = new Person("a", 20)
var b = new Person("b", 22)
 
a instanceof Person // true

構(gòu)造函數(shù)與其他函數(shù)唯一的區(qū)別就在于調(diào)用他們的方式不同。任何函數(shù)只要通過new 操作符來調(diào)用，那它就可以作為構(gòu)造函數(shù)。

使用new操作符調(diào)用函數(shù)

function CO(){  
    this.p = “I’m in constructed object”;  
    this.alertP = function(){  
        alert(this.p);  
    }  
}  

var o2 = new CO();  


var obj = {}; // 第一步創(chuàng)建一個空對象
obj.__proto__ = CO.prototype; // 該對象的原型鏈指向構(gòu)造函數(shù)的 prototype 所指向的對象。
CO.call(obj); // 第三步，將構(gòu)造函數(shù)的作用域賦值給新的對象
return obj; // 返回新的對象

自定義一個new()

function Person(name, age) {
  this.name = name;
  this.age = age;
}

function New(f) {

  return function() {
    var o = {"__proto__": f.prototype}
    f.apply(o, arguments);
    return o;
  }
}

上面這種構(gòu)造函數(shù)解決了對象類型識別的問題，但是每個方法都要在每個實例上重新創(chuàng)建一遍，在上面的例子中，a 和 b 都有個名為sayName()的方法，這兩個方法雖然名字、內(nèi)容、功能相同，但卻分別在 a 和 b 中都重新創(chuàng)建了一次，這是沒有必要的。

更好的方法應(yīng)該是將公用的方法放到他們的原型上，也就是接下來要說的原型模式。

原型模式

所有函數(shù)都有一個不可枚舉的 prototype（原型）屬性，這個屬性是一個指針，指向一個對象。

Person.prototype

返回如下：

仔細(xì)分析下面的圖，將會加深你的理解

prototype 和 proto

我們有一個person類

function Person (name, age) {
    this.name = name;
    thia.age = age;
    this.sayName = function() { alert(this.age) }
}
Person.prototype.count = 2;
var p = new Person("zjj", 10);

對象p有一個__proto__屬性，其指向構(gòu)造器的原型

p.__proto__ == Person.prototype

foo 是一個類（構(gòu)造器）
fooObj是new foo() 之后產(chǎn)生的。
fooObj的 __proto__ 指向構(gòu)造器原型（foo.prototype）
foo 通過prototype 指向 構(gòu)造器原型（foo.prototype）
構(gòu)造器原型（foo.prototype）的構(gòu)造器屬性constructor 指向 foo

Person.__proto__ === Function.prototype

__proto__究竟指向誰

由于Person.prototype.__proto__ === Object.prototype，這就

相信看了上面兩幅圖，大家一定對原型鏈有了更深的理解和認(rèn)識了吧！！