enyo.kind

20条回复
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
enyo.kind = function(inProps) {
    // kind-name to constructor map could be faulty now that a new kind exists, so we simply destroy the memoizations
    enyo._kindCtors = {};
    // extract 'name' property
    var name = inProps.name || "";
    // extract 'kind' property
    var kind = inProps.isa || inProps.kind;
    // if we have an explicit kind property that is undefined, we probably tried
    // to reference an kind that is not yet in scope
    if ((kind === undefined) && ("kind" in inProps)) {
        throw "enyo.kind: Attempt to subclass an 'undefined' kind. Check dependencies for [" + name + "].";
    }
    // establish base class reference
    var base = kind && enyo.constructorForKind(kind);
    var isa = base && base.prototype || null;
    // make a boilerplate constructor
    var ctor = enyo.kind.makeCtor();
    delete inProps.name;
    // semi-reserved word 'constructor' causes problems with Prototype and IE, so we rename it here
    if (inProps.hasOwnProperty("constructor")) {
        inProps._constructor = inProps.constructor;
        delete inProps.constructor;
    }
    // create our prototype
    //ctor.prototype = isa ? enyo.delegate(isa) : {};
    enyo.setPrototype(ctor, isa ? enyo.delegate(isa) : {});
    // put in our props
    enyo.mixin(ctor.prototype, inProps);
    // alias class name as 'kind' in the prototype
    ctor.prototype.kindName = name;
    // cache super-class constructor
    ctor.prototype.base = base;
    // reference our real constructor
    ctor.prototype.ctor = ctor;
    // support pluggable 'features'
    enyo.forEach(enyo.kind.features, function(fn){ fn(ctor, inProps); });
    // put reference into namespace
    enyo.setObject(name, ctor);
    return ctor;
};

kernel/Oop.js
enyo.kind

enyo.kind: function(inProps)
Creates a JavaScript constructor function with a prototype defined by inProps.

enyo.kind makes it easy to build a constructor-with-prototype (like a class) that has advanced features like prototype-chaining (inheritance).

A plug-in system is included for extending the abilities of the kind generator, and constructors are allowed to perform custom operations when subclassed.

Special Property Names

Generally the properties defined in inProps are copied directly to the generated prototype, but certain property names trigger special processing.

Examples of special properties are:

name: the name property defines the name of the created constructor in the global namespace (intermediate objects are created automatically). name is not copied directly to the prototype, but is instead stored as kindName.

1
2
3
4
5
6
7
8
9
// Creates a function MyNamespace.MyKind with a prototype.
// MyNamespace.MyKind.prototype.kindName is set to "MyNamespace.MyKind".
// MyNamespace.MyKind.prototype.plainProperty is set to "foo".
enyo.kind({
    name: "MyNamespace.MyKind"
    plainProperty: "foo"
});
// Make an instance of the new kind
var myk = new MyNamespace.MyKind();

kind: the name of or reference to a kind to derive from, like a super-class. The new constructor’s prototype is chained to the prototype specified by kind, and the base property in the new prototype is set to reference the kind constructor.

1
2
3
4
5
6
7
// Create a function MyKind with a prototype, derived from enyo.Object.
// MyKind.prototype.kindName is set to "MyKind".
// MyKind.prototype.base is set to enyo.Object.
enyo.kind({
    name: "MyKind",
    kind: enyo.Object
});

constructor: a function to call when a new instance is created. Actually stored on the prototype as _constructor.

1
2
3
4
5
6
7
8
9
10
11
// Create a function MyKind with a prototype, derived from enyo.Object.
// _constructor_ is called when an instance is created.
enyo.kind({
    name: "MyKind",
    kind: enyo.Object,
    constructor: function() {
        this.instanceArray = [];
        // call the constructor inherited from Object
        this.inherited(arguments);
    }
});

statics: properties from any statics object are copied onto the constructor directly, instead of the prototype.

1
2
3
4
5
6
7
8
9
10
11
// Create a kind with a static method.
enyo.kind({
    name: "MyKind",
    statics: {
        info: function() {
            return "MyKind is a kind with statics.";
        }
    }
});
// invoke the static info() method of MyKind
console.log(MyKind.info());

Certain kinds in the framework define their own special properties. For example, see the published property supported by enyo.Object.

inherited

The inherited feature allows you to easily call the super-kind method for any method that has been overridden.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
enyo.kind({
    name: "MyKind",
    doWork: function() {
        this.work++;
    }
});

enyo.kind({
    name: "MyDerivedKind",
    kind: "MyKind",
    doWork: function() {
        if (this.shouldDoWork) {
            this.inherited(arguments);
        }
    }
});

The first argument to inherited is required to be the literal arguments, which is a special JavaScript variable that contains information about the executing function.

《enyo.kind》上有20条评论

发表评论

电子邮件地址不会被公开。 必填项已用*标注