javascript - Javascript静的メソッドの継承

Question

さまざまなメソッドを持つことができるJavascriptクラス/オブジェクトを作成したいと思います。

モデルクラス

• Model.all()»静的メソッド
• Model.find()»静的メソッド
• Model delete()»インスタンスメソッド
• Model save()»インスタンスメソッド
• Model.create()»新しいモデルインスタンスを返す静的

静的メソッドの場合、次を使用してそれらを定義できます。

Model.staticMethod(){ method }

たとえば、メソッドを使用する方が適切です。

function Model(){
    this.instanceMethod = function(){}    
}

次に、新しいインスタンスを作成します

またはプロトタイプを使用していますか？

var m = function Model(){

}

m.prototype.method() = function() {
}

ここで、Modelに基づいて新しいクラスを作成したいとします。プロトタイプだけでなく、静的メソッドも継承する方法を教えてください。

編集：

混乱を避けるために、これは多かれ少なかれ私が作成したいものです：

http://activejs.org/activerecord/index.htmlおよびhttp://activejs.org/activerecord/ActiveRecord/Model/index.html

そのようなものを使用して新しいモデルを定義できる場所

var User = ActiveRecord.create({
    username: '',
    password: '',
    post_count: 0,
    profile: ''
}

次にインスタンスを作成します

var jessica = User.create({
    username: "Jessica",
    password: "rabbit"
});

次のようなインスタンスメソッドを使用します

jessica.save();

だけでなく、クラスメソッド：

User.findByUsername('Jessica');

Answer 1

function Model() {}

// Methods in the instantiated object
Model.prototype = {
    constructor: Model,

    // Note that "delete" is a reserved word, so we need quotes
    'delete': function() {},

    save: function() {}
};

// Static methods
Model.all = function() {};

Model.find = function() {};

Model.create = function() {
    return new Model();

    // To be more generic, you can also:
    return new this();
};

を使用するvar InheritedModel = Object.create( Model );と、静的メソッドも継承されます。

var InheritedModel = Object.create( Model );
!!InheritedModel.all // true

new InheritedModel()ただし、これは関数ではないため、実行できません。また、使用しObject.create( InheritedModel )てもインスタンス メソッドは得られません。

を使用して継承されたクラスをインスタンス化するnew場合は、次のものが必要です。

function InheritedModel() {}

InheritedModel.prototype = Object.create( Model.prototype );

// Copy all the static methods in the InheritedModel object
Object.keys( Model ).forEach( function( key ) {
    InheritedModel[ key ] = Model[ key ];
} );

編集：あなたの編集を見た後、私がお勧めする解決策は次のとおりです：

function ActiveRecord( type, args ) {
    if ( type = 'users' ) {
        return new this.users();
    }
}

// Static method on ActiveRecord
ActiveRecord.create = function( type, args ) {
    return new ActiveRecord( type, args );
};

ActiveRecord.prototype = {
    constructor: ActiveRecord,

    // Instance method on ActiveRecord, you won't need it,
    // but your constructor does
    users: function( args ) {}
};

var Users = ActiveRecord.prototype.users;

Users.prototype = {
    constructor: Users,

    // Instance method on User's instance
    save: function() {}
}

// Static method on User
Users.create = function() {}

Answer 2

コメント付きコードは疑似コードです。次の方法で同じことを達成できます。

var modelInstanceMethods = {

    save: function() {
        /*
        insert into this.tableName blabla
        */
    },

    'delete': function() {
        /*
        delete from this.tableName blabla
        */
    }
};

var modelStatics = {

    create: function(obj) {
        return new this(obj);
    },

    all: function() {
        /*
        return select * from this.tableName.map( function( values ) {
            return new this(values);
        },this);
        */
    },

    find: function(id) {
        /*
        select * from this.tableName where id = id
        return new this(columnValues);
        */
    }


};

var ActiveRecord = {
    create: function( tableName, fields, methods ) {

        function Model( obj ) {
            this.tableName = tableName;
            this.fields = {};
            if( fields ) {
                for( var field in fields ) {
                    this.fields[field] = fields[field];
                }
            }

            if( obj ) {
                for( var field in obj ) {
                    this.fields[field] = obj[field];
                }       
            }
        }

        Model.tableName = tableName;
        Model.prototype = Object.create(modelInstanceMethods);
        Model.prototype.constructor = Model;

        for( var key in modelStatics ) {
            Model[key] = modelStatics[key];
        }

        if( methods ) {
            for( var key in methods ) {
                Model.prototype[key] = methods[key];
            }   
        }

        return Model;
    }
};

使用法

var User = ActiveRecord.create('users',
    /* fields and their default values */
{
    id: 0,
    username: '',
    password: '',
    post_count: 0,
    profile: ''
}, {
    /*instance methods */
    setPassword: function(password) {
        this.fields.password = password;
    }
});

/*You can define static methods like this */

User.findByUsername = function(username) {
    /*select from this.tableName where userName = username
               return new this(columnValues) blabla
             */
};

var jessica = User.create( {
    username: "Jessica",
    password: "rabbit"
});

jessica.save();

User.findByUsername('Jessica');

Answer 3

Object.prototype に「extends」メソッドを追加して、オブジェクトのプロトタイプを拡張できます。このようにして、Java のような継承メソッドが作成されます。

(「extends」プロパティを列挙不可として定義することが重要です。そうしないと、jQuery が壊れます)

Object.defineProperty(Object.prototype, "extends", {
        "enumerable": false,
        "value" : function(constructor) {

                /*Inheriting enumerable statick method and paramether
                from the super class */
                Object.keys( constructor ).forEach( function(key) {
                        this[key]= constructor[key];
                }.bind(this));

                /*Classic Javascript inheritance*/
                this.prototype= Object.create( constructor.prototype, {
                            "constructor": {
                                    "value": this,
                                    "configurable": true
                            }
                });             

                this.__super__= constructor;

        }

});

そうすることで、あるクラスを別のクラスに簡単に継承できます。

InheritedModel.extends(Model);

function InheritedModel(params){

       this.constructor.__super__.call(this, params);

       /* Or directly :
       Model.call(this,param);
       */

       /*Code specific to InheritedModel constructor */
}

/*To overload method from the super class:*/

InheritedModel.prototype.foo= function(params){

     var out= this.constructor.__super__.prototype.foo.call(this,params);

     /* Or
     var out= Model.prototype.foo.call(this,param);
     */

     /* code */

};

InheritedModel は、すべてのインスタンス メソッドとすべての静的メソッドをモデルから継承します。

例：

function Model() {
        this.inheritedClassName= "Model";
};

Model.inheritedClassName= "Model";

Model.getClassName = function() {
       return this.name;
};

Model.prototype.getClassName = function() {
        return this.constructor.name;
};

InheritedModel.extends(Model);

function InheritedModel() {
        Model.call(this);
}

console.log(InheritedModel.inheritedClassName);/* Model */
console.log(InheritedModel.getClassName());/* InheritedModel */

var inheritedModel= new InheritedModel();

console.log(inheritedModel.inheritedClassName);/* Model */
console.log(inheritedModel.getClassName());/* InheritedModel */

これが最善の解決策だと思います。

Answer 4

これはどうですか、プライベートメソッドとパブリックメソッドがあります：

function Model() {
    var privateMethods = {
       private1: function() {},
       private2: function() {},
       private3: function() {},
    };

    var publicMethods = {
    method1: function() {},
    method2: function() {
            //call a private method...
            privateMethods.private1();
        }
    };

    return publicMethods;
}


// Static methods
Model.all = function() {};

Model.find = function() {};

Model.create = function() {
    return new Model();
};