2

私はこのようなコードを持っています:

var A = function(a,b,c) {
  var self = this;
  self.a = ko.observable(a);
  ... 


  self.function1 = ko.computed(function () {
      dothing(a);
      ...
  } 

  self.function2 = ko.computed(function () {
      dothing(b);
      ...
  }
}

var B = function(a,b,c,d) {
    var self = this;
  self.a = ko.observable(a);
  ... 


  self.function1 = ko.computed(function () {
      dothing(a);
      ...
  } 

  self.function2 = ko.computed(function () {
      dothing(b);
      ...
  }
}

function1とfunction2をAとBが共有できる関数に「抽出」するにはどうすればよいですか?

4

4 に答える 4

5

それがプロトタイプがぴったり合うところです:

function AB()
{};//empty object
AB.prototype.function1 = function()
{
    var self = this;//doesn't have access to self, but `this` will point to either A or B
    //do stuff
};
var A = function()
{
    var self = this;//constructor
}
var B = function()
{
    var self = this;//constructor
}
A.prototype = new AB;
A.prototype.constructor = A;
B.prototype = new AB;
B.prototype.constructor = B;
//marginally shorter:
A.prototype = B.prototype = new AB;
A.prototype.constructor = A;
B.prototype.constructor = B;
//instances:
var foo = new A();
var bar = new B();
console.log(foo.function1 === bar.function1);//logs true

そうは言っても、個人的には、コンストラクターを定期的に定義することを好みます。

function A()
{
    var self = this;
}
foo = new A();
console.log(Object.getPrototypeOf(foo).constructor.name);//logs A

コードは無名関数を変数に割り当てますが、これはコンストラクターに名前がないことを意味します。

foo = new A();
console.log(Object.getPrototypeOf(foo).constructor.name);//logs ''

それほど大したことではありませんが、ご存知のとおり...


グローバル(またはその他の)スコープからメソッドを参照します。

var virtualNewFunction = new A();//create object
virtualNewFunction = virtualNewFunction.function1;//virtualNewFunction now references function1
virtualNewFunction();

クロージャーはアクセス可能(露出)になりますが、次の点は十分注意してthisください。

A = function()
{
    var self = this;
    this.function1 = function()
    {
        console.log(this);
        console.log(self);
    };
}
foo = new A();
foo.function1();//logs A twice
foo = foo.function1
foo();//logs this -> window! self => A

もう1つの可能性は、関数を「借用」することです。

A = function()
{
    var self = this;
    this.function1 = function()
    {
        console.log(this);
        console.log(self);
    };
}
B = function()
{//no method
    var self = this;
}
foo = new A();
bar = new B();
foo.function1.apply(bar,[]);//call as though function1 was method of B

繰り返しますが、注意してください。この場合はthisログに記録されますBが、selfそれでも参照されますA。特定の「セーフティネット」を組み込むことができます:

    this.function1 = function()
    {
        self = this !== window && this !== self ? this : self;//redefine self to current caller object, unless it's window 
        console.log(this);
        console.log(self);
    };

しかし、正直なところ、この演算子をよく読んで、この参照のトリックをすべて把握することをお勧めします。基本を理解すれば、それほど難しくはありません。また、メソッドを「共有/借用」する方法の詳細については、呼び出し適用メソッドを確認してください

于 2012-10-01T14:47:42.557 に答える
0

関数をそのオブジェクトから引き出すことで、関数のスコープを変更できます。

var function1 = function() {

}

var function2 = function() {

}

var A = function(a,b,c) {
  var self = this;
  self.a = ko.observable(a);
  ... 


  self.function1 = ko.computed(function1)

  self.function2 = ko.computed(function2)
}
于 2012-10-01T14:36:43.477 に答える
0

underscore.js拡張機能を使用して継承を行うことができます。

于 2013-08-04T19:56:37.503 に答える
0
    var AB=function(){
    self=this;
    self.function1=function(){
                   //----something------
                  }
    self.function1=function(){
                   //----something------
                  }

   }


     var A=function(){
     var self=this;
     AB.apply(self,arguments);
     } 

    var B=function(){
     var self=this;
     AB.apply(self,arguments);
        } 
于 2013-08-05T22:15:31.537 に答える