enyo学习之enyo.Object类

     enyo.Object类是Enyo的基类，它实现了框架属性的一些公共方法。官方API文档给出了该类中几个方法的名称、参数和作用。

destroyObject: function(inName)  销毁名为inName的对象

getProperty: function(n)  返回名称为‘n’的属性的值

setProperty: function(n, v)  将名称为‘n’的属性赋值为‘v’

log: function()  向控制台发送log信息

warn: function()  和log类似，但是使用的是控制台的warn方法（如果存在该方法）

error: function() 和log类似，但是使用的是控制台的error方法（如果存在该方法）

    接下来简单看一下enyo.Object类的源码

enyo.kind({
    name: "enyo.Object",
    //* @protected
    // kind为空，没有父类
    kind: null,
    constructor: function() {
        enyo._objectCount++;
    },
    /**
        将名称为‘n’的属性值设置为‘v’，如果有回调方法cf则调用回调方法并将原来的值作为参数。
        所有属性的set方法都阻塞在这里以便对象观察属性的变化情况
    */
    setPropertyValue: function(n, v, cf) {
        if (this[cf]) {
            var old = this[n];
            this[n] = v;
            this[cf](old);
        } else {
            this[n] = v;
        }
    },
    _setProperty: function(n, v, cf) {
        this.setPropertyValue(n, v, (this.getProperty(n) !== v) && cf);
    },
    //* @public
    destroyObject: function(inName) {
        if (this[inName] && this[inName].destroy) {
            this[inName].destroy();
        }
        this[inName] = null;
    },
    getProperty: function(n) {
        var getter = "get" + enyo.cap(n);
        if (this[getter]) {
            return this[getter]();
        }
        return this[n];
    },
    /**
        设置属性值，如果该属性由set方法则调用set方法，否则调用_setProperty方法，并使用属性的Changed方法作为回调函数
    */
    setProperty: function(n, v) {
        var setter = "set" + enyo.cap(n);
        if (this[setter]) {
            this[setter](v);
        } else {
            this._setProperty(n, v, n + "Changed");
        }
    },
    /**
        Sends a log message to the console, prepended with the name of the kind
        and method from which _log_ was invoked.  Multiple arguments are coerced
        to String and joined with spaces.

            enyo.kind({
                name: "MyObject",
                kind: enyo.Object,
                hello: function() {
                    this.log("says", "hi");
                    // shows in the console: MyObject.hello: says hi
                }
            });
    */
    log: function() {
        var acc = arguments.callee.caller;
        var nom = ((acc ? acc.nom : "") || "(instance method)") + ":";
        enyo.logging.log("log", [nom].concat(enyo.cloneArray(arguments)));
    },
    //* Same as _log_, except uses the console's warn method (if it exists).
    warn: function() {
        this._log("warn", arguments);
    },
    //* Same as _log_, except uses the console's error method (if it exists).
    error: function() {
        this._log("error", arguments);
    },
    //* @protected
    _log: function(inMethod, inArgs) {
        if (enyo.logging.shouldLog(inMethod)) {
            try {
                throw new Error();
            } catch(x) {
                enyo.logging._log(inMethod, [inArgs.callee.caller.nom + ": "].concat(enyo.cloneArray(inArgs)));
                console.log(x.stack);
            }
        }
    }
});

//* @protected
//对象计数器
enyo._objectCount = 0;

enyo.Object.subclass = function(ctor, props) {
    this.publish(ctor, props);
};

/**
    为对象的publish属性添加get、set方法
*/
enyo.Object.publish = function(ctor, props) {
    var pp = props.published;
    if (pp) {
        var cp = ctor.prototype;
        for (var n in pp) {
            enyo.Object.addGetterSetter(n, pp[n], cp);
        }
    }
};

/**
    为对象的属性添加get、set方法的实现代码，注意添加set方法时将Changed方法作为了回调函数
*/
enyo.Object.addGetterSetter = function(inName, inValue, inProto) {
    var priv_n = inName;
    inProto[priv_n] = inValue;
    //
    var cap_n = enyo.cap(priv_n); 
    var get_n = "get" + cap_n;
    if (!inProto[get_n]) {
        inProto[get_n] = function() { 
            return this[priv_n];
        };
    }
    //
    var set_n = "set" + cap_n;
    var change_n = priv_n + "Changed";
    if (!inProto[set_n]) {
        inProto[set_n] = function(v) { 
            this._setProperty(priv_n, v, change_n); 
        };
    }
};

      JavaScript没有深入系统的学过，只能简单的理解一下。