Is the Prototype property of an object, an object?

Question

I've read a lot of amazing articles and discussions (like this one) about prototype property of an object but there is a big question here. When we observe the behavior of "prototype" property we realize that it is actually another object. We can see it has its own proto and constructor properties just like an object.

var myobj= function(){};
myobj.prototype.constructor== myobj  --> true

So these are the questions :

1. Is "prototype" itself an object?
2. What is the relationship between prototype and the object it's related to (in this example myobj)?
3. Why myobj.prototype.__proto__ is by default the "Object{ }" but its constructor is myobj?
4. We know : "__proto__ is the actual object that is used in the lookup chain to resolve methods, etc. prototype is the object that is used to build __proto__ when you create an object with new". But we can see that this is not just what prototype does. I think : Prototype acts like a container object of all the shared methods and properties of an object! Then, when an instance of an object is created using new, its internal [[Prototype]] points to the prototype where the shared behaviors and properties of a class is exposed to the instances! Is this true?

In the end : It seems when we instantiate a class, the constructor of the instance is set to the constructor of the prototype of that object. Can this conclusion true?

var b= new myobj();
 b.constructor== myobj.prototype.constructor --> true
 b.constructor == myobj --> true
 myobj.prototype={};
 b.constructor == myobj  --> false
 b.constructor== Object --> true
 myobj.prototype.constructor== Object --> true

Answer 1

1. Yes, the prototype object is an object. It is implicitly constructed together with the function.
2. I wouldn't call that a "parent". Their only relation is that the myobj function does have a .prototype property with the prototype object as its value.
3. The prototype object does inherit from Object.prototype. It does have an own .constructor property with the myobj function as its value. (It's really just a property)
4. Yes, this is true. .__proto__ is a non-standard accessor to the internal [[Prototype]] field. As such, they are often used synonymous.
5. No, when you construct an instance, no .constructor property is set. All that happens is the new instance inherits from the prototype object, and the prototype object has that constructor property. Notice that the myobj.prototype={}; in your example has no effects on your previously constructed instances.

Answer 2

I know there is an accepted answer, but it seems there is some confusion as to what a prototype is, what a constructor function is, and how they interact.

Take this object for example:

var foo = {
  bar : 'hello',
  sayBar : function(){
    alert(this.bar);
  }
};

You can use it as it is, and as you would expect. You can reassign foo.bar and use the sayBar method without any issues:

foo.bar = 'Goodbye';
foo.sayBar(); //alerts(Goodbye);

Now say you need to have a bunch of objects that all need a bar property, but with different values. This is when you could create a constructor function to create unique instances:

var fooClass = function(newbar){
  this.bar = newbar;
};

Which can be invoked like so:

var myFoo = new fooClass('baz');
console.log(myFoo.bar); //logs 'baz'

Which can be broken down like this behind the scenes:

var fooClass = function(newbar){
  //**IF 'new' is declared ** create an instance object, for now it has no declared prototype other than Object's base prototype
  //That instance of the prototype is now scoped to 'this'

  //it sets the 'constructor' of the instance behind the scenes      
  //this.constuctor = [our constructor function]

  // now we can assign values to our instance and invoke it's methods

  this.bar = newbar;
  // our instance now has a key 'bar' that has the value of newbar


  // so our instance now looks like this:
  //
  // { 
  //  bar : [newbar]
  // }


  // return our instance object { bar : [newbar] }
};

This is where prototype objects come into play. Let's use our foo object as fooClass prototype:

var fooClass = function(newbar){
  this.bar = newbar;
};

fooClass.prototype = foo;

Now, as you'd expect, you can use foo's methods:

var myFoo = new fooClass('baz');
myFoo.sayBar(); //alerts baz

This is now what the constructor is doing:

var fooClass = function(newbar){
  //**IF 'new' is declared ** create an instance object, which uses foo as it's prototype
  //That instance of the prototype is now scoped to 'this'

  //it sets the 'constructor' of the instance behind the scenes      
  //this.constuctor = [our constructor function]

  // now we can assign values to our instance and invoke it's methods

  this.bar = newbar;
  // we have now overridden foo's default foo.bar with our instance bar


  // so our instance now looks like this:
  //
  // { 
  //  bar : [newbar], //overridden in constructor
  //
  //  //with access to foo's methods through the prototype chain
  //  sayBar : function(){
  //    alert(this.bar);
  //  }
  // }


  // return our instance object
};

There is nothing magical happening, all the constructor function is doing is creating and returning an object instance, and all .prototype = is doing is setting the prototype for that object.

What happens if I forget 'new'?

If you don't use new when using a constructor function, an new object instance is not created or returned. This why it's often checked to see if your current instance has the proper constructor:

var fooClass = function(newbar){
  if(!(this instanceof fooClass)){ //if this constructor != fooClass
    return new fooClass(newbar); //refire constructor with 'new'
  }

  //...
};