prototype, __proto__, and constructor properties

[robertpenner]

Wanted to share my own explanation of the prototype, __proto__, and constructor properties. This has suddenly become very clear to me recently, so I hope this helps someone.

To elaborate on __proto__ and prototype, they are similar, but not exactly the same. The difference is that __proto__ is a property of an object (usually a class instance), while prototype is a property of a constructor function. An object's __proto__ is a reference to its constructor's prototype.

Example:

// constructor for the Game class
function Game () {
// code
}

// create a method for the Game class
Game.prototype.printMe = function () {
trace "Game";
}

// create an object that's an instance of the Game class
chess = new Game();
chess.printMe() // output: "Game"

- now you have a class instance (chess) and a class constructor (Game)
- the name of the constructor function determines the name of the class
- the Game function is automatically given a prototype property
- we can use Game's prototype property to attach methods (like printMe)

So far so good? Onward...

- chess is created with the Game constructor, so it belongs to the Game class
- chess is automatically given a __proto__ property that points to the prototype property of Game
- this means that chess.__proto__ == Game.prototype

Some other info that's interesting:

1)
- Game.prototype has a __proto__ property as well
- Game.prototype.__proto__ == Object.prototype
- thus, chess.__proto__.__proto__ == Object.prototype

2)
- you can reference the Game constructor function with chess.__proto__.constructor
- suppose you wanted to make an object similar to chess, but you didn't know what class it belonged to
- you could make the object by accessing chess' constructor:
checkers = new chess.__proto__.constructor();

3)
- Game.prototype.constructor is the same as Game
- some people use something like "Game.prototype.constructor" in class inheritance
- it works, but it's redundant


[there's also a good explanation on p.269 of "Actionscript: The Definitive Guide" by Colin Moock]

[Mortimer Jazz]

Thanks Robert. I recently c&p'd little of your previous explanation of prototypes in to one of the messages here (I credited you for it so I hope you don't mind).

Thanks for the info on __proto__. I look forward to the day when I can understand it (heheh!)
Kind regards,
Mort

[red penguin]

in response to penner...thanks for the insight...I've been trying to nail these things down recently and you definitely have helped. You da man!

mort...moock does a good job with this in the book but it leaves you hanging. But with kind souls like penner here, we need not worry!

[Reflex]

This may be one of the most helpful threads I have read in a long time. Thanks for the simple explanation. Brilliant

[Ruben]

Excellent man! You really helped me out here

- Ruben

[Flash Gordon]

I have been trying to read about this stuff recently, and I just don't get it. Is there a dumbed-down version somewhere???

[senocular]

try:
http://www.kirupa.com/developer/oop/index.htm

[CyanBlue]

I am only wishing somebody can actaully carve that idea into my brain... My brain is just not equipped to handle OOP... It only goes OOPS...

[senocular]

You need to stop thinking that CB. I think you are your worst enemy when it comes to learning this stuff. It's really, at its core, not hard to understand at all and you are more than capable of understanding it.

[CyanBlue]

Yeah... I know... I've got to get that thought out of my brain and it is not that easy to do...
As I have said earlier, I think I sorta understand the concept of the OOP but I just cannot program in that manner(when I say in that manner, I am sorta talking about the AS2 class structure as well)... That's where the most of my problem lies, I guess...