Classe imbriquée JavaScript

Question

Comment définir une classe imbriquée dans Java Script.

Voici l'extrait de code que j'ai:

objA = new TestA(); 

function TestB() 
{ 
    this.testPrint = function() 
    { 
    print (" Inside testPrint "); 
    } 
} 

function TestA() 
{ 
    var myObjB = new TestB(); 
} 

Maintenant, je suis en train d'accéder TestPrint à l'aide objA

objA.myObjB.testPrint(); 

Mais son erreur donnant "objA n'a pas de propriétés"

Comment puis-je accéder à la méthode testB en utilisant objA handler?

Answer 1

utilisation this.myObjB au lieu de var myObjB

Answer 2

Object literals:

var objA = { 
    myObjB: { 
     testPrint: function(){ 
      print("Inside test print"); 
     } 
    } 
}; 

objA.myObjB.testPrint(); 

Answer 3

Si vous essayez de faire de l'héritage, alors vous pouvez envisager le prototype mot-clé.

var myObjB = function(){ 
    this.testPrint = function() { 
     print (" Inside testPrint "); 
    } 
} 

var myObjA = new myObjB(); 
myObjA.prototype = { 
    var1 : "hello world", 
    test : function(){ 
     this.testPrint(this.var1); 
    } 
} 

(je l'espère, cela avait un sens)

Answer 4

Votre définition de TestA ne pas exposer les membres du public. Pour exposer myObjB, vous devez le rendre public:

function TestA() { 
    this.myObjB = new TestB(); 
} 
var objA = new TestA(); 
var objB = objA.myObjB; 

Answer 5

Si vous voulez que la définition du prototype des classes imbriquées internes ne pas être accessible depuis l'extérieur de la classe externe, ainsi qu'une mise en œuvre OO plus propre, prendre un regarde ça.

var BobsGarage = BobsGarage || {}; // namespace 

/** 
* BobsGarage.Car 
* @constructor 
* @returns {BobsGarage.Car} 
*/ 
BobsGarage.Car = function() { 

    /** 
    * Engine 
    * @constructor 
    * @returns {Engine} 
    */ 
    var Engine = function() { 
     // definition of an engine 
    }; 

    Engine.prototype.constructor = Engine; 
    Engine.prototype.start = function() { 
     console.log('start engine'); 
    }; 

    /** 
    * Tank 
    * @constructor 
    * @returns {Tank} 
    */ 
    var Tank = function() { 
     // definition of a tank 
    }; 

    Tank.prototype.constructor = Tank; 
    Tank.prototype.fill = function() { 
     console.log('fill tank'); 
    }; 

    this.engine = new Engine(); 
    this.tank = new Tank(); 
}; 

BobsGarage.Car.prototype.constructor = BobsGarage.Car; 

/** 
* BobsGarage.Ferrari 
* Derived from BobsGarage.Car 
* @constructor 
* @returns {BobsGarage.Ferrari} 
*/ 
BobsGarage.Ferrari = function() { 
    BobsGarage.Car.call(this); 
}; 
BobsGarage.Ferrari.prototype = Object.create(BobsGarage.Car.prototype); 
BobsGarage.Ferrari.prototype.constructor = BobsGarage.Ferrari; 
BobsGarage.Ferrari.prototype.speedUp = function() { 
    console.log('speed up'); 
}; 

// Test it on the road 

var car = new BobsGarage.Car(); 
car.tank.fill(); 
car.engine.start(); 

var ferrari = new BobsGarage.Ferrari(); 
ferrari.tank.fill(); 
ferrari.engine.start(); 
ferrari.speedUp(); 

// var engine = new Engine(); // ReferenceError 

console.log(ferrari); 

De cette façon, vous pouvez avoir héritage prototype et classes imbriquées afin que les classes définies dans BobsGarage.Car ne sont pas accessibles à l'extérieur du constructeur de BobsGarage.Car mais les instances d'entre eux sont accessibles aux classes dérivées, comme indiqué dans le test code. Note: Je fais référence au concept Classe dans Javascript comme défini sur le MDN.