Why dice.roll and dice10.roll should be the same if they are passing a diferent argument? (sec. 26.)

Think of it as comparing code versus the output of the executed code. Here's a quick thing that you can try to see what I'm saying.

In your console, try typing the following:

dice.roll

Now, try typing:

dice.roll()

Without parenthesis, you're basically just comparing a method built in a constructor and one that's built as part of a prototype. This is why it evaluates to FALSE in the beginning because he's trying to show that it's not the same method being called when the method isn't built as part of a prototype.

With parenthesis, you're actually executing the method itself which returns a value. I believe this is what you were thinking would happen when it did the comparison with the console log method.

Ultimately, Andrew is basically just comparing different pieces of code. He's not comparing the output of that code, which would return different values if a die with a parameter of six and a die with a parameter of ten was passed to the method.

Hope that helps!

Both instances share the same roll method code.

Since the method is implemented as a prototype, instead of each instance having it's own copy of the method code, all instances share the same code.

That's why if you compare the methods for equality, the result is true.

It's not that the two instances of Dice are being compared, but the prototype method itself. Of course, you can't say that dice === dice10 because they are different instances with different side properties. However, both instances of Dice, and any other instances use the exact same prototype regardless.

dice.roll === dice10.roll
Dice.prototype.roll === Dice.prototype.roll 

It's pretty much the same. Kind of redundant, but it shows that prototyping is a bit more efficient.

Thanks, this confused me.