2

I have a problem node.js structure with javascript oop. I created a class using another class.

var base = function (name) {    
    this.Rows = new Array();    
};

var top = function (name) {
    this.name = name;   
};

top.prototype = new base();

var myClass = new top("");
myClass.Rows.push("a");
console.log(myClass.Rows);
var myClass2 = new top("test");
myClass2.Rows.push("b");
console.log(myClass2.Rows);

This code returns the following results;

[ 'a' ]
[ 'a', 'b' ]

but I do not have to be found by the algorithm as the result of this code?

[ 'a' ]
[ 'b' ]

Thank you for helping.

solved: i solved this problem. refactoring code;

var base = function (name) {
  this.Rows = new Array();
}

var top = function(name) {
  top.prototype.constructor.call(this, name);
  this.name = name;
}

top.prototype = Object.create(new base());

thanks for all.

Improve this question
1

2 Answers 2

Reset to default
6

That's how JavaScript's prototypical inheritance works.

This seems rather confusing to newcomers to the language :)

Both objects myClass and myClass2 have the same prototype (set in top.prototype = new base();)

This means when you access their Rows property since neither of them has one they access the one of their prototype. Since it's the same for both they both act on the same object. If you add the line console.log(myClass2.Rows); to the end of your code it would also output [ 'a', 'b' ]

Prototypical inheritance seems to confuse beginners because in classical languages if class A extends class B then all of A's properties are copied to B - this is not the case in JavaScript.

You can accomplish the same functionality if you refactor your code to the following:

var base = function () {    

};

base.prototype.getRows = function(){
    return this.rows;
}

var top = function (name) {
    this.name = name;   
    this.rows= [];    
};

top.prototype = new base();

var myClass = new top("");
myClass.getRows().push("a");
console.log(myClass.getRows());
var myClass2 = new top("test");
myClass2.getRows().push("b");
console.log(myClass2.getRows());

This would produce the 'classical' result you expect.

However, JavaScript's prototypical model focuses more on sharing functionality. I would probably refactor your code to:

var myClass = {Rows:[]},myClass2 = {Rows:[]};
Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

I want each row in the result set of a new object creation. so that the correct result ['a'] ['b'] I want to be. var base = function (name) { this.Rows = new Array (); }; / / var top = function (name) { / / This.name = name; / /}; / / top.prototype = new base (); var myClass = new base (""); myClass.Rows.push ("a"); console.log (myClass.Rows); var myClass2 = new base (""); myClass2.Rows.push ("b"); console.log (myClass2.Rows); the code in this way is the result correctly. the result is wrong in another class, the class has been generated.
@KiPSOFT I think your problem requires a bit of understanding of how JavaScript oop works, if you'd like to discuss to deeper detail how that works, you're welcome to visit chat.stackoverflow.com/rooms/17/javascript where I'd love to explain how JavaScript OOP design works :)
:) I understand better now. do you define the upper class. So I wanted to produce more than one class I'm using a subclass for each class re-definition of the Rows property have to do?
I would love an actual use case before suggesting other approaches. If you would like to learn more about JavaScript design patterns Addy Osmani has a great book on the subject addyosmani.com/resources/essentialjsdesignpatterns/book . I find that in practice I rarely resort to classical oop subclassing because I get the two major benefits in JavaScript without it (polymorphism - JS is dynamic, functionality sharing - prototyping). Sadly, building maintainable and correct JavaScript code is beyond the scope of a single SO question :-)
@KiPSOFT any luck? What did you end up doing?
2

Yes, prototypes are shared. I think you intended this type of inheritance:

var base = function (name) {
    this.Rows = new Array();
};

var top = function (name) {
    base.call(this,name); // this replaces your prototype
    this.name = name;
};

var myClass = new top("");
myClass.Rows.push("a");
console.log(myClass.Rows);
var myClass2 = new top("test");
myClass2.Rows.push("b");
console.log(myClass2.Rows);

call will invoke the function as if it was a method, so it will set up the object as base, then you override it with specific properties. As noted by nrabinowitz in the comments, this won't inherit any prototype methods.

Also my initial suggestion, which I quite like but it has no benefits over the above:

var top = function (name) {
    this.super=base; // these two lines replace your prototype
    this.super(name);
    this.name = name;
};

The method makes "base" into a member function, then calls it. It will set up "top" as a new "base" object, then customise it. I chose "super" as the variable name because it's similar to Objective C's style.

Improve this answer

5 Comments

This is an interesting approach (though note it doesn't support prototypical inheritance of base methods, just constructor setup). A more common JS idiom might be to use base.call(this) or base.apply(this, arguments) (if you needed to have common args between the constructors).
I hadn't thought of .call, and it would of course be better (faster, less variable pollution). I'll update it, though to be honest I quite like the "super" style!
This is pretty interesting :) . Note that the two lines you mentioned do not replace the prototype (it's still Object). What's even more confusing is that you're calling a function constructor like one would call a normal function. I would not recommend this approach as it seems to go against the prototypical nature of JavaScript but non-the-less it's a pretty interesting idea.
this is great work :) thanks for all. I need to know a little more javascript. :)
@BenjaminGruenbaum: I updated it with notes about the prototype already (I don't use prototypes often so it's not something I'd considered). But when Base's prototype isn't needed, I see no problem with this approach, and it's certainly a lot simpler and more intuitive than any others I've seen.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.