Function object prototype

Question

function funcObj() { } 
funcObj.prototype.greet = "hello";
console.log(funcObj.greet) // undefined ???
console.log(funcObj.prototype.greet) // hello

var obj = new funcObj();
console.log(obj.greet); // hello

As per my understanding in prototype. If you access a member of an object it will get it from prototype object when not available in that object.

My questions is:

since functions in Javascript are objects why funcObj.greet -> undefined, but obj.greet -> hello?

Only constructor functions have a `.prototype` property, which is used when you call them with `new`. All objects do have a *prototype*, but this is not a property. — Bergi, Nov 29 '15 at 14:46

score 2 · Accepted Answer · edited Nov 29 '15 at 14:02

2

A prototype is nothing more than an object from which instances inherit properties.

So, funcObj is an instance of another prototype (the one of Function) from which it has inherited all the properties. Also, it has for itself a prototype on which you can bind whatever you want and that prototype will be used once you invoke it to construct new instances of funcObj (that is, when you invoke it along with the new keywork, as new funcObj()).

Because of that, it's perfectly normal that funcObj doesn't have a member called greet, while its instances have it.

edited Nov 29 '15 at 14:02

Danield

121,619
37
226
255

answered Nov 29 '15 at 13:34

skypjack

49,335
19
95
187

hence every function object itself is an instance from Function constructor. so if i add my property to Function.prototype it will shared by all function instances , is right ? – Vignesh Nov 30 '15 at 06:22
More or less. Actually, the scope to which the function is bound differs, it is the current *this* reference. – skypjack Nov 30 '15 at 06:51

score 0 · Answer 2 · answered Nov 29 '15 at 13:23

0

Because the function is a different object than the instance.

Putting a property on one object will not affect any other object; not even the function that that object or prototype is an instance of.

answered Nov 29 '15 at 13:23

SLaks

868,454
176
1,908
1,964

score 0 · Answer 3 · answered Nov 29 '15 at 15:15

Much like a class Foo is not itself the same type as a new Foo, there is no reason for Foo to have any properties you assign to Foo.prototype. The reasons are a little different, but consider it in another language like java and it's apparent that what you're trying to do just should not work:

class Foo {
    public String bar = "analogous to Foo.prototype.bar which is a property of Foo instances";
}

class Baz {
    String thisMethodShouldAndWillFail() {
        return Foo.bar;
    }
    String thisIsWhatShouldAndWillWork() {
        return (new Foo()).bar;
    }
}

In javascript, you need to correct your idea of what a prototype is and how it is related to objects and constructors, or you will run into problems continually. A foo has a prototype, but that prototype is not foo.prototype. There is no property of foo itself that is its prototype. The foo's prototype is determined by its constructor Foo; it makes more sense this way because you could assign any old value to foo.prototype after it is constructed, which breaks foo by turning it into an instance of a class for which it was not initialized.

The constructor Foo would similarly not make any sense if it would act as an instance of the class it defines; it has not been initalized by itself, so it cannot safely be assumed that it will fulfill the behavior intended for its instances. Foo is an instance of Function, which makes sense because it can be called. Therefore the prototype of Foo is Function.prototype, not Foo.prototype.

The relationship between a foo and its prototype is set up when you call foo = new Foo. Since the body of the constructor Foo is expected to initialize the instance, this is the only time to give foo its prototype that makes sense. The prototype provides an object its common behaviors, the constructor initializes the object so that these behaviors will work as intended. The prototype that is assigned to foo when it is constructed via new Foo is none other than Foo.prototype; this is done before Foo is executed for convenience and a guarantee that it cannot possibly be messed up. Following that, there is no way to access the prototype of foo without going through Foo explicitly.

enter code here

Function object prototype

3 Answers3