Q:

How prototype works in javascript?

I know that there is question already, but I have to make this clear.
function Animal(species) {
    this.species = species;
}
Animal.prototype.getSpecies = function() {
    return "Animal is " + this.species;
};

(function() {
    var animal1 = new Animal("Snake");
    var animal2 = new Animal("Wolf");
    var animal3 = new Animal("Tiger");
}());

And this is how I understand.

Function/Method getSpecies() is shared between all Animal objects in prototype object.
Did I understand correctly?
Is it correct to say that _Proto_ is pointer to prototype object ?
Thanks for help.

A:

Yes you are right, that is how it works! But __proto__ is not a pointer, it is a reference and its use is depricated. In Javascript real pointers do not exist, but references do.
If you create a Type that inherits from Animal like this:
function FastAnimal () {
    Animal.call(this, 'extreme-fast');
}

FastAnimal.prototype = Object.create(Animal.prototype);
FastAnimal.prototype.constructor = FastAnimal;
FastAnimal.prototype.getSpeed = function () { return '1MILLION'; };

var fa = new FastAnimal();

fa.getName = function () {}

Than a lookup for a property or Method in fa will go that way:

does fa has this OWN Property (as getName)
does it exist in FastAnimal.prototype (getSpeed)
does it exist in Animal

In general: This lookup goes on as long as there are prototypes on the way. However, that is what happens under the hood and called the prototype chain.
N.B.:
If you would like to loop over the properties of a given Object, there are two ways:
for (var prop in obj) {
    //do stuff
}

That includes properties of the prototype and normally not what people want, that's why
for (var prop in obj) {
    if (obj.hasOwnProperty(prop)) {
        //do stuff
    }
}

is a common pattern, BUT there is a new type of loop coming up and hopefully usable in the near future.
for (var prop of obj) {}

This one also explicitly excludes properties of the object’s prototype. 

