JS高级-原型链

JavaScript 不包含传统的类继承模型,而是使用 prototypal 原型模型。

方式1:

JS高级-原型链
var Calculator = function (decimalDigits, tax) {
            this.decimalDigits = decimalDigits;
            this.tax = tax;
        };
Calculator.prototype = {
            add: function (x, y) {
                return x + y;
            },
            subtract: function (x, y) {
                return x - y;
            }
        };
        //alert((new Calculator()).add(1, 3));
JS高级-原型链

方式2:

JS高级-原型链
 Calculator.prototype = function () {
            add = function (x, y) {
                return x + y;
            },

            subtract = function (x, y) {
                return x - y;
            }
            return {
                add: add,
                subtract: subtract
            }
        } ();
        //alert((new Calculator()).add(11, 3));
JS高级-原型链

可以封装私有的function,通过return的形式暴露出简单的使用名称,以达到public/private的效果(没看懂

分步声明:

JS高级-原型链
var BaseCalculator = function () {
    //为每个实例都声明一个小数位数
    this.decimalDigits = 2;
};        
//使用原型给BaseCalculator扩展2个对象方法
BaseCalculator.prototype.add = function (x, y) {
    return x + y;
};
BaseCalculator.prototype.subtract = function (x, y) {
    return x - y;
};
var Calculator = function () {
    //为每个实例都声明一个税收数字
    this.tax = 5;
};       
Calculator.prototype = new BaseCalculator();
var calc = new Calculator();
alert(calc.add(1, 1));
//BaseCalculator 里声明的decimalDigits属性,在 Calculator里是可以访问到的
alert(calc.decimalDigits); 
JS高级-原型链

Calculator的原型是指向到BaseCalculator的一个实例,所以不管你创建多少个 Calculator对象实例,他们的原型指向的都是同一个实例。

重写原型:

属性或function

JS高级-原型链
//覆盖前面Calculator的add() function 
Calculator.prototype.add = function (x, y) {
    return x + y + this.tax;
};
JS高级-原型链

原型链:

JS高级-原型链
  function foo() {
            this.add = function (x, y) {
                return x + y;
            }
        }
        foo.prototype.add = function (x, y) {
            return x + y + 10;
        }
        Object.prototype.subtract = function (x, y) {
            return x - y;
        }
        var f = new foo();
        alert(f.add(1, 2)); //结果是3,而不是13
        alert(f.subtract(1, 2)); //结果是-1
JS高级-原型链

当查找一个对象的属性时,JavaScript 会向上遍历原型链,直到找到给定名称的属性为止,到查找到达原型链的顶部 - 也就是 Object.prototype - 但是仍然没有找到指定的属性,就会返回 undefined。

注意:属性在查找的时候是先查找自身的属性,如果没有再查找原型,再没有,再往上走,一直插到Object的原型上,所以在某种层面上说,用 for in语句遍历属性的时候,效率也是个问题。

我们可以赋值任何类型的对象到原型上,但是不能赋值原子类型的值,比如如下代码是无效的:

JS高级-原型链
function Foo() {}
Foo.prototype = 1; // 无效
JS高级-原型链

hasOwnProperty函数:

hasOwnProperty是Object.prototype的一个方法,判断一个对象是否包含自定义属性而不是原型链上的属性,因为hasOwnProperty 是 JavaScript 中唯一一个处理属性但是不查找原型链的函数。

JS高级-原型链
// 修改Object.prototype
Object.prototype.bar = 1; 
var foo = {goo: undefined};
foo.bar; // 1
‘bar‘ in foo; // true
foo.hasOwnProperty(‘bar‘); // false
foo.hasOwnProperty(‘goo‘); // true
JS高级-原型链

但有个恶心的地方是:

JS高级-原型链
var foo = {
    hasOwnProperty: function() {
        return false;
    },
    bar: ‘Here be dragons‘
};
foo.hasOwnProperty(‘bar‘); // 总是返回 false
// 使用{}对象的 hasOwnProperty,并将其上下为设置为foo
{}.hasOwnProperty.call(foo, ‘bar‘); // true
JS高级-原型链

JavaScript 不会保护 hasOwnProperty 被非法占用,因此如果一个对象碰巧存在这个属性,就需要使用外部的 hasOwnProperty 函数来获取正确的结果。(没看懂

JS高级-原型链
// 修改 Object.prototype
Object.prototype.bar = 1;

var foo = {moo: 2};
for(var i in foo) {
    console.log(i); // 输出两个属性:bar 和 moo
}

// foo 变量是上例中的
for(var i in foo) {
    if (foo.hasOwnProperty(i)) {
        console.log(i);
    }
}
JS高级-原型链

JS高级-原型链,布布扣,bubuko.com

JS高级-原型链

上一篇:活用maven使web.xml可以用maven变量


下一篇:C# .net中cookie值为中文时的乱码解决方法