Eine native Weise benutzerdefinierte JavaScript-Funktionen in eine Methode-Anrufe Kette der Zugabe

Question

ich bekannt möchte, wenn es eine einheimische Art und Weise, dies zu tun ist:

Object.prototype.chain = function(f) { return f.call(this) } 


function fun1() { 
    doSomethingWithObject(this) 
    return this 
} 

function fun2() { 
    doSomethingElse(this) 
    return this 
} 

someObject 
    .method1('something') 
    .method2() 
    .chain(checkSomething() ? fun1 : fun2) 
    .method3() 

Aber ich fühle mich nicht wie der Prototyp Object Wechsel . Gibt es eine Möglichkeit, dies zu tun, ohne den Prototyp Objects oder die anderen Konstrukteuren zu ändern, die ich (und ist nicht der Entwickler)

Edits:

Ich fühle mich nicht sehr gut erklären, lassen‘ fügen Sie einige Details hinzu:

Was ich tun möchte, ist, einige APIs zu verwenden, die ich nicht definiere. someObject wird wie folgt definiert, mit verkettbar Methoden:

var someObject = { 
    method1: function(val) { 
     // do something 
     return this 
    }, 
    method2: function() { 
     // do something 
     return this 
    }, 
    method3: function() { 
     // do something 
     return this 
    } 
} 

Jetzt stelle ich mir den Code nicht ändern kann, da dieses Objekt aus einer Bibliothek ist, und so will ich nicht zu. Stellen Sie sich dann vor, dass ich Methoden und einige benutzerdefinierte Funktionen (siehe mein erstes Snippet) für viele andere Objekte ketten möchte. Am einfachsten ist es, eine chain Methode an Object.prototype anzuhängen.

Aber ich denke, dass es zu Konflikten in der Zukunft führen könnte. Ich suche nach einer Möglichkeit, dasselbe zu tun, ohne den Prototyp zu berühren.

Answer 1

Der Wrapper ist etwas, das jedes Objekt umschließt, um es mit "Verkettung" kompatibel zu machen, und fügt eine weitere Kettenmethode hinzu, die es ermöglicht, externe Funktionen zu verbinden und trotzdem die Verkettung zu erhalten.

prüfen dieses Beispiel:

function myObj() { 
    this.state = { 
     a: 1 
    }; 
    this.method1 = function() { 
     console.log("1"); 
    } 
    this.method2 = function() { 
     console.log("2"); 
    } 
    this.method3 = function() { 
     console.log("3"); 
    } 
    this.method4 = function() { 
     console.log(this.state); 
    } 
} 

function objectChainWrapper(obj) { 
    this.chain = function (fn) { 
     fn.call(obj); 
     return this; 
    } 

    for (var prop in obj) { 
     if (obj.hasOwnProperty(prop) && typeof obj[prop] == 'function') { 
      this[prop] = (function (methodName) { 
       return function() { 
        obj[methodName].call(obj); 
        return this; 
       } 
      }(prop)) 
     } 
    } 
} 

var obj = new myObj(); 
var wrapper = new objectChainWrapper(obj); 
var chainMethod = function(){ console.log('chain') }; 
var chainMethodState = function(){ console.log(this.state) }; 
wrapper.method1().method2().chain(chainMethodState).method3().chain(chainMethod).method4(); 

JSFIDDLE.

Answer 2

Ich bin überrascht, dass es keine Antworten auf diese um ehrlich zu sein.

Es gibt viele Möglichkeiten, die Verkettung nativ einzuführen. Ich benutze gerne die revealing module pattern.

So erstelle ich ein Basismodell (Gehen Sie weiter und schmeißen Sie dies in Ihrem Chrome Firefox Konsole)

var Dog = function(name) { 
    var self = this; 
    this.name = name; 


    var core = { 
      getName:function(){ 
       return self.name; 
      } 
     }; 

    this.movement = function(){  //this function will be exposed including its returned functions for chaining  
     console.log(self.name + " is getting restless... "); 

     var jump = function(){ 
      console.log(self.name + " jumps around "); 
      return this //returns the movement scope 
     }; 
     var run = function(){ 
      console.log(self.name + " has decided to run"); 
      return this //returns the movement scope 
     }; 

     return { 
      jump:jump, 
      run:run   
     }; 

    }  
    console.log("A Pup has been born, we shall call him... " + name); 
    return{ 
     movement:self.movement //only .movement is exposed to the outside world 
    }; 
    } 

Jetzt einen neuen Hund var p = new Dog("doggyName");

jetzt mit erstellen, können Sie Kettenfunktionen. Versuchen Sie:

Sie sollten die Konsole geloggten Text, der mit jeder Funktion entspricht.

Durch die Rückgabe des Bereichs nach der Ausführung Ihrer Bewegungsfunktion geben Sie die zusätzlichen Funktionen frei, die in diesem Bereich zurückgegeben werden (siehe die Kommentare im Code). Diese können dann am Ende Ihrer aktuellen Funktion angekettet werden, sofern sie sich im selben Umfang befinden. Auf diese Weise können Sie bestimmte Teile Ihres Codes umgrenzen. Zum Beispiel mit diesem Hund, alle Bewegung ist auf self.movement Bereich beschränkt, könnten Sie alle essen beschränkt auf self.eat und so weiter

Read up on the revealing module pattern. Obwohl dies nicht der einzige Weg ist, dies zu tun.