4.0.2

sop-sdk/sdk-nodejs/common/Class.js

@@ -0,0 +1,125 @@
+/**
+ * 面相对象辅助类，可实现类的创建，继承，方法重写
+ *
+ <pre>
+ //-------------------------
+ // JS类的创建,继承
+ //-------------------------
+
+ // 例子1:-------------------------
+ // 创建一个父类
+ var Person = Class.create({
+        // 构造函数
+        init:function(option){
+            this.name = option.name;
+        }
+        ,getName:function() {
+            return this.name;
+        }
+    });
+
+ // 声明类实例
+ var Jim = new Person({name:'Jim'});
+ console.log('Jim name:' + Jim.getName())
+
+ //例子2:-------------------------
+
+ // 创建一个类,继承Person类，并重写getName
+ var Man = Class.create({
+        init:function(option) {
+            this._super(option);// 调用父类构造函数
+            this.age = option.age;
+        }
+        // 重写父类方法
+        ,getName:function() {
+            // 调用父类的getName()
+            var name = this._super();
+            return '我重写了getName方法：{'+name+'}';
+        }
+    },Person);
+
+ var man = new Man({name:'Tom',age:22});
+ console.log('man name:' + man.getName())
+
+ console.log('Jim instanceof Person: ' + (Jim instanceof Person));
+ console.log('man instanceof Person: ' + (man instanceof Person));
+ </pre>
+ *
+ */
+exports.Class = (function () {
+    // ------Class Creation------
+    var initializing = false,
+        fnTest = /xyz/.test(function () {
+            xyz;
+        }) ? /\b_super\b/ : /.*/;
+
+    // The base Class implementation (does nothing)
+    this.Class = function () {
+    };
+
+    // Create a new Class that inherits from this class
+    Class.extend = function (prop) {
+        var _super = this.prototype;
+
+        // Instantiate a base class (but only create the instance,
+        // don't run the init constructor)
+        initializing = true;
+        var prototype = new this();
+        initializing = false;
+
+        // Copy the properties over onto the new prototype
+        for (var name in prop) {
+            // Check if we're overwriting an existing function
+            prototype[name] = typeof prop[name] == "function" && typeof _super[name] == "function" && fnTest.test(prop[name]) ? (function (name, fn) {
+                return function () {
+                    var tmp = this._super;
+
+                    // Add a new ._super() method that is the same method
+                    // but on the super-class
+                    this._super = _super[name];
+
+                    // The method only need to be bound temporarily, so we
+                    // remove it when we're done executing
+                    var ret = fn.apply(this, arguments);
+                    this._super = tmp;
+
+                    return ret;
+                };
+            })(name, prop[name]) : prop[name];
+        }
+
+        // The dummy class constructor
+        function Class() {
+            // All construction is actually done in the init method
+            if (!initializing && this.init) this.init.apply(this, arguments);
+        }
+
+        // Populate our constructed prototype object
+        Class.prototype = prototype;
+
+        // Enforce the constructor to be what we expect
+        Class.prototype.constructor = Class;
+
+        // And make this class extendable
+        Class.extend = arguments.callee;
+
+        return Class;
+    };// ------Class Creation end------
+
+
+
+    return {
+        /**
+         * 创建一个类
+         * @param option 类方法,json数据
+         * @param parentClass 父类
+         */
+        create: function (option, parentClass) {
+            if (!parentClass) {
+                parentClass = Class;
+            }
+            return parentClass.extend(option);
+        }
+    };
+
+})();