JavaScript - Inheritance

First class:
Code:

function ClassOne(){    
    this.events = [];
    this.executeEvents = [];
    this.addEvents = function(event){
        this.events.push(event);
    }
    this.addExecuteEvents = function(e){
        this.executeEvents.push(e)
    }
    this.getEvents = function(){
        return this.events;
    }
}

Second class:

Code:

function ClassTwo(){
    this.add = function(e){
        this.addEvents(e)
    }
}
ClassTwo.prototype = new ClassOne

Here the second class extends the first class,
now I want to create two objects of class two,
Code:

 var b = new ClassTwo();
 b.add('hello');
 var c = new ClassTwo();
 c.add('hi');
 console.log(c.getEvents())

I just added one event on b and c each, but when I logged the c.getEvents(), it returns both 'hi' and 'hello' events. why??
What am I doing wrong?? how to solve this problem??

Thanks in advance

please bear with my noobishness, but i've been trying for many hours to understand what is going on behind this code:


**
Code:

function Person() {
document.write('constructor: <br/>'+this.constructor); //displays Person constructor
this.name = "Rob Roberson";
this.age = 31;
}

function Employee() {
document.write('<br/>constructor: <br/>'+this.constructor); //displays Person constructor
this.dept = "HR";
this.manager = "John Johnson";
}

Employee.prototype = new Person();

var Ken = new Employee();

document.write('<br/>'+Ken.constructor); //displays Person constructor
document.write('<br/>name:'+ Ken.name + '<br/>age:' + Ken.age + '<br/>dept:' + Ken.dept + '<br/>manager:' + Ken.manager ); //displays all properties correctly

***

from what i've read, every object references a prototype. in this case, the Employee function will automatically reference a prototype with 'constructor' as its initial value. this command:

Employee.prototype = new Person();

will replace the Employee function's prototype to an instance of Person. so now Employee function's prototype will contain both name and age properties, BUT, and this is where i get lost, ITS CONSTRUCTOR PROPERTY GETS REPLACED! so how does:

var Ken = new Employee();

actually construct an instance of Employee if the reference to its constructor has been replaced by an instance of Person that only contains name and age properties? how is Ken ever initialized by Employee constructor?

Hi!

This is probably a classic inheritance thing...

I have two objects, C1 and C2. Both contains a callback method named 'callback'. Now, if I let C2 inherit from C1, then C1's 'callback' gets overridden by C2's. The problem is I still want C1's methods to access their own 'callback' method.

Is this possible, and is it "valid"? Am I headed down disaster lane here? Should I re-think and refactor?


Example:

Code:

function C1 () {};

C1.prototype.callback = function () {
	console.log('c1 called');
};

C1.prototype.call = function () {
	//do stuff
	this.callback();
};

function C2 () {};

C2.prototype = new C1();

C2.prototype.callback = function () {
	console.log('c2 called');
};


var obj = new C2();
obj.call();

Output:
c2 called Regards

Don

I posted this once, but it disappeared, and I have no notifications that I did anything wrong. I read the rules before posting and wasn't breaking any so I am not sure why it disappeared but here goes again.

I am trying to learn Javascript (particularly OOP) from a series of screencasts by Douglas Crockford. I have developed a theoretical "game" to build to illustrate it to myself better, and learn by example.

I must be misunderstanding how inheritance works, because my code is not producing the results I thought it would.

Here is what I have, followed by an explanation of my understanding.
Code:

$(function() {

function object(o) {
	function Funct() {}
	Funct.prototype = o;
	return new Funct();
}


soldier = {
      pointsCost: 0,
      movement: "1 Infantry Block",
      validTargets: {},
      weapons: {
			"Main Weapon": {
				"Weapon Type": "M4 Carbine",
				"Fire Range": 12
			},
			"Secondary Weapon": {
				"Weapon Type": "JCP .45",
				"Fire Range": 3
			}
		}
};

var rifleman = object(soldier); 
rifleman.pointsCost += 10;
rifleman.validTargets.target1 = "Infantry"
rifleman.weapons["Secondary Weapon"]["Weapon Type"] = "";
rifleman.weapons["Secondary Weapon"]["Fire Range"] = "";


var heavyGunner = object(soldier);
heavyGunner.pointsCost += 20;
heavyGunner.validTargets.target1 = "Infantry";
heavyGunner.validTargets.target2 = "Light Armor";
heavyGunner.weapons["Main Weapon"]["Weapon Type"] = "SAW M249";
heavyGunner.weapons["Main Weapon"]["Fire Range"] = 12;
heavyGunner.weapons["Secondary Weapon"]["Weapon Type"] = "";
heavyGunner.weapons["Secondary Weapon"]["Fire Range"] = "";
 
var sniper = object(soldier);
sniper.pointsCost += 30;
sniper.validTargets.target1 = "Infantry";
sniper.weapons["Main Weapon"]["Weapon Type"] = "Savage .308";
sniper.weapons["Main Weapon"]["Fire Range"] = 20;
sniper.weapons["Secondary Weapon"]["Weapon Type"] = "JCP .45";
sniper.weapons["Secondary Weapon"]["Fire Range"] = 3;

 
var demolitions = object(soldier);
demolitions.pointsCost += 30;
demolitions.validTargets.target1 = "Infantry";
demolitions.validTargets.target2 = "Light Armor";
demolitions.validTargets.target3 = "Artilery";
demolitions.validTargets.target4 = "Structures";
demolitions.weapons["Main Weapon"]["Weapon Type"] = "SMAW MK153";
demolitions.weapons["Main Weapon"]["Fire Range"] = 16;
demolitions.weapons["Secondary Weapon"]["Weapon Type"] = "M1014 Combat Shotgun";
demolitions.weapons["Secondary Weapon"]["Fire Range"] = 1; 


var infantry = { 

    rifleman: rifleman, 
    
    heavyGunner: heavyGunner, 
     
    sniper: sniper, 
     
    demolitions: demolitions 
 
};



console.log(infantry);

});

I start by creating an object function that accepts an object passed in, and sets it to the prototype of a constructor (that would allow me to create a new object linked to, and inheriting from, the initial passed in object)

I initialized a solider object literal, and pass that into the object function while creating 4 new objects (rifleman, heavyGunner, sniper, demolitions)
These four should inherit from and customize upon the soldier object.

The way I understood inheritance is that the new objects (example. rifleman) would inherit properties from the old object (i.e. soldier) and change or add properties, affecting only the new (rifleman) object but not changing the old(solider) object.

this works ok somewhat in my example, until it comes to nested objects.
In the above example I have objects as values for some Object's properties. (i.e. validTargets and weapons) When I change or add these, all of the new objects seem to inherit the last declarations, from demolitions, as if demolitions is actually changing that part of the soldier object so that the other's inherit those properties.

From my viewpoint, I expected these values to not be changed and that the 4 infantry types had no link to each other, but only to the soldier object.

I apparently misunderstood something, or coded something wrong.

Some minor notes:
-I will be updating most of the "string" values to be objects, so for instance, the validTargets value of "Infantry" would actually be the infantry object, stating that any of the 4 solider types would be a valid target.
- I intend to create weapons as their own viable objects in the future, and pass those objects instead of "strings"
- I intend to extend this (once this is working) to create an armor object that contains armor type units, similar in structure to the infantry object.
- If I can get this all to work, I may make this into a "simple" dice style battle game. but that is way off, I just want to get this nesting of objects to work with inheritance for now.

Thanks in advance for any help you can provide.
Here is a link to the "live" example. (not much different there except if you have firebug you can see the console.log method showing the objects, and how they are inheriting in properly from my POV.)

Link to Live example...


Blue

Hello,
I am new with Javascript and running into this problem that I don't understand.

I define a base class that only contains an array "elements", and a derived class that contains nothing more (for simplicity):

Code:

  function baseClass() {
     this.elements = new Array;
  }

  function derivedClass() {
  }
  derivedClass.prototype = new baseClass;

Then I create two instances of the derived class, and add two elements in each:

Code:

   a = new derivedClass();
   a.elements.push("A");
   a.elements.push("B");

   b = new derivedClass();
   b.elements.push("C");
   b.elements.push("D");

When I examine the contents of these arrays, I see that both a.elements and b.elements contain {"A","B","C","D"} ! I.e. as if the two arrays are in fact the same array! But these are two separate instances of the class, I expect two separate arrays.

Note that if instead I use the base class:

Code:

   a = new baseClass();
   a.elements.push("A");
   a.elements.push("B");

   b = new baseClass();
   b.elements.push("C");
   b.elements.push("D");

then I get a.elements = {"A","B"} and b.elements = {"C","D"}, as I would expect.

Could someone explain to me the problem with using the derived class?

Thank you,
Stephanos