Prototypal Model is much reliable and stronger compared to the classical model where you work with classes in languages like (C++ or Java). The prototypal model can provide more functionality and control over your base objects and their instances.
The prototype chain is a pointer chain where a child object points to its parent (the object it has been created from) and so on till it reaches the end of the chain where it ends with null.
The instance object shares the same prototype as the parent object this way the base object can forward properties and methods to its children (that's how inheritance works).
Take a look at the below diagram:
Foo also has a __proto__ property, this property points to the base prototype that is used to create the current Object (function). it plays the role of chain holder it maintains the chain so whenever you need to look for an inheritance to check a parent of a child instance you look under __proto__ property.
Both c and b __proto__ property point to Foo.prototype so c and b instances have access to all properties under Foo.prototype. The trick is if you want to add properties that get added to the inherited objects you can add them under the parent's prototype object.
So always remember there are two types of main properties to look at under objects for knowing inheritance:
If you would like to break the prototype chain you can simply set at any point in the chain (any object) it's __proto__ property to null so it thinks it is the end of the chain.