摘要：命令命令的作用，就是執(zhí)行構(gòu)造函數(shù)，返回一個實例對象。實例對象相當(dāng)于創(chuàng)建一個空的構(gòu)造函數(shù)，將其屬性指向參數(shù)對象，從而實現(xiàn)讓該實例繼承的屬性。

這是ES5的入門篇教程的筆記，網(wǎng)址：JavaScript教程，以下內(nèi)容中黑體表示大標(biāo)題，還有一些重點(diǎn)；斜體表示對于自身，還需要下功夫?qū)W習(xí)的內(nèi)容。這里面有一些自己的見解，所以若是發(fā)現(xiàn)問題，歡迎指出~

實例對象與new命令
面向?qū)ο缶幊淌悄壳爸髁鞯木幊谭妒剑鼘⒄鎸嵤澜绺鞣N復(fù)雜的關(guān)系，抽象為一個個對象，然后由對象之間的分工與合作，完成對真實世界的模擬。
對象是單個事物的抽象。
對象是一個容器，封裝了屬性（property）和方法（method）。
屬性是對象的狀態(tài)，方法是對象的行為。兩者最主要的區(qū)別在于屬性屬于對象靜態(tài)的一面，方法屬于對象動態(tài)的一面。
構(gòu)造函數(shù)
面向?qū)ο缶幊痰牡谝徊剑褪且蓪ο螅ǔＰ枰粋€模板，表示某一類實物的共同特征，然后對象根據(jù)這個模板生成。
典型的面向?qū)ο缶幊陶Z言（比如C++和JAVA），都有“類”（class）這個概念。所謂“類”就是對象的模板，對象就是“類”的實例。但是JavaScript語言的對象體系，不是基于“類”的，而是基于構(gòu)造函數(shù)（constructor）和原型鏈（prototype）。
構(gòu)造函數(shù)，為了與普通函數(shù)區(qū)別，構(gòu)造函數(shù)名字的第一個字母通常大寫。它有兩個特點(diǎn)：1）函數(shù)體內(nèi)部使用了this關(guān)鍵字，代表了所要生成的對象實例；2）生成對象的時候，必須使用new命令。
new命令
new命令的作用，就是執(zhí)行構(gòu)造函數(shù)，返回一個實例對象。
new命令本身就可以執(zhí)行構(gòu)造函數(shù)，所以后面的構(gòu)造函數(shù)可以帶括號，也可以不帶括號。但是為了表示這里是函數(shù)調(diào)用，推薦使用括號。

// 推薦的寫法
let v = new Vehicle();
// 不推薦的寫法
let v = new Vehicle(); // 這兩種寫法都是等價的

new命令的原理
使用new命令時，它后面的函數(shù)依次執(zhí)行下面的步驟：

1、創(chuàng)建一個空對象，作為將要返回的對象實例；
2、將這個空對象的原型，指向構(gòu)造函數(shù)的prototype屬性；
3、將這個空對象賦值給函數(shù)內(nèi)部的this關(guān)鍵字；
4、開始執(zhí)行構(gòu)造函數(shù)內(nèi)部的代碼。

如果構(gòu)造函數(shù)內(nèi)部由return語句，而且return后面跟著一個對象，new命令會返回return語句指定的對象；否則，就會不管return語句，返回this對象。（也就是說，new后，只能返回對象，要么是自身，要么是一個新對象。）
構(gòu)造函數(shù)與普通函數(shù)最主要的區(qū)別，是內(nèi)部有沒有this關(guān)鍵字的函數(shù)。
對普通函數(shù)使用new命令，會返回一個空對象。

function getMessage() {
    let a = 1;
    return "this is a message";
}
let msg = new getMessage(); // {}
typeof msg // "object"

構(gòu)造函數(shù)作為模板，可以生成實例對象，但是，有時拿不到構(gòu)造函數(shù)，只能拿到一個現(xiàn)有的對象，通過Object.create()方法，可以將這個現(xiàn)有的對象作為模板，生成新的實例對象。

let person1 = {
    name: "張三",
    greeting: function() {
        console.log("Hi! I"m " + this.name + ".");
    }
}
let person2 = Obejct.create(person1); // person2繼承了person1的屬性和方法。
person2.name // 張三
person2.greeting() // Hi! I"m 張三.

this關(guān)鍵字
如果this所在的方法不在對象的第一層，這時this只是指向當(dāng)前一層的對象，而不會繼承更上面一層。
由于this的指向是不確定的，所以切勿在函數(shù)中包含多層的this。

let a = {
    p: "Hello",
    b: {
        m: function() {
            console.log(this.p);
        }
    }
};
a.b.m() // undefined a.b.m方法在a對象的第二層，該方法內(nèi)部的this不是指向a，而是指向a.b。

let o = {
    f1: function () {
        console.log(this);
        let f2 = function () {
            console.log(this);
        }(); // 這里是執(zhí)行函數(shù)了，就變成了值
    }
}
o.f1()
// Object 第一層指向?qū)ο髈
// Window 第二層指向全局對象

// 實際執(zhí)行的如下
let temp = function () {
    console.log(this);
};
let o = {
    f1: function() {
        console.log(this);
        let f2 = temp();
    }
}

數(shù)組中的map和foreach方法，允許提供一個函數(shù)作為參數(shù)，這個函數(shù)內(nèi)部不應(yīng)該使用this。因為兩者回調(diào)的this，是指向window對象的。（內(nèi)層的this不指向外部，而是指向頂層對象）解決這種方法可以用中間變量，也可以將this當(dāng)作foreach方法的第二個參數(shù)，固定運(yùn)行環(huán)境。
JavaScript提供了call、apply、bind三個方法，來切換/固定this的指向。
函數(shù)實例的call方法，可以指定函數(shù)內(nèi)部this的指向（即函數(shù)執(zhí)行時所在的作用域），然后在所指定的作用域中，調(diào)用該函數(shù)。
call的第一個參數(shù)就是this所要指向的那個對象，后面餓參數(shù)則是函數(shù)調(diào)用時所需的函數(shù)。
apply方法的作用與call方法類似，也是改變this指向，然后再調(diào)用該函數(shù)。唯一的區(qū)別就是，它接收一個數(shù)組作為函數(shù)執(zhí)行時的參數(shù)。
如果兩個方法沒有參數(shù)，或者參數(shù)為null或undefined，則等同于指向全局對象。

let obj = {};
let f = function () {
    return this;
};
f() === window // true
f.call(obj) === obj // true

func.call(thisVlaue, arg1, arg2, ...)
func.apply(thisValue, [arg1, arg2, ...])
function f(x, y) {
    console.log(x + y);
}
f.call(null, 1, 1) //2
f.apply(null, [1, 1]) //2

// JS不提供找出數(shù)組最大元素的函數(shù)，結(jié)合apply方法和Math.max方法，就可以返回數(shù)組的最大元素
let a = [10, 2, 4, 15, 9];
Math.max.apply(null, a) // 15

bind方法用于將函數(shù)體內(nèi)的this綁定到某個對象，然后返回一個新函數(shù)。

let d = new Date();
d.getTime() // 1561974996108
let print = d.getTime; // 賦值后，內(nèi)部的this已經(jīng)不指向Date對象的實例了
print() // Uncaught TypeError: this is not a Date object.

// 使用bind
let print = d.getTime.bind(d);
print() // 1561974996108

空元素（null）與undefined的差別在于，數(shù)組的forEach方法會跳過空元素，但是不會跳過undefined。

對象的繼承
大部分面向?qū)ο蟮木幊陶Z言，都是通過“類（class）”實現(xiàn)對象的繼承。傳統(tǒng)上，JavaSCript語言的繼承不通過class，而是通過“原型對象（prototype）”實現(xiàn)。
構(gòu)造函數(shù)的缺點(diǎn)：同一個構(gòu)造函數(shù)的多個實例之間，無法共享屬性，從而造成對系統(tǒng)資源的浪費(fèi)。

function Cat(name, color) {
    this.name = name;
    this.color = color;
    this.meow = function () {
        console.log("喵喵");
    };
}
let cat1 = new Cat("大毛", "白色");
let cat2 = new Cat("二毛", "黑色");
cat1.meow === cat2.meow // false cat1和cat2是同一個構(gòu)造函數(shù)的兩個實例，它們都具有meow方法。由于meow方法是生成在每個實例對象上面的，所以兩個實例就生成了兩次，沒有必要，也浪費(fèi)了系統(tǒng)資源，需要共享，也就是JavaScript的原型對象（prototype）。

prototype屬性的作用
JavaScript繼承機(jī)制的涉及思想就是，原型對象的所有屬性和方法，都能被實例對象共享。也就是說，如果屬性和方法定義在原型上，那么所有實例對象就能共享，不僅節(jié)省了內(nèi)存，還體現(xiàn)了實例對象之間的聯(lián)系。（感覺像是Java類中的公共屬性和公共方法一樣。。。）
JavaScript規(guī)定，每個函數(shù)都有一個prototype屬性，指向一個對象。對于普通函數(shù)來說，該屬性基本無用，但是，對于構(gòu)造函數(shù)來說，生成實例的時候，該屬性會自動成為實例對象的原型。

function f() {}
typeof f.prototype // "object"

function Animal(name) {
    this.name = name;
}
Animal.prototype.color = "white"; // 原型對象上添加一個color屬性，下面的實例對象都共享了該屬性。
let cat1 = new Animal("大毛");
let cat2 = new Animal("二毛");
cat1.color // "white"
cat2.color // "white"
// 原型對象的屬性不是實例對象自身的屬性。只要修改原型對象，變動就立刻會體現(xiàn)在所有實例對象上
Animal.prototype.color = "yellow";
cat1.color // "yellow"
cat2.color // "yellow"
// 如果實例對象自身就有某個屬性或方法，它就不會再去原型對象尋找這個屬性或方法。
cat1.color = "black";
cat1.color // "black"
cat2.color // "yellow"

綜上，原型對象的作用，就是定義所有實例對象共享的屬性和方法，而實例對象可以視作從原型對象衍生出來的子對象。
原型鏈
JavaScript規(guī)定，所有對象都有自己的原型對象（prototype）。一方面，任何我一個對象，都可以充當(dāng)其他對象的原型；另一方面，由于原型對象也是對象，所以它也有自己的原型。因此，就會形成一個“原型鏈”（prototype chain）：對象到原型，再到原型的原型……如果一層層地上溯，所有對象的原型最終都可以上溯到Object.prototype，即Object構(gòu)造函數(shù)的prototype屬性。也就是說，所有對象都繼承了Object.prototype的屬性。這就是所有對象都有valueOf和toString方法的原因，因為這是從Object.prototype繼承的。
其實，Object.prototype對象也有他的原型，Object.prototype的原型是null。null沒有任何屬性和方法，也米有自己的原型。因此，原型鏈的盡頭就是null。

Object.getPrototypeOf(Object.prototype) // null

如果對象自身和它的原型，都定義了一個同名屬性，那么優(yōu)先讀取對象自身的屬性，這叫做“覆蓋”（overriding）。舉例來說，如果讓構(gòu)造函數(shù)的prototype屬性指向一個數(shù)組，就意味著實例對象可以調(diào)用數(shù)組方法。
constructor屬性
prototype對象有一個constructor屬性，默認(rèn)指向prototype對象所在的構(gòu)造函數(shù)。
constructor屬性的作用是，可以得知某個實例對象，到底是哪一個構(gòu)造函數(shù)產(chǎn)生的。

function P() {}
P.prototype.constructor === P // true constructor屬性定義在prototype對象上，意味著可以被所有實例對象繼承。

let p = new P();
p.constructor === P // true p是構(gòu)造函數(shù)P的實例對象
p.constructor === P.prototype.constructor // true
p.hasOwnPrototype("constructor") // false p自身沒有constructor屬性，該屬性是讀取原型鏈上面的P.prototype.constructor屬性

instanceof運(yùn)算符
instanceof運(yùn)算符返回一個布爾值，表示對象是否為某個構(gòu)造函數(shù)的實例。（左邊是實例對象，右邊是構(gòu)造函數(shù)。）

let v = new Vehicle();
v instanceof Vehicle // true 實際檢查右邊構(gòu)建函數(shù)的原型對象（prototype），是否在左邊對象的原型鏈上。
// 等同于
Vehicle.prototype.isPrototypeOf(v)

// instanceOf檢查的是整個原型鏈，因此同一個實例對象，可能會對多個構(gòu)造函數(shù)都返回true
let d = new Date();
d instanceof Date // true
d instanceof Object // true d同時是Date和Object的實例

// 任意對象（除了null）都是Object的實例，所以instanceof運(yùn)算符可以判斷一個值是否為非null的對象
typeof null // Object 是為了防止這種情況的發(fā)生
null instanceof Object // false

// 但是需要注意的是，instanceof運(yùn)算符只能用于對象，不適用原始類型的值
let s = "hello";
"s" instanceof String // false
new String("s") instanceof String // true

// 對于undefined和null，instanceof運(yùn)算符總是返回false
undefined instanceof Object // false
null instanceof Object // false

emm，對象的繼承中的模塊內(nèi)容還需要下狠功夫
Object對象的相關(guān)方法
Object.getPrototypeOf()方法返回參數(shù)對象的原型，這是獲取原型對象的標(biāo)準(zhǔn)方法。

let F = function () {};
let f = new F();
Object.getPrototypeOf(f) === F.prototype // true

// 特殊對象的原型
// 空對象的原型是 Object.prototype
Object.getPrototypeOf({}) === Object.prototype // true
// Object.prototype 的原型是 null
Object.getPrototypeOf(Objectprototype) === null // true
// 函數(shù)的原型是 Function.prototype
function f() {}
Object.getPrototypeOf(f) === Function.prototype // true

Object.create()可以從一個實例對象，生成另一個實例對象。該方法接受一個對象作為參數(shù)，然后以它為原型，返回一個實例對象，該實例完全繼承原型對象的屬性。

// 原型對象 沒有this，所以不是構(gòu)造函數(shù)！！！不能用new來創(chuàng)建，這是一個實例對象。
let A = {
    print: function () {
        console.log("hello");
    }
}
// 實例對象
let B = Object.create(A); // 相當(dāng)于創(chuàng)建一個空的構(gòu)造函數(shù)，將其.prototype屬性指向參數(shù)對象A，從而實現(xiàn)讓該實例繼承A的屬性。

Object.getPrototypeOf(B) === A // true 以A對象為原型，生成了B對象，B繼承了A的所有屬性和方法
B.print() // hello
B.print === A.print // true

// 以下三種方式生成的新對象是等價的
let obj1 = Object.create({});
let obj2 = Object.create(Object.prototype);
let obj3 = new Object();

//Object.create方法生成的新對象，動態(tài)繼承了原型。在原型上添加或修改任何方法，會立刻反映在新對象之上。
let obj1 = { p: 1 };
let obj2 = Object.create(obj1);
obj1.p = 2;
obj2.p // 2 修改對象原型obj1會影響到實例對象obj2
obj2.p = 3;
obj1.p // 1 修實例對象obj2并不會影響到原型對象obj1
obj2.p // 3

length用來截斷長度，只對數(shù)組有效，對字符串無效。
emm 面向?qū)ο蟮木幊桃彩窃评镬F里的，fighting！
異步操作概述
JavaScript只在一個線程上運(yùn)行，也就是說，JavaScript同時只能執(zhí)行一個任務(wù)，其他任務(wù)都必須在后面排隊等待。
程序里面所有的任務(wù)，可以分成兩類：同步任務(wù)（synchronous）和異步任務(wù)（asynchronous）。同步任務(wù)是那些沒有被引擎掛起、在主線程上排隊執(zhí)行的任務(wù)，只有前一個任務(wù)執(zhí)行完畢，才能執(zhí)行后一個任務(wù)。異步任務(wù)是那些被引擎放在一邊，不進(jìn)入主線程、而進(jìn)入任務(wù)隊列的任務(wù)，只有引擎認(rèn)為某個異步任務(wù)可以執(zhí)行了（比如Ajax操作從服務(wù)器得到了結(jié)果），該任務(wù)（采用回調(diào)函數(shù)的形式）才會進(jìn)入主線程執(zhí)行。也就是說，異步任務(wù)不具有“堵塞”效應(yīng)。
JavaScript運(yùn)行時，除了一個正在運(yùn)行的主線程，引擎還提供了一個任務(wù)隊列（task queue），里面是各種需要當(dāng)前程序處理的異步任務(wù)。（實際上，根據(jù)異步任務(wù)的類型，存在多個任務(wù)隊列。為了方便理解，這里假設(shè)只存在一個隊列。）
引擎如何確定異步任務(wù)有沒有結(jié)果，能不能進(jìn)入主線程呢？答案就是引擎在不停地檢查，一遍又一遍，只要同步任務(wù)執(zhí)行完了，引擎就會去檢查那些掛起來的異步任務(wù)，是不是可以進(jìn)入主線程了。這種循環(huán)檢查的機(jī)制，就叫做時間循環(huán)（Event Loop）。維基百科的定義是：“事件循環(huán)是一個程序結(jié)構(gòu)，用于等待和發(fā)送消息和事件”（a programming construct that waits for and dispatches events or messages in a program）。
異步操作的模式：
1、回調(diào)函數(shù) 回調(diào)函數(shù)是異步操作最基本的方法。（包括Promise）

function f1() {
    // ...
}
function f2() {
    // ...
}

f1();
f2(); // 這樣編程的意圖是f2必須等到f1執(zhí)行完成，才能執(zhí)行。
// 但是如果f1是異步操作，f2會立即執(zhí)行，不會等到f1結(jié)束再執(zhí)行。這種情況下，可以考慮改寫f1，把f2寫成f1的回調(diào)函數(shù)。
function f1(callback) {
    // ...
    callback();
}
function f2() {
    // ...
}
f1(f2); // 回調(diào)函數(shù)的優(yōu)點(diǎn)是簡單、容易理解和實現(xiàn)，缺點(diǎn)是不利于代碼的閱讀和維護(hù)，各個部分之間高度耦合（coupling），使得程序結(jié)構(gòu)混亂、流程難以追蹤（尤其是多個回調(diào)函數(shù)嵌套的情況），而且每個任務(wù)只能指定一個回調(diào)函數(shù)。

2、事件監(jiān)聽
以前只記著是定時器，現(xiàn)在才知道，應(yīng)該是事件監(jiān)聽！！！還是需要多看！！！
另一種思路是采用事件驅(qū)動模式。異步任務(wù)的執(zhí)行不取決于代碼的順序，而取決于某個事件是否發(fā)生。

f1.on("done", f2); // 當(dāng)f1發(fā)生done事件，就執(zhí)行f2。接著，對f1進(jìn)行改寫
function f1() {
    setTimeout(function () {
        // ...
        f1.trigger("done"); // 表示執(zhí)行完成后，立即觸發(fā)done事件，從而開始執(zhí)行f2
    }, 1000);
}

這種方法比較容易理解，可以綁定多個事件，每個事件可以指定多個回調(diào)函數(shù)，并且可以“去耦合”（decoupling），有利于實現(xiàn)模塊化。缺點(diǎn)是整個程序都要編程事件驅(qū)動型，運(yùn)行流程會變得很不清晰。閱讀代碼的時候，很難看出主流程。
3、發(fā)布/訂閱
事件完全可以理解成“信號”，如果存在一個“信號中心”，某個任務(wù)執(zhí)行完成，就向信號中心“發(fā)布”（publish）一個信號，其他任務(wù)可以向信號中心“訂閱”（subscribe）整個信號，從而知道什么時候自己可以開始執(zhí)行。這就叫做“發(fā)布/訂閱模式”（publish-subscribe parttern），又稱“觀察者模式”（observer pattern）。
觀察者模式還不是了解，還需要學(xué)習(xí)！！

定時器
JavaScript提供定時執(zhí)行代碼的能力，叫做定時器（timer），主要由setTimeout()和setInterval()這兩個函數(shù)來完成。
1、setTimeout()
該函數(shù)用來指定某個函數(shù)或某段代碼，再多少毫秒之后執(zhí)行。它返回一個整數(shù)，表示定時器的編號，以后可以用來取消這個定時器。
setTimeout函數(shù)接受兩個參數(shù)，第一個參數(shù)func|code是將要推遲執(zhí)行的函數(shù)名或者一段代碼，第二個參數(shù)是推遲執(zhí)行的毫秒數(shù)。

let timerId = setTimeout(func|code, delay);

console.log(1);
setTimeout("console.log(2)", 1000); // 需要注意的是，console.log(2)必須以字符串的形式，作為setTimeout的參數(shù)
console.log(3);
// 1
// 3
// 2

function f() {
    console.log(2);
}
setTimeout(f, 1000); // 如果推遲執(zhí)行的是函數(shù)，就直接將函數(shù)名，作為setTimeout的參數(shù)。

2、setInterval()
該函數(shù)的用法與setTimeout完全一樣，區(qū)別僅僅在于setInterval指定某個任務(wù)每隔一段時間就執(zhí)行一次，也就是無限次的定時執(zhí)行。

// 清除定時器
var id1 = setTimeout(f, 1000);
var id2 = setInterval(f, 1000);
clearTimeout(id1);
clearInterval(id2);

3、實例：debounce函數(shù)
debounce防抖動，這是個好東西，以后要好好看看！！感覺可以用到小程序以及h5的輸入框輸入！！
4、setTimeout(f, 0)
setTimeout的作用是將代碼推遲到指定時間執(zhí)行，如果指定時間為0，即setTimeout(f, 0),那么會立刻執(zhí)行嗎？答案是不會，因為它必須要等到當(dāng)前腳本的同步任務(wù)，全部處理完以后，才會執(zhí)行setTimeout指定的回調(diào)函數(shù)f。也就是說，setTimeout(f, 0)會在下一輪事件循環(huán)一開始就執(zhí)行。

setTimeout(function () {
    console.log(1);
}, 0);
console.log(2);
// 2
// 1

Promise對象
Promise對象是JavaScript的異步操作解決方案，為異步操作提供統(tǒng)一接口。它起到代理作用（proxy），充當(dāng)異步操作與回調(diào)函數(shù)之間的中介，使得異步操作具備同步操作的接口。
Promise對象的狀態(tài)：Promise對象通過自身的狀態(tài)，來控制異步操作。
Promise實例具有三種狀態(tài)：
1）異步操作未成功（pending）
2）異步操作成功（fulfilled）
3）異步操作失敗（rejected）
三種狀態(tài)里面，fulfilled和rejected合在一起稱為resolved（已定型）。
這三種狀態(tài)的變化途徑只有兩種：從“未完成”到“成功”；從“未完成”到“失敗”。
一旦狀態(tài)發(fā)生變化，就凝固了，不會再有新的狀態(tài)變化。這也是Promise這個名字的又來，它的英文意思是“承若”，一旦承諾成效，就不得再改變了。這也意味著，Promise實例的狀態(tài)變化只可能發(fā)生一次。因此，Promise的最終結(jié)果只有兩種：
1）異步操作成功，Promise實例傳回一個值（value），狀態(tài)變?yōu)閒ulfilled；
2）異步操作失敗，Promise實例拋出一個錯誤（error），狀態(tài)變?yōu)閞ejected。
JavaScript提供原生的Promise構(gòu)造函數(shù)，用來生成Promise實例。
Promise構(gòu)造函數(shù)接受一個函數(shù)作為參數(shù)，該函數(shù)的兩個參數(shù)分別是resolve和reject，它們是兩個函數(shù)，由JavaScript引擎提供，不用自己實現(xiàn)。
resolve函數(shù)的作用是，將Promise實例的狀態(tài)從“未完成”變?yōu)椤俺晒Α保磸膒ending變?yōu)閒ulfilled），在異步操作成功時調(diào)用，并將異步操作的結(jié)果，作為參數(shù)傳遞出去。
reject函數(shù)的作用是，將Promise實例的狀態(tài)從“未完成”變?yōu)椤笆　保磸膒ending變?yōu)閞ejected），在異步操作失敗時調(diào)用，并將異步操作報出的錯誤，作為參數(shù)傳遞出去。

DOM概述
DOM是JavaScript操作網(wǎng)頁的接口，全稱為“文檔對象模型”（Document Object Model）。它的作用是將網(wǎng)頁轉(zhuǎn)為一個JavaScript對象，從而可以用腳本進(jìn)行各種操作（比如增刪內(nèi)容）。
DOM的最小組成單位叫做節(jié)點(diǎn)（node）。文檔的屬性結(jié)構(gòu)（DOM樹），就是由各種不同類型的節(jié)點(diǎn)組成，每個節(jié)點(diǎn)可以看作是文檔樹的一片葉子。
節(jié)點(diǎn)的類型有七種：
Document：整個文檔樹的頂層節(jié)點(diǎn)
DocumentType：doctype標(biāo)簽（比如）
Element：網(wǎng)頁的各種HTML標(biāo)簽（比如、等）
Attribute：網(wǎng)頁元素的屬性（比如class="right"）
Text：標(biāo)簽之間或標(biāo)簽包含的文本
Comment：注釋
DocumentFragment：文檔的片段
瀏覽器提供一個原生的節(jié)點(diǎn)對象Node，上面這七種節(jié)點(diǎn)都繼承了Node，因此具有一些共同的屬性和方法。
emm 后面的看不下去了，再見!!!