面向对象的顺序设计

ECMA-262定义对象：无序属性的鸠合，其属性可以包含基础值，对象或许函数。
平常明白：对象是一组没有特定递次的值。
对象的每一个属性或要领都有一个名字，而每一个名字都映照一个值。

每一个对象都是基于一个援用范例建立的。

明白对象

属性范例

在定义只需内部的特征(attribute)时，形貌了属性(property)的种种特征。
是为了完成JavaScript引擎用的，在JavaScript中不能直接接见他们。
为了示意特征是内部值，把它们放在了两对方括号中. 比方: [[Enumerable]]

ECMAScript中有两种属性：数据属性和接见器属性。

数据属性

数据属性包含一个数据值的位置。在这个位置可以读取和写入值。数据属性有4个形貌行动的特征

• [[Configurable]]: 可否经由历程delete删除属性从而从新定义属性，可以修正属性的特征，或许可否把属性修正为接见属性。 默许值：false;(不可以从新定义或删除)
• [[Enmuerable]]: 可以经由历程for-in轮回返回属性。(是不是可以被罗列).默许值：false;(不可以被罗列)
• [[Writable]]： 可否修正属性的值。默许值：false,(不可以被修正)
• [[Value]]：包含这个属性的数据值，读取属性的时刻，从这个位置读；写入属性值的时刻，把新值保存在这个位置。默许值：undefiend.

var Person = {
    name: 'Nicholas'
}

// 建立name属性。为它置顶的值是“Nicholas”。也就是[[Value]]被设置了"Nicholas",而对这个值的任何修正都将回响反映在这个位置。

Object.defineOProperty();
作用：修正属性默许特征
参数1：属性地点的对象
参数2：属性的名字
参数3：一个形貌符对象
形貌符(descriptor)对象的属性必需是：configurable,enumerable,writable,value.
设置个中一个或多个值，可以修正对应的特征值。

var Person = {};
Object.defineProperty(Person, "name", {
    writable: false,
    value: "Nicholas"
});

alert(Person.name); //"Nicholas"
Person.name = "Greg"; // 设置成只读的，属性是不可修正的。
alert(Person.name); //"Nicholas" 

constructor属性,是没法被罗列的. 平常的for-in轮回是没法罗列. [eable = false];

Object.getOwnPropertyNames(); //罗列对象一切的属性：不论该内部属性可以被罗列.

//3个参数，  参数1：从新设置构造的对象 （给什么对象设置）     参数2：设置什么属性        参数3：options设置项 (要怎样去设置)
Object.defineProperty(Person.prototype,'constructor',{
    enumerable: false,  //是不是是 可以 被罗列
    value: Person  //值   构造器的 援用
});

接见器属性

接见器属性不包含数据值，包含一堆geter() 和setter(); 函数 (这两个函数都不是必需的)

在读取接见器属性时，会挪用getter(); 这个函数担任返回有用值，在写入接见器属性时，会挪用setter()函数并传入新值，这个函数担任决议怎样处置惩罚数据。

接见器属性的4个特征：

• [[Configurable]]: 可以经由历程delete删除属性从而定义新的属性，可否修正属性的特征，或许可否把属性修正为数据属性。默许值：false; （不可从新定义，和删除属性）
• [[Enmuerable]]:可否经由历程for-in轮回返回属性。默许值：false；（不可被罗列）
• [[Get]]: 在读取属性时挪用的函数。默许值为：undefeind
• [[Set]]: 在写入属性时挪用的函数。默许值为:undefiend

接见器属性不能直接定义，必需运用Object.defineProperty();来定义。

var book = {
    _year: 2016,
    edition: 1
};
Object.defineProperty(book, "year", {
    get: function(){
        return this._year;
    },
    set: function(newValue){
        if (newValue > 2016) {
            this._year = newValue;
            this.edition += newValue - 2016;
        }
    }
});

book.year = 2020;
alert(book.edition); // 5

// _year前面的下划线是一种经常使用的暗号，用于示意只能经由历程对象要领接见的属性。

定义多个属性

Object.defineProperties();
定义多个属性。
参数1：对象要增添和修正其属性的对象
参数2：对象的属性与第一个对象中要增添或修正的属性一一对应.

var book = {};

Object.defineProperties(book, {
    _year: {
        value: 2016
    },
    edition: {
        value: 1
    },
    year: {
        get: function () {
            return this._year;
        },
        set: function (newValue) {
            this._year = newValue;
        }
    }
});

读取属性的特征
Object.getOwnPropertyDescriptor()
取得给定属性的形貌符.
参数1：属性地点的对象
参数2：要读取其形貌符的属性称号
返回值：对象。假如是接见器属性，这个对象含有：configurable,enumerable,get和set
假如是数据属性，这个对象含有：configureable，enumerbale，writeable，value

建立对象

工场情势
处理：建立多个相似对象。(未处理：对象辨认的题目-怎样晓得一个对象的范例)

function createPerson(name, age, job){

    var o = new Object();

    o.name = name;
    o.age = age;
    o.job = job;
    
    o.sayName = function(){
        alert(this.name);
    };

    return o;
}

var person1 = createPerson("Nicholas", 29, "Software Engineer");
var person2 = createPerson("Greg", 27, "Doctor");

构造函数情势

function Person(name, age, job){

    this.name = name;
    this.age = age;
    this.job = job;

    this.sayName = function(){
        alert(this.name);
    };
    
}

var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");

• 没有显现的建立对象
• 直接将属性和要领赋给this对象
• 没有reutrn语句

建立实例会经由：

1. 建立一个对象
2. 将构造函数的作用域赋给新对象(因而this就指向了这个新对象)
3. 实行构造函数中的代码(为这个新对象增添属性)
4. 返回新对象

对象的 constructor 属性最初是用来示意对象范例。
提到检测对象范例，照样运用instanceof操纵符要更牢靠。

将构造函数看成函数

构造函数与别的函数的唯一区分，在于挪用它们的体式格局差异。
构造函数也是函数，不存在定义构造函数的语法。任何函数，只需经由历程new操纵来挪用，就可以作为构造函数。
任何函数，假如不经由历程new操纵符来挪用，就跟平常函数没什么差异。

构造函数的题目

每一个要领都要在每一个实例上从新建立

经由历程原型情势来处理

原型情势
每一个函数都有一个 prototype （原型）属性，这个属性是一个指针，指向一个对象，
而这个对象的用途是包含可以由特定范例的一切实例同享的属性和要领

每一个函数都有一个prototype(原型)属性，这个属性石一个指针，指向一个对象，而这个对象的用途是包含可以由特定范例的一切实例同享的属性和要领。

字面的明白：prototype就是经由历程挪用构造函数而建立的谁人对象实例的原型。
让一切对象实例同享它一切包含的属性和要领。没必要在构造函数中定义对象实例的信息，而是将这些信息直接增添到原型中。

明白原型对象

只需建立了一个函数，就会依据一组特定的规则为该函数建立一个prototype属性，这个属性指向函数的原型对象。

默许状况下：一切原型对象都邑自动取得一个constructor(构造函数)属性，这个属性包含一个指向prototype属性地点函数的指针。

建立了自定义的构造函数以后，其原型对象默许只会取得constructor属性。

当挪用构造函数建立一个新实例后，该实例的内部将包含一个指针(内部属性)，指向构造函数的原型对象。

原型链查找：
每当代码读取某个对象的某个属性时，都邑实行一次搜刮，目标是具有给定名字的属性。搜刮起首从对象实例本身最先。假如在实例中找到了具有给定名字的属性，则返回该属性的值，假如没有找到，则继续搜刮指针指向的原型对象，在原型对象中查找具有给定名字的属性。假如在原型对戏谁人中找到这属性，则返回该属性的值。

可以经由历程对象实例接见保存在原型中的值，但却不能经由历程对象实例重写原型中的值，假如在实例中增添了一个属性，而该属性与实例原型中的一个属性同名，那在实例中建立该属性，该属性将会屏障原型中的谁人属性。

function Person(){
}

Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";

Person.prototype.sayName = function(){
    alert(this.name);
};

var person1 = new Person();
var person2 = new Person();

person1.name = "Greg";

alert(person1.name); //"Greg" —— 来自实例的name

alert(person2.name); //"Nicholas" -- 来自原型中的name

当为对象实例增添一个属性时，这个属性就会屏障原型对象中保存的同名属性。增添这个属性只会构造接见原型中的谁人属性，但不会修正谁人属性。纵然将这个属性设置为null，也只会在实例中设置这个属性，而不会恢复其指向原型的衔接。可以运用delete操纵符可以完全删除实例属性。

hasOwnProperty() // 从Object继续而来的要领
检测一个属性是不是存在于实例中，照样存在于原型。
推断一个对象属性 是属于 原型属性 照样属于 实例属性
在实例中，返回true
在原型上，返回false

function Person() {}

Person.prototype.name = 'Nicholas';

var p1 = new Person();
console.log(p1.hasOwnProperty('name')); // false

原型与in操纵符
in 操纵符，经由历程对象可以接见给定属性时返回true，不管是在实例中照样原型中。可以接见到，就返回true.

同时运用hasOwnProperty(); 和 in操纵符 : 肯定是属性存在实例中，照样原型中。

// 推断属于原型上的属性
function hasPrototypeProperty( obj, attr ) {
    return !obj.hasOwnProperty(attr) && attr in obj;
}

Object.keys()
参数：吸收一个对象作为参数，返回一个包含一切可罗列的属性的字符串数组。

function Person() {}

Person.prototype.name = 'Nicholas';
Person.prototype.age = 20;

var p1 = new Person();

var keys = Object.keys(Person.prototype);

console.log(keys); // ["name", "age"]

更简朴的原型要领

function Person() {}
Person.prototype = {}

将Person.prototype设置为等于一个对象字面量情势建立的新对象。
会形成constructro属性不再指向Person。
每建立一个函数，就会同时建立它的peorotype，这个对象也会自动取得constructro属性。直接赋值为一个字面量情势，实质上是完全重写了默许的prottoype对象，因而constructor属性也就变成新的对象的constructor属性(指向Object构造函数) 不再指向Person函数。
经由历程instanceof操纵符可以返回准确的结果，然则经由历程constructor已没法肯定对象的范例了。

可以手动设置回constructor属性为当前的类

function Person () {}

Person.prototype = {
    constructor: Person,
    name: 'Nicholas'
}

这类体式格局重设constructor属性会致使它的[[Enumerable]]特征被设置为true

constructor是不可被罗列，可以经由历程Object.definePropert();修正特征，重置构造函数。

Object.defineProperty(Person.protype, 'constructor', function () {
    enmuerable:  false,
    value: Person
});

原型动态
由于在原型中查找值的历程是一次搜刮，对原型对象所做的任何修正都可以马上从实例上回响反映出来，纵然是先建立了实例后修正原型也是一样。

实例中的指针仅指向原型，而不指向构造函数。

可以随时为原型增添属性和要领，而且修正可以马上在一切对象实例中回响反映出来，但假如是重写了这个原型对象，那末就不一样。
挪用构造函数时会为实例增添一个指向最初原型的[[Prototype]] 或许__proto__ .而把原型修正为别的一个对象就等于割断了构造函数与最初原型之间的联络。

function Person () {}

var firend = new Person();

Person.prototype = {
    constructor: Person,
    name: 'Nicholas',
    sayName: function () {
        console.log(this.name);
    }
}

firend.sayName(); // error //  friend 指向的原型中不包含以该名字定名的属性

原生对象的原型
原型情势的表如今建立自定义范例方面，一切的原生的援用范例，都是采纳这类情势建立的。
一切元素援用范例(Object,Array,String…)都在其构造函数上定义了要领

经由历程原生对象的原型，不仅可以取得一切默许要领的援用，而且也可以定义新的要领。

console.log( typeof Array.prototype.slice ); // function

不发起如许运用，会致使定名争执，也能够不测的重写原生的要领。

原型对象的题目

原型情势省略了为构造函数通报参数初始化的，形成一切实例默许状况下都将取得雷同的属性值。
原型情势最大的题目是由其同享的本性所致使。

关于包含援用范例的原型对象，假如修正其值，那末另个实例也会修正。

function Person () {}

Person.prototype = {
    constructor: Person,
    name: 'Nicholas',
    friends: ['Shelby', 'Court']
}

var p1 = new Person();
var p2 = new Person();

p1.friends.push('Van');

console.log(p1.friends);  // ["Shelby", "Court", "Van"]
console.log(p1.friends);  // ["Shelby", "Court", "Van"]

实例平常都要有属性本身的悉数属性。这个题目形成很少会零丁运用原型情势。

组合运用构造函数情势和原型情势
构造函数情势：用于定义实例的属性
原型情势：用于定义要领和同享的属性。

结果：每一个实例都邑有本身的一份实例属性的副本，但同时又同享这对要领的援用，最大限制的节约内存，同时还支撑向构造函数通报参数。

是如今在ECMAScript中运用最普遍，认同度最高的一种建立自定义范例的要领。是用来定义援用范例的一种默许情势。

动态原型情势
把信息都封装到函数中，如许表现了封装的观点。

经由历程在构造函数中初始化原型(仅在必要状况下)，同时坚持了同时运用构造函数和原型的长处。
可以经由历程搜检默许应当存在的要领是不是有用，来决议是不是须要初始化运原型。

//动态原型情势：（让你的代码  都封装到一同）
function Person( name,age,firends ) {
    
    this.name = name;
    this.age = age;
    this.firends = firends;
    
    //动态原型要领
    if ( typeof this.sayName !== 'function'  ) {
        
        Person.prototype.sayName = function () {
            console.log(this.name);
        }
        
    }
    
}

sayName()要领不存在的状况下，才会将它增添到原型中if语句中的代码只会在首次挪用构造函数时才会实行。今后，原型已完成初始化，不须要再做什么修正。这边的原型所做的修正，可以明白在一切实例中获得回响反映。
if语句的搜检可所以初始化以后应当存在的任何属性或要领—没必要用一大堆if语句搜检每一个属性和每一个要领。只需搜检个中一个即可。

采这类情势建立的对象，还可以运用instanceof操纵符肯定它的范例。
运用动态原型情势时，不能运用对象字面量重写原型。假如在已建立了实例的状况下重写原型，就会割断现有实例与新原型之间的联络。

寄生构函数情势
建立一个函数，该函数的作用仅仅是封装建立对象的代码，然后再返回新建立的对象。
在工场情势，组合运用构造函数情势和原型情势，都不能运用的状况下，运用。
这个情势与工场情势是相似的，构造函数在不返回值的状况下，默许会返回新对象的实例。而在构造函数末端增添一个return语句，可以重写挪用构造函数时返回出来的值。

function Person ( name ) {
    var o = new Object();
    o.name = name;
    o.sayName = function () {

        console.log(this.name);

    }
    return o;
}


var friend = new Person('Van');
friend.sayName();

寄生构造函数情势，起首，返回的对象与构造函数或许与构造函数的原型属性之间没有关联。
构造函数返回的对象与在构造函数外部建立的对象没有什么差异，为此，不恩呢该依靠 instanceof操纵符来肯定对象范例。

平常来说，不可经由历程prototype修正原生对象的要领。可以运用寄生构造函数情势，到达迥殊需求。

稳妥构造函数情势

稳妥情势就是没有大众属性，而且其他要领也不援用this对象，稳妥情势最合适在平安的环境中运用。假如顺序关于平安性要求很高，那末异常合适这类情势。
也不能运用new关键字。

//稳妥构造函数式  durable object (稳妥对象)
//1，没有大众的属性
//2,不能运用this对象

function Person ( name,age ) {
    
    //建立一个要返回的对象。  运用工场情势头脑。
    var obj = new Object();
    
    //可以定义一下是有的变量和函数 private
    
    var name = name || 'zf';
    
//                        var sex = '女';
//                        var sayName = function () {
//                        }

        
    //增添一个对外的要领
    obj.sayName = function () {
        console.log(name);
    }
    
    return obj;
    
}

var p1 = Person('xixi',20);

p1.sayName();    

继续

很多OO言语横纵都支撑两种继续体式格局：接口继续 和完成继续。
接口继续：只继续要领署名
完成继续：继续现实的要领。

由于函数中没有署名，在ECMAScript中没法完成接口继续，ECAMScript 只支撑完成继续，而其完成继续主要原型链来完成。

原型链

基础思想：让一个援用范例继续另一个援用范例的属性和要领。

让原型对象等于另一个范例的实例，此时的原型对象将包含一个指向另一个原型的指针，响应的，另一个原型中也包含指向另一个构造函数的指针。

完成的实质是重写原型对象，代之以一个新范例的实例

function SuperType () {
    this.property = true;
}

SuperType.prototype.getSuperValue = function () {
    return this.property;
}

function SubType () {
    this.subproperty = false;
}

// 继续了SuperType
SubType.prototype = new SuperType();

SubType.prototype.getSubValue = function () {
    return this.subproperty;
}

var instance = new SubType();

console.log( instance.getSuperValue() ); // true

挪用 instance.getSuperValue()会阅历三个步骤：
1：搜刮实例
2：搜刮SubType.prototype
3：搜刮SuperTpe.prototype

别忘记默许的原型

一切函数的原型都是Object的实例，因而默许原型都邑包含一个内部指针，指向Object.prototype

肯定原型和实例的关联

可以经由历程两种体式格局来肯定原型和实例之间的关联。第一种体式格局是运用 instanceof 操纵符，只需用
这个操纵符来测试实例与原型链中涌现过的构造函数，结果就会返回 true 。

体式格局1：运用instanceof操纵符。 测试实例与原型链中涌现的构造函数，就会返回true。

alert(instance instanceof Object); //true
alert(instance instanceof SuperType); //true
alert(instance instanceof SubType); //true

体式格局2：运用isPrototypeOf(); 是原型链中涌现过的原型，都可以说是该原型链所派生的实例的原型。就会返回true。

alert(Object.prototype.isPrototypeOf(instance)); //true
alert(SuperType.prototype.isPrototypeOf(instance)); //true
alert(SubType.prototype.isPrototypeOf(instance)); //true

郑重地定义要领

子范例有时刻须要重写超范例中的某个要领，或许须要增添超范例中不存在的某个要领。

给原型增添要领的代码肯定要放在替代原型的语句以后。

即在经由历程原型链完成继续时，不能运用对象字面量建立原型要领。由于这
样做就会重写原型链，

即在经由历程原型链完成继续时，不能运用对象字面量建立原型要领。如许会重写原型链。致使替代原型无效。

原型链的题目

原型链可以完成继续，然则存在一些题目：包含援用范例的原型。
经由历程原型来完成继续时，原型现实上会变成另一个范例的实例。因而，本来的实例属性也就变成了如今的原型属性了。

在构造函数中，而不是原型对象中定义属性的缘由：包含援用范例的原型属性会被实例所同享。

第二个题目：在建立子范例的实例时，不能向超范例的构造函数中通报参数。
缘由：没有办法在不影响一切对象的实例状况下，给超范例的构造函数通报参数。
实践中很少零丁运用原型链。

借用构造函数

在子范例构造函数的内部挪用超范例构造函数
函数只是在特定环境中实行代码的对象，因而经由历程运用apply()和call()要领可以在新建立的对象上实行构造函数

通报参数

在范例构造函数中向超范例构造函数通报参数

function SuperType ( name ) {
    this.name = name;
}

function SubType ( name ) {
    // 继续了SuperType，同时通报参数
    SuperType.call(this,name)
    this.age = 21;
}

var instance = new SubType('cyan');
console.log( instance.name ); // cyan
console.log( instance.age ); // 21

借用构造函数的题目

没法防备构造函数情势存在的题目–要领都定义构造函数中定义。
超范例的原型中定义的要领，对子范例而言也是不可见的。
借用构造函数很少零丁运用

组合继续
将原型链和借用构造函数的手艺组合到一块，发挥两者之长的一种继续情势。
思绪：运用原型链的完成对象原型属性和要领的继续，经由历程借用构造函数完成的对象属性的继续。
结果：即经由历程在原型上定义要领完成了函数复用，有可以保证每一个实例都有它本身的属性。

instanceof 和isPrototypeOf(); 可以用于辨认基于组合建立的对象。 (JavaScript中最经常使用的继续情势)

瑕玷：会实行构造函数二次。

原型式继续

借助原型可以基于已有的对象建立新对象，同时还不比因而建立自定义范例。

function object(o){
    function F(){}
    F.prototype = o;
    return new F();
}

在 object(); 函数内部，先建立了一个暂时性的构造函数，然后将传入的对象作为这个构造函数的原型，末了返回这个暂时范例的一个新实例。实质上：boject()对传入个中的对象实行了一次浅复制

//2件事： 继续了1次父类的模板，继续了一次父类的原型对象


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

Person.prototype = {
    
    constructor: Person,
    
    sayHello: function () {

        console.log('hello world!');

    }
    
}

function Boy ( name,age,sex ) {
    
    //call 绑定父类的模板函数  完成  借用构造函数继续  只复制了父类的模板
    
//  Person.call(this,name,age);

        Boy.superClass.constructor.call(this,name,age);
    
    this.sex = sex;        
    
}

//原型继续的体式格局： 即继续了父类的模板，又继续了父类的原型对象。
//            Boy.prototype = new Person();
//只继续 父类的原型对象
    extend(Boy,Person);  // 目标 只继续 父类的原型对象  , 须要那两个类发生关联关联.

//给子类加了一个原型对象的要领。
Boy.prototype.sayHello = function () {
    
    console.log('hi,js');
    
}

var b = new Boy('zf',20,'男');

console.log( b.name );
console.log( b.sex );
b.sayHello(); 

Boy.superClass.sayHello.call(b);

//extend要领

//sub子类， sup 父类
function extend ( sub,sup ) {
    
    //目标, 完成只继续 父类的原型对象。   从原型对象入手
    
    //1，建立一个空函数， 目标：空函数举行中转
    var F = new Function();  // 用一个空函数举行中转。
    
// 把父类的模板屏障掉， 父类的原型取到。
    
    F.prototype = sup.prototype;  // 2完成空函数的原型对象 和 超类的原型对象转换
    
    sub.prototype = new F();  // 3原型继续
    
    //做善后处置惩罚。 复原构造器 ，
    sub.prototype.constructor = sub;  //4 ，复原子类的构造器
    
//保存一下父类的原型对象  // 由于 ①轻易解耦， 减低耦合性      ② 可以轻易取得父类的原型对象
    sub.superClass = sup.prototype;   //5 ，保存父类的原型对象。   //自定义一个子类的静态属性   ， 接收父类的原型对象。
    
    //推断父类的原型对象的构造器， （防备简朴原型中给更改成  Object）
    if ( sup.prototype.constructor == Object.prototype.constructor ) {
        
        sup.prototype.constructor = sup;  //复原父类原型对象的构造器
        
    }
    
}

Object.create()
参数1：用作新对象原型的对象。
参数2(可选)一个为新对象分外属性的对象. 设置参数（每一个属性都是经由历程高本身的形貌符定义）
传入一个参数的状况下：Object.create(); 与 object() 要领的行动雷同.
注重：定义任何属性都邑掩盖原型对象上同名属性。

包含援用范例值的属性一直都邑同享响应的值

var person = {
    name: 'cyan',
    firends: ['tan', 'kihaki', 'van']
}

var anotherPerson = Object.create(person, {
    name: {
        value: 'red'
    }
});
console.log( anotherPerson.name ); // red

寄生式继续

建立一个仅用于封装历程的函数，该函数在内部以某种体式格局来加强对象，末了返回对象。

function createAnother ( original ) {
    var cloen = Object.create(original); // 挪用函数建立一个新对象
    clone.sayHi = function () { // 以某种体式格局来加强这个对象
        console.log('hi'); 
    }
    return clone; // 返回这个对象
}

寄生组合式继续
处理，构造函数挪用二次的题目。
经由历程借用构造函数来继续属性，经由历程原型链的混成情势来继续要领。
基础思绪：没必要为了指定子范例的原型而挪用超范例构造函数。须要的是超范例的原型的一个副本。
实质：运用寄生式继续来继续超范例的原型，然后再将指定给子范例的原型。
没有运用new关键字

function inheritProtoype ( subType, superType ) {
    
    var prototype = Object.create(superType.prototype);  // 建立对象
    prototype.constructor = subType; // 加强对象
    subType.prototype = prototype; // 指定对象

}
// 1: 建立超范例的原型的一个副本。
// 2：为建立的副本增添增添constructor属性，从而填补由于重写原型而市区去的constructor属性  
// 3： 将新建立的对象，赋值给子范例的原型。

函数表达式

经由历程name 可以接见函数名(非标准属性)

关于函数声明，主要特征就是函数声明提拔：代码实行之前会先读取函数声明。

匿名函数(也叫拉姆达函数)： function 关键字背面没有标识符
匿名函数的name属性时空字符串

递归

递归函数: 一个函数经由历程名字挪用本身的状况

function factorial (num) {
    if ( num <= 1 ) { // 递归出口
        return 1;
    } else {
        return num * arguments.callee(num-1); // 递归点
    }
}

定名函数表达式：

var factorial = (function f ( num ) {
    if ( num <= 1 ) {
        return 1;
    } else {
        return num * f(num-1);
    }
});

建立了一个名为f() 的定名函数表达式，然后将它赋值给变量factorial。纵然把函数赋值给另一个变量，函数的名字f仍然是有用的。

闭包

闭包：指有权接见另一个函数中作用域中的变量的函数。

表现：在一个函数内部建立另一个函数

当某个函数被挪用的时刻，会建立一个实行环境(execution context)及响应的作用域链。然后运用arguments和别的定名参数的值来初始化函数的运动对象(activation object)。
在作用域链中，外部函数的运动对象一直处于第二位，外部函数的外部函数的运动对象处于第三位直至作用域链的尽头的全局实行环境。

背景的每一个实行环境都有一个示意变量的对象—变量对象

作用域链中最少包含二个变量对象：当地运动对象和全局变量对象。
作用域链实质：一个指向变量对象的指针列表，援用但不现实包含变量对象。

不管什么时刻在函数中接见一个变量时，就会从作用域链中搜刮具有响应名字的变量。
平常来说，当函数实行终了后，部分运动对象就会被烧毁，内容中近保存全局作用域(全局实行环境的比变量对象)。
然则，闭包可以延伸变量的生计周期

function createComparisonFunction( propertyName ) {

    return function ( object1, object2 ) {

        var val1 = object1[propertyName];
        var val2 = object1[propertyName];

        if ( val1 < val2 ) {

            return -1;

        } else if ( val1 > val2 ) {

            return 1;

        } else {

            return 0;

        }

    }
}


var compare = createComparisonFunction('name');
var reslut = compare({name: 'cyan'}, {name: 'tan'});

// 示知渣滓接纳机制将其消灭，
// 跟着匿名函数的作用域链被烧毁，别的作用域(除了全局作用域)也都可以平安的烧毁。
compare = null; // 打仗对匿名函数的援用(以便开释内存)

createComparisonFunction()函数实行终了后，其运动对象也不会被烧毁，由于匿名函数的作用域链仍然在援用这个运动对象。
当createComparisonFunction()函数实行返回后，其实行环境的作用域链会被烧毁，但它的运动对象仍会留在内存中，直至匿名函数被烧毁。createComparisonFunction()的运动对象才会被烧毁。

闭包的题目：
由于闭包会照顾包含它的函数的作用域，因而会比其他函数占用过量的内存。过分运用闭包能够会致使内存占用过量，V8引擎优化后，JavaScript引擎会尝试接纳被闭包占用的内存。

闭包与变量
闭包只能取得包含函数中任何变量的末了一值。(轮回嵌套函数的i题目)
闭包所保存的是全部变量对象，而不是某个迥殊的变量。

function createFunctions () {

    var reslut = [];

    for ( var i=0; i<10; i++ )  {

        reslut[i] = function (num) {

            return function () {

                return num;

            }

        }(i);

    }

    return reslut;
    
}

定义一个匿名函数，并将马上实行该匿名函数的结果赋给数组。由于函数参数是按值通报的，所以就会将变量i的当前值复制给参数num。而在这个匿名函数内部，有建立并返回了一个接见num的闭包。如许，reslut数组中的每一个函数都有本身num变量的一个副本，因而可以返回各自差异的数值。

关于this对象

this对象是运行时就函数实行环境绑定的：在全局函数中，this等于window，而当函数被作为某个对象的要领挪用时，this等于谁人对象。
匿名函数的实行环境具有全局性，因而其this对象一般指向window。但有时刻由于编写闭包的体式格局差异，这一点不明显。(在经由历程call()或apply()来转变函数实行环境的状况下，this就会指向别的对象。)

var name = 'window';

var object = {
    name: 'object',

    getNameFunc: function () {

        return function () {

            return this.name;
            
        }

    }

}

console.log( object.getNameFunc()() );

先建立了一个全局变量name，有建立一个包含name属性的对象。这个对象包含一个要领–getNameFunc(); 它返回一个匿名函数，而匿名函数又返回this.name。由于getNameFunc();返回一个函数，因而挪用object.getNameFunc()(); 就马上挪用它返回的函数，结果返回一个字符串。 结果的name变量的值是全局的。为何匿名函数没有取得其包含作用域(或外部作用域)的this对象呢?

每一个函数在被挪用时都邑自动取得两个迥殊变量：this和arguments。内部函数在搜刮这两个变量时，只会搜刮到其运动对象为止，因而永久不能够直接接见外部函数中的这个两个变量。

可以经由历程保存this援用来接见

var name = 'window';

var object = {
    name: 'object',

    getNameFunc: function () {

        var self = this;

        return function () {

            return self.name;

        }

    }

}

console.log( object.getNameFunc()() );

this 和arguments存在一样的题目，假如想接见作用域中的arguments对象，必需将对该对象的援用保存到另一个闭包可以接见的变量中。

内存走漏
假如闭包的作用域链保存着一个HTML元素，就意味着该元素将没法被烧毁

闭包会援用包含函数的全部运动对象。
包含函数的运动中也仍然会保存一个援用。因而，有必要把element变量设置null。如许可以打仗对DOM对戏谁人的援用。顺遂地削减其援用数据，确保平常接纳其占用的内存。

模拟块级作用域
JavaScript中没有块级作用域的观点

function outputNumbers ( count ) {
    for ( var i=0; i<count; i++ ) {
        console.log(i);
    }
    console.log(i); // 计数
}

变量i是定义在outputNumbers()的运动对象中，因而从它有定义最先，就可以在函数内部到处接见它。

匿名函数用来模拟块级作用域并防备这个题目。

块级作用域：称为私有作用域

(function () {})();

将函数声明包含在一堆圆括号中，示意它现实上是一个函数表达式，而紧随其后的另一对圆括号会马上挪用这个函数。

JavaScript将function 关键字作一个函数声明的最先，而函数后声明不能跟圆括号。然后函数表达式的背面可以跟圆括号。
将函数声明转换成表达式运用()
需求：只需暂时须要一些变量，就可以运用私有化作用域

function outputNumbers ( count ) {
    (function () {
        for ( var i=0; i<count; i++ ) {
            console.log(i);
        }
    })();
    console.log(i); // 报错
}
// 变量i 只能在轮回中运用，运用后即被烧毁，而在私有化作用域中可以接见变量count，由于这个匿名函数是一个闭包，它可以接见包含作用域中的一切变量。

在匿名函数中的定义的任何变量，都邑在实行结束时被烧毁。

结果：削减闭包占用的内存题目，由于没有指向匿名函数的援用。只需函数实行终了，就可以马上烧毁其作用域链了。

私有变量

特权要领：有权接见私有变量和私有要领的公有要领。
作用：封装性，隐蔽那些不该当被被直接修正的属性，要领。
瑕玷：必需运用构造函数情势来到达这个目标。
构造函数本身是有瑕玷：对每一个实例都是建立一样一组新要领。

构造函数中定义特权要领：

function MyObject () {

    // 私有变量和私有函数
    var privateVariable = 10;

    function prvateFunction () {
        return false;
    }

    // 特权要领
    this.publicMethod = function () {
        privateVariable++;
        return prvateFunction();
    }

}

静态私有变量
目标：建立静态变量会由于运用原型而增长代码的复用，但没有实例对象都没有本身的私有变量。

运用闭包和私有变量瑕玷：多查找作用域中的一个条理，就会在肯定水平上影响查找速率。

模块情势

目标：为单例建立私有变量和特权要领。
实质：对象字面量定义的是单例的大众接口

单例：只需一个实例的对象。
通例：JavaScript是以对象字面量的体式格局来建立单例对象。
作用：对单例举行某些初始化，同时又须要保护其私有化变量。

//经由历程 一个私有变量来掌握是不是 实例化对象， 初始化一个 init。

var Ext = {};

Ext.Base = (function () {

//私有变量 掌握返回的单体对象
var uniqInstance;  

//须要一个构造器  init 初始化单体对象的要领
function Init () {
    
    //私有成员
    var a1 = 10;
    var a2 = true;
    
    var fun1 = function () {
        
        console.log( a1 );
        
    }
    
    return {
        attr1: a1,
        attr2: a2,
        fun1: fun1
    }
    
}

return {
    
    getInstance: function () {
        
        if ( !uniqInstance ) {  //不存在 ，建立单体实例
            
            uniqInstance = new Init();                    
            
        }
        
        return uniqInstance;
        
    }
    
}

})()

var init = Ext.Base.getInstance();

init.fun1(); //10

运用需求：建立一个对象并以某些数据对齐初始化，同时还要公然一些可以接见这些私有数据要领。
每一个单例都是Object的实例，由于经由历程一个对象字面量示意单例一般都是 全局对象存在，不会将它通报给一个函数。

加强的模块情势
在返回对象之前假如对其加强的代码。

var application = function(){
    //私有变量和函数
    var components = new Array();

    //初始化
    components.push(new BaseComponent());

    //建立 application 的一个部分副本
    var app = new BaseComponent();

    //大众接口
    app.getComponentCount = function(){

        return components.length;
    }

    app.registerComponent = function(component){

        if (typeof component == "object"){
            components.push(component);
        }

    }

    //返回这个副本
    return app;

}();

BOM

window对象

BOM的中心对象是window，示意浏览器的一个实例。
在浏览器中，window对象有两重角色：
1:JavaScript接见浏览器窗口的一个接口
2: ECMAScript划定的Global对象。
在网页中定义的任何一个对象，变量，函数，都已window作为其Global对象。因而有权接见parseInt()等要领。

窗口与框架
运用框架时，每一个框架都有本身的window对象以及一切原生构造函数及别的函数的副本。每一个框架都保存在frames鸠合中，可以经由历程位置或经由历程称号来接见。
top对象一直指向最外围的框架，也就是全部浏览器窗口。
parent 对象示意包含当前框架的框架，而 self 对象则回指 window 。

全局作用域
定义全局变量与在window对象上直接定义属性差异：
全局变量不能经由历程delete操纵删除，直接定义window对象上的定义属性可以删除。

var age = 22;
window.color = "red";

//在 IE < 9 时抛出毛病，在其他一切浏览器中都返回 false
delete window.age;

//在 IE < 9 时抛出毛病，在其他一切浏览器中都返回 true
delete window.color; // returns true

console.log(window.age); //22 29

console.log(window.color); // undefined

var 语句增添的window属性[Configurable]的特征，这个特征的值被设置为false。所以定义的不可delete操纵符删除。

尝试接见未声明的变量会抛出毛病，然则经由历程window对象，可以晓得某个能够未声明的变量是不是存在。

var newValue = oldValue; // 报错，未定义

var newValue = window.oldValue; // 属性查询，不会抛出毛病

location对象

供应了与当前窗口中加载的文档有关的信息，供应一些导航功用。
location对象很迥殊，等于window对象的属性，也是document对象的属性，window.location 和 document.location援用的是同一个对象。

作用：保存着当前文档的信息，还表现将URL剖析为自力的片断。

位置操纵
location对象转变浏览器位置

location.assign('http://segmentfault.com'); // 翻开新的URL并在浏览器的历史纪录中天生一条纪录。

假如将location.href 或window.location设置为一个URL，会以该值挪用assign()要领。

window.location = "http://www.segmentfault.com";
location.href = "http://www.segmentfault.com";

最经常使用的体式格局：location.href = “http://www.segmentfault.com”;

制止用户运用‘退却’按钮 运用location.replace();
参数：须要导航的URL
location.relaod(); 作用：从新加载当前显现的页面

location.reload(); //从新加载（有能够从浏览器缓存中加载）
location.reload(true); //从新加载（从服务器从新加载）

location.reload();挪用以后的代码能够会也能够不会实行，取决于收集耽误或系统资源等要素。假如运用location.relaod();最好放在代码末了一行。

navigator对象

作用：辨认客户端浏览器

navigator.userAgent // 浏览器的用户代办字符串

检测插件
非IE下运用：navigator.plugins数组

function hasPlugin(name){
    name = name.toLowerCase();
    for (var i=0; i < navigator.plugins.length; i++){
        if (navigator. plugins [i].name.toLowerCase().indexOf(name) > -1){
            return true;
    }
}
return false;

注册处置惩罚顺序
registerContentHandler() 和 registerProtocolHandler()
作用：让一个站点指明它可以处置惩罚特定范例的信息。（运用范围：RSS 阅读器和在线电子邮件顺序）

registerContentHandler();
参数1：要处置惩罚的MIME范例
参数2：可以处置惩罚该MIME范例的页面URL
参数3：运用顺序的称号

   
// 站点注册为处置惩罚 RSS 源的处置惩罚顺序
navigator.registerContentHandler("application/rss+xml","http://www.somereader.com?feed=%s", "Some Reader");
// 参数1：RSS源 的MIME范例参数  2：应当吸收 RSS源 URL的 URL，个中的%s 示意RSS 源 URL，由浏览器自动插进去。
// 作用：当下一次要求 RSS 源时，浏览器就会翻开指定的 URL，而响应的Web 运用顺序将以恰当体式格局来处置惩罚该要求。

screen对象

表明客户端才能：浏览器窗口外部的显现器信息，如：像素宽度和高度。

window.screen.height // 屏幕的像素高度
window.screen.windth // 屏幕的像素宽度

window.resizeTo(); // 调解浏览器窗口大小

history对象

history 对象：保存用户上网的历史纪录。充窗口被翻开的那一刻算起。
history是window对象的属性，因而每一个浏览器串窗口，每一个标签页以致每一个框架，都有本身的history对象与特定的window对象关联。

history.go(); 在用户的历史纪录中恣意跳转。

//退却一页
history.go(-1);
//行进一页
history.go(1);
//行进两页
history.go(2);

// go()参数是字符串 // 能够退却，也能够行进，详细要看哪一个位置近来
//跳转到近来的 wrox.com 页面
history.go("segmentfault.com");

history.length; 保存着历史纪录的数目
包含一切历史纪录，即一切向后向前的纪录。关于加载到窗口，标签页或框架中的第一个页面而言。

高等技能

高等函数

平安的范例检测

JavaScript 中内置的范例检测机制并不是完全牢靠

typeof操纵符，由于它有一些没法预知的行动，致使检测数据范例时获得不靠谱的结果。(Safari直至第四版，对正则表达式 typeof 检测 会返回 ‘function’)

instanceof操纵符，存在多个全局作用域(像一个页面中包含多个frame)的状况下。

var isArray = valeu instaceof Array; 
// 返回true 前提：value 必需是数组， 必需与Array构造函数在同个全局作用域中。（Array 是 window的属性）。

在任何值上挪用Object原生的toString();要领。
返回 [object NativeConstructorName]花样的字符串。每一个类在内部都有一个[[Class]]属性，这个属性中指定了这个字符串中的构造函数名.

运用：
检测原生JSON对象。

var isNativeJSON = window.JSON && Object.prototype.toString.call(JSON) === '[object JSON]';

作用域平安的构造函数

作用：自定义对象和构造函数的定义和用法。
构造函数就是一个运用new操纵符挪用的函数。当运用new挪用时，构造函数内用到的this对象会指向新建立的对象实例。

题目：当没有运用new操纵符来挪用该构造函数的状况下。this对象是在运行时绑定的，所以直接挪用 类名 ，this会映照到全局对象window上，致使毛病对象属性的之外增添。

function Person ( name, age ) {

    this.name = name;
    this.age = age;

}

var p1 = Person('cyan', 22);

console.log(window.name);
console.log(window.age);
// Person实例的属性被加到window对象上，由于构造函数时作为平常函数挪用，疏忽了new操纵符。由this对象的晚绑定形成的，在这里this被剖析成了window对象。

// 在类中增添推断:
function Person ( name, age ) {

    if ( this instanceof Person ) {

        this.name = name;
        this.age = age;
    
    } else {

        return new Person(name, age);

    }

}

var p1 = Person('cyan', 22);

console.log(window.name);
console.log(window.age);
        
// 增添一个搜检，并确保this对象是Person实例。
// 要么运用new操纵符，要么运用现有的Person实例环境中挪用构造函数。

函数绑定
函数绑定要建立一个函数，可以在待定的this环境中指定参数挪用另一个函数。
运用范围：回调函数与事宜处置惩罚顺序一同运用，(在将函数作为变量通报的同时保存代码实行环境)

// bind(); 函数
function bind ( fn, context ) {
    return function () {
        return fn.apply(context, arguments);
    }
}

将某个函数以值的情势举行通报，同时该函数必需在特定环境中实行，被绑定的函数的结果。
主要用于事宜处置惩罚顺序以及setTimeout() 和 setInterval();
被绑定函数与平常函数比拟有更多开支，须要更多内存支撑，同时也由于多重函数挪用挪用比较慢。最好只在必要时运用。

函数柯里化

函数柯里化( function currying )： 把接收多个参数的函数变换成接收一个单一参数(最初函数的第一个参数)的函数，并返回接收余下的参数且返回结果的新函数

作用：建立已设置好的一个或多个参数的函数。

函数柯里化的基础要领：运用一个闭包返回一个函数。

函数柯里化和函数绑定区分：当函数被挪用时，返回的函数还须要设置一些传入的参数。

函数柯里化的动态建立：挪用另一个函数并为它传入要柯里化的函数和必要的参数。

用途：
作为函数绑定的一部分包含在个中，构造出更加庞杂函数

function bind ( fn, context ) {
    let args = Array.prototype.slice.call(arguments, 2);

    return {
        let innerArgs = Array.prototype.slice.call(arguments);
        let fianlArgs = args.concat(innerArgs);
        return fn.apply(context, fianlArgs);
    }

}

瑕玷：
每一个函数都邑带来分外的开支.不可以滥用。