1

I cant understand the differences between the normal object and inheritance creation process and the whole prototype concept. Let's say I have this code:

function Person(name, age,location){
    this.name = name;
    this.age = age;
    this.location = location;
    this.greet = function(){
        return console.log(this.name + " says hi from "+this.location);
    }
}
    Person.prototype = {
        protoGreet: function(){
            console.log(this.name + " says 'that greeting was sent using a prototype'")
        }
    }

var alex = new Person("Alex",29,"earth");
var john = Object.create(Person);
//now I can set john's location john.location = "wherever";
  1. Whats the difference between greet and protoGreet methods. They both act completely the same.
  2. What is the difference between alex and john. One was created using the new keyword and the other one thru the prototype property of Person "class".
  3. I guess there's no right way because both are correct, but when should I prefer one method over the other?
Improve this question
4
  • 2
    There is a greet function created for every Person instance, whereas there's only one protoGreet function, which is shared between all instances. Commented Oct 1, 2014 at 17:43
  • generally, it's handy to code generic methods on the prototype and properties and protected methods in-constructor. if all objects need it, use proto, if only some do, do it in-constructor. Commented Oct 1, 2014 at 17:44
  • 1
    Object.create(Person) should be Object.create(Person.prototype), and then the difference is that none of the work done in the Person constructor will have been applied to the john object, unless you do Person.call(john, "John", 20, "mars") Commented Oct 1, 2014 at 17:44
  • 1. What do I care how many instances of greet are there? Performance? 2. What are the benefits of having only one shared instance of a certain method? 3. Under what circumstances I dont need/want/have to to use the original constructor? 4. In case I create an object using the Object.create(Person.prototype), where does the magic happen? In the constructor of Object? Commented Oct 1, 2014 at 18:15

1 Answer 1

Reset to default
2

Difference between prototype functions and object itself functions:
greet function: This function (all functions are objects) is inside of the instance object so each instance has its own greet function, as you can see in the picture.

protoGreet function: Located inside an independent object in the memory (the literal object in the picture) and is not owned by any instances of Person. But each instance of the Person has a hidden link (reference) to that object (this link is called __proto__). So this object is shared among all instances of the Person

enter image description here

What do I care how many instances of greet are there?

Memory optimization is an essence for all applications and actually there is no exceptions for web applications. So when a single shared object is adequate for your purpose, using separate object for each instance could violate this rule. But as performance point of view the first way (i.e greet function) can be faster than the second one (i.e protoGreet function) because a certain process called prototype chain lookup does not take place. Keep in mind that in this trade-off memory is the winner.

For your other questions, Seems you don't know what exactly is done by new keyword. So let me point you out to a side note.

Note: These steps is going to be done when you invoke a function with new keyword. Suppose we have the following function:

function Person (name, age) {
    this.name = name;
    this.age = age;
}
  • Create an empty literal object i.e {} (Note that the hidden __proto__ link of this object refers to the object represented by Person.prototype)
  • Invoke the function and substitute all this keywords with this emply literal object (In more technical words, this refers to that empty literal object).
  • The specified properties and methods will be added to that newly created object. (In this case name and age properties).
  • Finally that object implicitly will be returned from the function.

Now lets come back to your question, What's differences between Object.create(Person.prototype) and new Person() ?

Case new Person() was discussed earlier above. But Object.create(Person.prototype) creates an empty object and links its __proto__ to the first input argument object (In this case Person.prototype) and return that newly created object as output.

Okay, so far I hope that this notes clarify your problems, But if my answer still doesn't make sense let me know where's your problem.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

Thanks for your answer. Could you please refer to the following questions as well? 1. What do I care how many instances of greet are there? Performance? 2. What are the benefits of having only one shared instance of a certain method? 3. Under what circumstances I dont need/want/have to to use the original constructor? 4. In case I create an object using the Object.create(Person.prototype), where does the magic happen? In the constructor of Object?
thanks! still some things not entirely clear. The creation of an object is done via literal expression or the new keyword, but the inheritance is done by Object.create(Person.prototype) or for example jon=new Person()? When would I prefer to use one method over the other?
@undroid In my opinion object creation using new could be adequate in all major purposes. Also note that prototype chaining is also applied via new object creation (As I previously mentioned in my last update)

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.