Tutorial zur JavaScript-Erweiterung – JavaScript-Vererbung in Cocos2d-JS

Die JavaScript-Sprache selbst stellt keine Klassen bereit und es gibt keinen Klassenvererbungsmechanismus in anderen Sprachen. Die Vererbung wird über den Prototyp des Objekts implementiert, dies kann jedoch die Anforderungen der Cocos2d-JS-Engine nicht erfüllen. Da die Cocos2d-JS-Engine aus Cocos2d-x hervorgegangen ist, wurden fast alle APIs in Cocos2d-HTML, der frühen Version von Cocos2d-JS, entwickelt, um die Cocos2d-x-API selbst zu simulieren, viele davon wurden in C++ geschrieben Objekte und Funktionen sind relativ komplex und die JavaScript-Sprache ist nicht in der Lage, sie zu beschreiben.
In der Open-Source-Community stellt John Resiq in seinem Blog (http://ejohn.org/blog/simple-j ... ance/) eine einfache JavaScript-Vererbungsmethode (Simple JavaScript Inheritance) bereit.
John Resiqs einfache JavaScript-Vererbungsmethode ist vom prototypischen Vererbungsmechanismus inspiriert. Sie hat das gleiche Klassenkonzept wie objektorientierte Objekte wie Java, und er hat die Stammklasse Klasse für alle Klassen wie folgt entworfen:

/* Simple JavaScript Inheritance  
 * By John Resig http://ejohn.org/  
 * MIT Licensed.  
 */  
// Inspired by base2 and Prototype  
(function(){  
  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;  
  };  
})();

Wie Object in Java erben alle Klassen direkt oder indirekt von Class. Das Folgende ist ein Beispiel für die Vererbung von Class:

var Person = Class.extend({                                             ①  
    init: function (isDancing) {                                                ②  
        this.dancing = isDancing;  
    },  
    dance: function () {                                                    ③  
        return this.dancing;  
    }  
});  
  
  
var Ninja = Person.extend({                                             ④  
    init: function () {                                                     ⑤  
        this._super(false);                                             ⑥  
    },  
    dance: function () {                                                    ⑦  
        // Call the inherited version of dance()  
        return this._super();                                               ⑧  
    },  
    swingSword: function () {                                               ⑨  
        return true;  
    }  
});  
  
  
var p = new Person(true);                                               ⑩  
console.log(p.dance());// true                                                
  
  
var n = new Ninja();                                                          
console.log(n.dance()); // false                                                  
console.log(n.swingSword()); // true

Wenn Sie mit der objektorientierten Natur vertraut sind der Java-Sprache sollte es leicht zu verstehen sein. Zeile 1 des Codes deklariert die Person-Klasse, die von Class erbt, und Class.extend() gibt an, dass sie von Class erbt. Zeile 2 des Codes definiert den Konstruktor init, der zum Initialisieren von Eigenschaften verwendet wird. Zeile 3 des Codes definiert die gewöhnliche Funktion dance(), die das Attribut dance zurückgeben kann.
Die Codezeile ④ deklariert, dass die Ninja-Klasse von der Person-Klasse erbt. Die Codezeile ⑤ definiert den Konstruktor init. In dieser Funktion ruft die Anweisung this._super(false) den Konstruktor der übergeordneten Klasse auf, um die Attribute zu initialisieren in der übergeordneten Klasse. Siehe Zeile ⑥ des Codes. Zeile 7 des Codes besteht darin, die Funktion dance() neu zu schreiben, wodurch die Funktion dance() der übergeordneten Klasse überschrieben wird. Zeile 8 des Codes lautet: this._super() ruft die dance()-Funktion der übergeordneten Klasse auf. Zeile 9 des Codes ist die neu hinzugefügte Funktion swingSword() der Unterklasse Ninja.
Zeile ⑩ des Codes erstellt das p-Objekt über die Person-Klasse und der Parameter für den Konstruktor ist wahr. Die erste Codezeile gibt das Tanzattribut des log p-Objekts aus und das Ergebnis ist wahr.
Die erste Codezeile erstellt das n-Objekt über die Ninja-Klasse. Die Parameter des Konstruktors sind leer. Die Standardinitialisierung verwendet false, um das Tanzattribut in der übergeordneten Klasse zu initialisieren. Zeile 1 des Codes gibt also false aus.
Diese einfache JavaScript-Vererbungsmethode implementiert tatsächlich den Vererbungs- und Polymorphismusmechanismus objektorientierter Konzepte im Allgemeinen. Diese einfache JavaScript-Vererbungsmethode ist der Kern des Cocos2d-JS-Vererbungsmechanismus. Die Vertrautheit mit der Verwendung der einfachen JavaScript-Vererbung ist sehr wichtig, um Cocos2d-JS zu verstehen.

Das Obige ist der Inhalt des JavaScript-Verbesserungs-Tutorials – JavaScript-Vererbung in Cocos2d-JS. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn).