1.弱范例言语

• 在JavaScript中，定义变量时没必要声明其范例。但这并不意味着变量没有范例。一个变量可以属于几种范例之一，这取决于其包含的数据。JavaScript中有三种原始范例：布尔型、数值型和字符串范例(不辨别整数和浮点数是JavaScript与大多数其他主流言语的一个差异之处)。别的，另有对象范例和包含可实行代码的函数范例，前者是一种复合数据范例(数组是一种特别的对象，它包含着一批值的有序鸠合)。末了，另有空范例(null)和未定义范例(undefined)这两种数据范例。原始数据范例按值传送，而其他数据范例则按援用传送。
• 与其他弱范例言语一样，JavaScript中的变量可以依据所赋的值转变范例。原始范例之间也可以举行范例转换。toString可以把数值或布尔值转为字符串。parseFloat和parseInt函数可以把字符串转变为数值。两重“非”可以把字符串或数值转变为布尔值：var bool = !!num;

2.初谈闭包

匿名函数最风趣的用途是用来建立闭包。闭包是一个遭到庇护的变量空间，由内嵌函数天生。JavaScript具有函数级的作用域。这意味着定义在函数内部的变量在函数外部不能被接见。JavaScript的作用域又是词法性子的。这意味着函数运转在定义它的作用域中，而不是在挪用它的作用域中。把这两个要素结合起来，就可以经由历程把变量包裹在匿名函数中而对其加以庇护。

3.依靠于接口的设想情势

下面列出的设想情势，特别依靠接口：

• 工场情势。对象工场所建立的详细对象会因详细状况而异。运用接口可以确保所建立出来的这些对象可以交换运用。也就是说，对象工场可以保证其临盆出来的对象都完成了必须的要领。
• 组合情势。如果不必接口你就不能够用这个情势。组合情势的中心思想在于可以将对象群体与其构成对象同等对待。这是经由历程让它们完成一样的接口来做到的。如果不举行某种情势的鸭式辨型或范例搜检，组合情势就会落空大部分作用。
• 装潢者情势。装潢者经由历程透明地为另一对象供应包装而发挥作用。这是经由历程完成与别的谁人对象完全雷同的接口而做到的。关于外界而言，一个装潢者和它所包装的对象看不出有什么区分。
• 敕令情势。代码中一切的敕令对象都要完成统一批要领。经由历程运用接口，你为实行这些敕令对象而建立的类可以没必要晓得这些对象详细是什么，只需晓得它们都完成了准确的接口即可。

4.用定名范例区分私用成员

在一些要领和属性的称号前面加下划线以示其私用性。下划线的这类用法是一个尽人皆知的定名范例，它表明一个属性(或要领)仅供对象内部运用，直接接见它或设置它能够会致使意想不到的结果。这有助于防备程序员对它的无意运用，却不能防备对它的故意运用。后一个目标的完成须要有真正私用性的要领。

5.作用域

下面这个示例说清楚明了JavaScript中作用域的特性：

function foo() {
    var a = 10;

    function bar() {
        a *= 2;
    }

    bar();
    return a;
}

在这个示例中，a定义在函数foo中，但函数bar可以接见它，由于bar也定义在foo中。bar在实行历程中将a设置为a乘以2。当bar在foo中被挪用时它可以接见a，这可以明白。然则如果bar是在foo外部被挪用呢？

function foo() {
    var a = 10;

    function bar() {
        a *= 2;
        return a;
    }

    return bar;
}

var baz = foo();
console.log(baz());//20
console.log(baz());//40
console.log(baz());//80

var blat = foo();
console.log(blat());//20

在上述代码中，所返回的对bar函数的援用被赋给变量baz。这个函数如今是在foo外部被挪用，但它依旧可以接见a。这是由于JavaScript的作用域是词法性的。函数是运转在定义它们的作用域中(本例中是foo内部的作用域)，而不是运转在挪用它们的作用域中。只需bar被定义在foo中，它就可以接见在foo中定义的一切变量，纵然foo的实行已完毕。
这就是闭包的一个例子。在foo返回后，它的作用域被保留下来，但只要它返回的谁人函数可以接见这个作用域。在前面的示例中，baz和blat各有这个作用域及a的一个副本，而且只要它们本身能对其举行修正。返回一个内嵌函数是建立闭包最经常使用的手腕。

6.用闭包完成私用成员的弊病

在流派翻开型对象建立情势中，一切要领都建立在原型对象中，因而不论派生若干对象实例，这些要领在内存中只存在一份。而包含特权要领、私用成员的建立情势中，每天生一个新的对象示例都将为每一个私用要领和特权要领天生一个新的副本。这会比其他做法消耗更多内存，所以只宜用在须要真正的私用成员的场所。这类对象建立情势也不利于派生子类，由于所派生出的子类不能接见超类的任何私用属性或要领。比拟之下，在大多数言语中，子类都能接见超类的一切私有属性和要领。故在JavaScript顶用闭包完成私用成员致使的派生题目称为“继续损坏封装”。

7.静态要领和属性

前面所讲的作用域和闭包的观点可用于建立静态成员，包含公用和私用的。大多数要领和属性所关联的是类的实例，而静态成员所关联的则是类本身。换句话说，静态成员是在累的条理上操纵，而不是在实例的条理上操纵。每一个静态成员都只要一份。稍后将会看到，静态成员是直接经由历程类对象接见的。

下面是增加了静态属性和要领的Book类：

var Book = (function () {

    //私有静态变量
    var numOfBooks = 0;

    //私有静态要领
    function checkIsbn(isbn) {

    }

    //返回一个构造器
    return function (newIsbn, newTitle, newAuthor) {
        //私有属性
        var isbn, title, author;

        //特权要领
        this.getIsbn = function () {
            return isbn;
        };
        this.setIsbn = function (newIsbn) {
            if (!checkIsbn(newIsbn)) {
                throw new Error('Book: Invalid ISBN.');
            }
            isbn = newIsbn;
        };
        this.getTitle = function () {
            return title;
        };
        this.setTitle = function (newTitle) {
            title = newTitle || "No title specified";
        };
        this.getAuthor = function () {
            return author;
        };
        this.setAuthor = function (newAuthor) {
            author = newAuthor || "No author specified";
        };

        //Constructed code.
        numOfBooks++;
        if (numOfBooks > 50) {
            throw new Error(".");
        }
        this.setIsbn(newIsbn);
        this.setTitle(newTitle);
        this.setAuthor(newAuthor);
    }
})();

//大众静态要领
Book.convertToTitleCase = function (inputString) {

};

//大众非特权要领
Book.prototype = {
    display: function () {

    }
};

这里的私用成员和特权成员依然被声明在构造器中(离别运用var和this关键字)。但哪一个构造器却从本来的平常函数变成了一个内嵌函数，而且被作为包含它的函数的返回值赋给变量Book。这就建立了一个闭包，你可以把静态的私用成员声明在里面。位于外层函数声明以后的一对空括号很重要，其作用是一段代码载入就马上实行这个函数(而不是在挪用Book构造函数时)。这个函数的返回值是另一个函数，它被赋给Book变量，Book因而成了一个构造函数。在实例化Book时，所挪用的是这个内层函数。外层谁人函数只是用于建立一个可以用来寄存静态私用成员的闭包。

• 在本例中，checkIsbn被设想为静态要领 ，原因是为Book的每一个实例都天生这个要领的一个新副本毫无道理。别的另有一个静态属性numOfBooks，其作用在于跟踪Book构造器的总挪用次数。本例运用这个属性将Book实例的个数限制为不凌驾50个。
• 这些私用的静态成员可以从构造器内部接见，这意味着一切私用函数和特权函数都能接见它们。与其他要领比拟，它们有一个显著的长处，那就是内存中只会寄存一份。由于个中那些静态要领被声明在构造器以外，所以它们不是特权要领，不能接见任何定义在构造器中的私用属性。定义在构造器中的私用要领可以挪用那些私用静态要领，反之则不然。要推断一个私用要领是不是应当被设想为静态要领，一条履历法则是看它是不是须要接见任何实例数据。如果它不须要，那末将其设想为静态要领会更有效力(从内存占用的意义上来讲)，由于它只会被建立一份。
• 建立公用的静态成员则轻易很多，只需直接将其作为构造函数这个对象的属性建马上可，前述代码中的要领converToTitleCase就是一例。这现实上相当于把构造器作为定名空间来运用。
• 一切公用静态要领如果作为自力的函数来声明实在也一样简朴，但最好照样像如许把相干行动集合在一同。这些要领用于与类这个团体相干的使命，而不是与类的任一特定实例相干的使命。它们并不直接依靠于对象实例中包含的任何数据。

8.私用变量模拟常量

经由历程建立只要取值器而没有赋值器的私用变量可以模拟常量。

var Class = (function () {
    var UPPER_BOUND = 100;

    //构造器
    var ctor = function (constructorArgument) {

    };
    //静态特权要领
    ctor.getUPPER_BOUND = function () {
        return UPPER_BOUND;
    };
    return ctor;

})();

9.封装之弊

• 私用要领很难举行单位测试。由于它们及其内部变量都是私用的，所以在对象外部没法接见到它们。这个题目没有什么很好的应对之策。你要么经由历程运用公用要领来供应接见门路(如许一来就葬送了运用私有要领所带来的大多数优点)，要么想法在对象内部定义并实行一切单位测试。最好的处置惩罚方法是只对公用要领举行单位测试。这应当能掩盖到一切私用要领，只管对它们的测试只是间接的。这类题目不是JavaScript所独占的，只对公用要领举行单位测试是一种广为吸收的处置惩罚体式格局。
• 运用封装意味着不得不与庞杂的作用域链打交道。
• 封装能够会损伤类的天真性，致使其没法被用于某些你不曾想到过的目标。

10.单体情势

单体情势是JavaScript中最基础但又最有效的情势之一，它能够比其他任何情势都更经常使用。这类情势供应了一种将代码构造为一个逻辑单位的手腕，这个逻辑单位中的代码可以经由历程单一的变量举行接见。经由历程确保单体对象只存在一份实例，你就可以够确信本身的一切代码运用的都是一样的全局资本。

单体类在JavaScript中有很多用途。它们可以用来分别定名空间，以削减网页中全局变量的数目。更重要的是，借助于单体情势，你可以把代码构造得更加一致，从而使其更轻易浏览和保护。

11.单体的基础构造

var Singleton = {
    attribute1: true,
    attribute2: 10,
    method1: function () {

    },
    method2: function (args) {

    }
};

• 这个单体对象可以被修正。你可认为其增加新成员，这一点与别的对象字面量没有什么差异。你也可以用delete运算符删除其现有成员。这现实上违犯了面向对象设想的一条准绳：类可以被扩大，但不应当被修正。
• 按传统的定义，单体是一个只能被实例化一次而且可以经由历程一个尽人皆知的接见点接见的类。如果严厉根据这个定义来讲，前面的例子所示的并非一个单体，由于它不是一个可实例化的类。我们盘算把单体情势定义的更广义一些：单体是一个用来分别定名空间并将一批相干要领和属性构造在一同的对象，如果可以被实例化，那末它只能被实例化一次。

12.分别定名空间

为了防止无意中改写变量，最好的处置惩罚方法之一是用单体对象将代码构造在定名空间当中。下面是前面的例子用单体情势改进后的结果：

var MyNamespace = {
    findProduct: function (id) {

    }
};

如今findProduct函数是MyNamespace中的一个要领，它不会被全局定名空间中声明的任何新变量改写。要注意，该要领依然可以从各个处所接见。差异之处在于如今其挪用体式格局不是findProduct(id)，而是MyNamespace.findProduct(id)。另有一个优点就是，这可以让其他程序员大致晓得这个要领的声明所在及其作用。用定名空间把相似的要领构造到一同，也有助于加强代码的文档性。

13.模块情势

有一种单体情势被称为模块情势，由于它可以把一批相干要领和属性构造为模块并起到分别定名空间的作用。比方：

MyNamespace.Singleton = (function () {
    //私有成员
    var privateAttribute1 = false;
    var privateAttribute2 = [1, 2, 3];

    function privateMethod1() {

    }

    function privateMethod2() {

    }

    return {
        //public members
        publicAttribute1: true,
        publicAttribute2: 10,
        publicMethod1: function () {

        },
        publicMethod2: function (args) {

        }
    }
})();

14.简朴工场情势

最好用一个例子来讲明简朴工场情势的观点。假定你想开几个自行车市肆，每一个店都有几种型号的自行车出卖。这可以用一个类来示意：

/*BicycleShop class.*/
var BicycleShop = function () {

};

BicycleShop.prototype = {
    sellBicycle: function (model) {
        var bicycle;
        switch (model) {
            case "The Speedster":
                bicycle = new SpeedSter();
                break;
            case "The Lowrider":
                bicycle = new Lowrider();
                break;
            case "The Comfort Cruiser":
            default:
                bicycle = new ComfortCruiser();
        }
        Interface.ensureImplements(bicycle, Bicycle);
        bicycle.assemble();
        bicycle.wash();
        return bicycle;
    }
};

sellBicycle要领依据所要求的自行车型号用switch语句建立一个自行车的实例。各种型号的自行车实例可以交换运用，由于它们都完成了Bicycle接口：

/* The Bicycle interface. */
var Bicycle = new Interface('Bicycle', ['assemble', 'wash', 'ride', 'repair']);

/* Speedster class. */
var Speedster = function () {

};
Speedster.prototype = {
    assemble: function () {
    },
    wash: function () {
    },
    ride: function () {
    },
    repair: function () {
    }
};

要出卖某种型号的自行车，只需挪用sellBicycle要领即可：

var californiaCruisers = new BicycleShop();
var yourNewBike = californiaCruisers.sellBicycle("The Speedster");

在状况发作变化之前，这倒也挺管用。但如果你想在供货目次中到场一款新车型又会怎样呢？你得为此修正BicycleShop的代码，哪怕这个类的现实功用现实上并没有发作转变——依旧是建立一个自行车的新实例，组装它，洗濯它，然后把它交给主顾。更好的处置惩罚方法是把sellBicycle要领中“建立新实例”这部分事情转交给一个简朴工场对象：

/* BicycleFactory namespace. */
var BicycleFactory = {
    createBicycle:function(model){
        var bicycle;
        switch (model) {
            case "The Speedster":
                bicycle = new SpeedSter();
                break;
            case "The Lowrider":
                bicycle = new Lowrider();
                break;
            case "The Comfort Cruiser":
            default:
                bicycle = new ComfortCruiser();
        }
        Interface.ensureImplements(bicycle, Bicycle);
        return bicycle;
    }
};

BicycleFactory是一个单体，用来把createBicycle要领封装在一个定名空间中。这个要领返回一个完成了Bicycle接口的对象，然后你可以照旧对其举行组装和洗濯：

/* BicycleShop class, improved. */
var BicycleShop = function () {
};
BicycleShop.prototype = {
    sellBicycle: function (model) {
        var bicycle = BicycleFactory.createBicycle(model);
        bicycle.assemble();
        bicycle.wash();
        return bicycle;
    }
};

这个BicycleFactory对象可以供种品种用来建立新的自行车实例。有关可供车型的一切信息集合在一个处所治理 ，所以增加更多车型很轻易：

/* BicycleFactory namespace,with more models. */
var BicycleFactory = {
    createBicycle: function (model) {
        var bicycle;
        switch (model) {
            case "The Speedster":
                bicycle = new SpeedSter();
                break;
            case "The Lowrider":
                bicycle = new Lowrider();
                break;
            case "The Flatlander":
                bicycle = new Flatlander();
                break;
            case "The Comfort Cruiser":
            default:
                bicycle = new ComfortCruiser();
        }
        Interface.ensureImplements(bicycle, Bicycle);
        return bicycle;
    }
};

15.工场情势

真正的工场情势与简朴工场情势的区分在于，它不是别的运用一个类或对象来建立自行车，而是运用一个子类。根据正式定义，工场是一个将其成员对象的实例化推晚到子类中举行的类。

16.工场情势的实用场所

• 动态完成：如果须要建立一些用差异体式格局完成统一接口的对象，那末可以运用一个工场要领或简朴工场对象来简化挑选完成的历程。
• 节约设置开支：如果对象须要举行庞杂而且相互相干的设置，那末运用工场情势可以削减每种对象所需的代码量。如果这类设置只须要为特定范例的一切实例实行一次即可，这类作用尤其凸起。把这类设置代码放到类的构造函数中并非一种高效的做法，这是由于即使设置事情已完成，每次建立新实例的时刻这些代码照样会实行，而且如许做会把设置代码疏散到差异的类中。工场要领异常适合于这类场所。它可以在实例化一切须要的对象之前先一次性地举行设置。不管有若干类会被实例化，这类方法都可以让设置代码集合在一个处所。
• 用很多小型对象构成一个大对象

17.工场情势之利

• 工场情势的重要优点在于消弭对象间的耦合。经由历程运用工场要领而不是new关键字及详细类，你可以把一切实例化的代码集合在一个位置。这可以大大简化替换所用的类或在运转时期动态挑选所用的类的事情。在派生子类时它也供应了更壮大的天真性。
• 一切这些优点都与面向对象设想的这两条准绳有关：弱化对象间的耦合；防备代码的反复。在一个要领中举行类的实例化，可以消弭反复性的代码。这是在用一个对接口的挪用庖代一个详细的完成。这些都有助于建立模块化的代码。

18.桥接情势

桥接情势最罕见和现实的运用场所之一就是事件监听器回调函数。假定有一个名为getBeerById的API函数，它依据一个标识符返回有关某种啤酒的信息。你愿望用户在点击的时刻猎取这类信息。谁人被点击的元素很能够有啤酒的标识符信息，它多是作为元素本身的ID保留，也多是作为别的自定义属性保留。下面是一种做法：

addEvent(element, 'click', getBeerById);
function getBeerById(e) {
    var id = this.id;
    asyncRequest('GET', 'beer.uri?id=' + id, function (resp) {
        console.log(resp.responseText);
    });
}

这个API只能事情在浏览器中，如果要对这个API函数做单位测试，或许在敕令行中实行，能够会报错。一个优秀的API设想，不应当把它与任何特定的完成搅在一同。

function getBeerById(id, callback) {
    asyncRequest('GET', 'beer.uri?id=' + id, function (resp) {
        callback(resp.responseText);
    })
}

如今我们将针对接口而不是完成举行编程，用桥接情势把笼统断绝开来：

addEvent(element, 'click', getBeerByIdBridge);
function getBeerBIdBridge(e) {
    getBeerById(this.id, function (beer) {
        console.log(beer);
    });
}

这下getBeerById并没有和事件对象绑缚在一同了。

19.用桥接情势联络多个类

var Class1 = function (a, b, c) {
    this.a = a;
    this.b = b;
    this.c = c;
};
var Class2 = function (d) {
    this.d = d;
};
var BridgeClass = function (a, b, c, d) {
    this.one = new Class1(a, b, c);
    this.two = new Class2(d);
};

20.适配器情势

适配器情势可以用来在现有接口和不兼容的类之间举行适配。运用这类情势的对象又叫包装器，由于它们是在用一个新的接口包装另一个对象。

21.适配器的特性

• 适配器可以被增加到现有代码中以谐和两个差异的接口。如果现有代码的接口能很好地满足须要，那就能够没有必要运用适配器。
• 从表面上看，适配器情势很像门面情势。它们都要对别的对象举行包装并转变其显现的接口。两者的差异在于它们怎样转变接口。门面元素展示的是一个简化的接口，它并不供应分外的挑选，而且偶然为了轻易完成某些罕见使命它还会做出一些假定。而适配器则要把一个接口转换为另一个接口，它并不会滤除某些才能，也不会简化接口。如果客户体系期待的API不可用，那就须要用到适配器。
• 适配器可被完成为不兼容的要领挪用之间的一个代码薄层。
• 示例：
• 如果你有一个对象另有一个以三个字符串为参数的函数：

    var clientObject = {
        string1: "foo",
        string2: "bar",
        string3: "baz"
    };
    function interfaceMethod(str1, str2, str3) {

    }

为了把clientObject作为参数通报给interfaceMethod，须要用到适配器。我们可以如许建立一个：

function clientToInterfaceAdapter(o) {
    interfaceMethod(o.string1, o.string2, o.string3);
}
//如今就可以够把全部对象传给这个函数
clientToInterfaceAdapter(clientObject);

clientToInterfaceAdapter函数的作用就在于对interfaceMethod函数举行包装，并把通报给它的参数转换给后者须要的情势。

22.装潢者情势

装潢者情势可用来透明地把对象包装在具有一样接口的另一对象中。如许一来，你可以给一个要领增加一些行动，然后将要领挪用通报给原始对象。相干于建立子类来讲，运用装潢者对象是一种更天真的挑选。

23.享元情势

享元情势最适合于处置惩罚因建立大批相似对象而累及的机能题目。这类情势在JavaScript中特别有效，由于庞杂的JavaScript代码能够很快就会用光浏览器的一切可用内存。经由历程把大批自力对象转化为少许同享对象，可以下降运转Web运用程序所需的资本数目。

享元情势用于削减运用程序所需对象的数目。这是经由历程将对象的内部状况分别为内涵数据和外在数据两类而完成的。内涵数据是指类的内部要领所需的信息，没有这类数据的话类不能平常运转。外在数据则是可以从类身上剥离并存储在其外部的信息。我们可以将内涵状况雷同的一切对象替换为统一个同享对象，这类要领可以把对象数目削减到差异内涵状况的数目。

24.完成享元情势的平常步骤

1. 将一切外在数据从目标剥离。详细做法是尽量多地删除该类的属性，所删除的应当是那种因实例而异的属性。构造函数的参数也要如许处置惩罚。这些参数应当被增加到该类的各个要领。这些外在数据如今不再保留在类的内部，而是由治理器供应给类的要领。经由如许的处置惩罚后，目标类应当依旧具有与之前一样的功用。唯一的区分在于数据的泉源发作了变化。
2. 建立一个用来控制该类的实例化的工场。这个工场应当控制该类一切已建立出来的举世无双的实例。其详细做法之一是用一个对象字面量来保留每一个这类对象的援用，并以用来天生这些对象的参数的唯一性组合作为它们的索引。如许一来，每次要求工场供应一个对象时，它会先搜检谁人对象字面量，看看之前是不是要求过这个对象。如果是，那末只需返回谁人现有对象的援用就行。不然它会建立一个新对象并将其援用保留在谁人对象字面量中，然后返回这个对象。另一种做法称为对象池，这类手艺用数组来保留所建立的对象的援用。它适合于注意可用对象的数目而不是那些零丁设置的实例的场所。这类手艺可用来将所实例化的对象的数目维持在最低值。工场会处置惩罚依据内涵数据建立对象的一切事件。
3. 建立一个用来保留外在数据的治理器。该治理器对象担任控制处置惩罚外在数据的各种事件。在实行优化之前，如果须要一个目标类的实例，你会把一切数据传给构造函数以建立其新实例。而如今如果须要一个实例，你会挪用治理器的某个要领，把一切数据都供应给它。这个要领会区分内涵数据和外在数据。它把内涵数据供应给工场对象以建立一个对象(或许，如果已存在如许一个对象的话，则重用该对象)。外在数据则被保留在治理器内的一个数据构造中。治理器随后会依据须要将这些数据供应给同享对象的要领，其结果就犹如该类有很多实例一样。

25.观察者情势

• 在事件驱动的环境中，比方浏览器这类延续追求用户关注的环境中，观察者情势(别名发布者-定阅者情势)是一种治理人与其使命之间的关联(确切的说，是对象及其行动和状况之间的关联)的得力东西。
• 观察者情势中存在两个角色：观察者和被观察者。