/*

    原型Prototype

*/

//一、原型

//原型使用一

var calculator = function (dlg, tax)

{

    this.dlg = dlg;

    this.tax = tax;

}

calculator.prototype = {

    add: function (x, y) {

        return x + y;

    },

    subtrac: function (x, y) {

        return x - y;

    }

}

//原型使用二

//封装私有函数

calculator.prototype = function () {

    add = function (x, y) {

        return x + y;

    },

    subtract = function (x, y) {

        return x - y;

    }

    return {

        add: add,

        substract: subtract

    }

}();

//分开设置原型的每个属性

calculator.prototype.add = function (x, y) { };

calculator.prototype.substract = function (x, y) { };

var cal = function () {

    this.tax = 5;

};

cal.prototype = new calculator(); //cal的原型指向calculator的实例上，让cal继承两个函数

//无论创建多少个cal实例，都指向同一个对象

var newCal = new cal();

newCal.dlg;

//不想访问calculator的构造函数声明的属性值dlg

cal.prototype = calculator.prototype;

cal.dlg//报错

//重写原型

//覆盖前面的add方法

calculator.prototype.add = function (x, y) {

    return x + y + this.tax;

};

var calc = new calculator();

calc.add(1, 1);

//二、原型链

function Foo() {

    this.value = 42;

}

Foo.prototype = {

    method: function () { }

};

function bar() {

}

bar.prototype = new Foo();

bar.prototype.foo = 'hello';

//?

bar.prototype.constructor = bar;

var test = new bar();

/*

    原型链

    test[bar实例]

        bar.prototype [foo实例]

            {foo:'hello'}

            foo.prototype

                {method:...};

                Object.prototype

                    {toString:....}

*/

//属性查找

function foo() {

    this.add = function (x, y) {

        return x + y;

    }

}

foo.prototype.add = function (x, y) {

    return x + y + 10;

}

var f = new foo();

f.add(1, 2) //3， 先找自身属性，再往上找，直到object，如果没有，返回undefined. for in 效率问题

foo.prototype = 1;//错误，不能赋值原子类型的值

//hasOwnProperty函数，唯一一个处理属性不查找原型链的函数

Object.prototype.bar = -1;

var foo = { goo: undefined };

'bar' in foo //true,查找原型链

foo.hasOwnProperty('bar');//false 未查找原型链

foo.hasOwnProperty('goo');//true

//hasOwnProperty不受保护，可能会被非法占用命名，需要使用外部的hasOwnProperty来获取正确结果

var foo = { hasOwnProperty: function () { return false; }, bar: 'Here be dragons' }; foo.hasOwnProperty('bar'); // 总是返回 false

// 使用{}对象的 hasOwnProperty，并将其上下为设置为foo

var my = {};

my.hasOwnProperty.call(foo, 'bar');