Question

实现改变原型，为什么不只是将目录改为'some class'.prototype ...，它似乎很无用或者是palaver

Answer 1

您可以查看MooTools源代码或检查控制台中的MooTools对象，以便在调用implement()时查看它在幕后的作用。

在MooTools 1.4.5中，它正在这样做：

function (key, value){

    if ($type(key) == 'object'){
        for (var p in key) this.implement(p, key[p]);
        return this;
    }

    var mutator = Class.Mutators[key];

    if (mutator){
        value = mutator.call(this, value);
        if (value == null) return this;
    }

    var proto = this.prototype;

    switch ($type(value)){

        case 'function':
            if (value._hidden) return this;
            proto[key] = Class.wrap(this, key, value);
        break;

        case 'object':
            var previous = proto[key];
            if ($type(previous) == 'object') $mixin(previous, value);
            else proto[key] = $unlink(value);
        break;

        case 'array':
            proto[key] = $unlink(value);
        break;

        default: proto[key] = value;

    }

    return this;

}

正如你所看到的，那里肯定有一些额外的逻辑。例如，您似乎可以传递具有key和value的相应属性名称的对象，以使其在一次调用中实现向对象原型添加多个内容。

我会使用implement()并避免将内容直接添加到原型链中，除非您非常确定自己知道自己在做什么。毫无疑问，那些额外的东西是有原因的。

Answer 2

实施有两个方面。在类上下文和对象（类型/本机）上。

共同利益

它们之间的共同点是，它们是API。因为它是API，MooTools可以添加一些方法来确保您不会（意外地）覆盖受各种Native类型保护的原型方法。请参阅此位以强制保护许多本机方法：https://github.com/mootools/mootools-core/blob/master/Source/Core/Core.js#L238-282

此外，实现被重载 - 这意味着你可以传递一个同时实现多个方法的对象，而不是为每个原型调用打破并有一个新行。

包装中的函数方法。

这些装饰者可用：

Function.implement({

    hide: function(){
        this.$hidden = true;
        return this;
    },

    protect: function(){
        this.$protected = true;
        return this;
    }

});

这意味着你可以做到

Obj.implement({
   foo: foo.hide(),
   bar: bar.protect()
});

这允许您通过.hide()使用非包装方法来添加未包装的属性：

Number.prototype.$family = function(){
    return isFinite(this) ? 'number' : 'null';
}.hide();

Class使用

.protect()，见下文。

这并不意味着你不能做Number.prototype.$family = somethingElse - 你可以。

Class

的细节

在类构造函数上使用implement时，请注意对$hidden的引用并致电wrap()：

var implement = function(key, value, retain){
    if (Class.Mutators.hasOwnProperty(key)){
        value = Class.Mutators[key].call(this, value);
        if (value == null) return this;
    }

    if (typeOf(value) == 'function'){
        if (value.$hidden) return this;
        this.prototype[key] = (retain) ? value : wrap(this, key, value);
    } else {
        Object.merge(this.prototype, key, value);
    }

    return this;
};

这意味着当您传递一个函数时，它将自动换行 - 换行使您可以通过.protect()装饰器获取私有方法，或通过.hide()

获取特殊方法

它还支持Class Mutators - 你应该检查这个，但它能够定义可以修改构造函数的特殊键，而不是只添加到原型。

再一次，您可以轻松地做到：

ClassConstructor.prototype.foo = someFn;

这将有效。

// but:
ClassConstructor.prototype.foo = someFn.protect();

// however...
instanceOfClassconstructor.foo(); // works also.

看到这个：

// generic method.
var foo = function() {
    console.log('hi');
};

var ClassConstructor = new Class({});

// implement the foo method as private.
ClassConstructor.implement({
    foo: foo.protect()
});

var instance = new ClassConstructor();

// try to call it, will throw.
try {
    instance.foo();
}
catch(e) {
    console.warn(e);
}

// do it directly on the prototype
ClassConstructor.prototype.foo = foo.protect();

var instance2 = new ClassConstructor();
instance2.foo(); // works.

在MooTools中，.implement和.prototype之间的区别是什么

2 个答案:

共同利益

Class