You-dont-know-js: 'this' in JS and 'this' in C++ are exactly the same

[psxcode]

No confusion about JS's 'this'. It is exactly the same as in C++
Just look at the docs http://en.cppreference.com/w/cpp/language/this
in C++ an object does not contain any method.
They are just assigned to class.
When you invoke an object's method, it is being called with special __thiscall convention, and a special pointer (this) is being passed to method, which is a pointer to object, the method is being called against.
This allowes to modify an object within a method. If method is constant - 'this' is constant, so you cannot modify an object.
You can even invoke a method against uninitialized pointer to object, so 'this' will be 'nullptr', and if you don't touch any of object's properties - the program will not crash.
The only difference is that C++ does not allow to invoke a method against another class'es object.
But JS does.
You can invoke any function against any object in JS.
But for the rest - 'this' in JS and 'this' in C++ are exactly the same

[getify]

exactly the same

I don't buy that argument, but I'll concede there are similarities. The biggest difference is that JS's mechanism is dynamic, meaning at run-time you can swap out for a different object to be used for context. That's no small diff with a static lang like C++.

[psxcode]

As I can see, the main rule, the core mechanism for 'this' is implicit binding. Others are just extension features for that main rule.

In JS function do not belong to any object. Object only contains a references to functions
In C++ object do not contain a methods. Methods are assigned to class, and can be invoked only for instances of that class. This is language restriction. But again - methods are ordinary functions. The only difference is calling convention.

In JS you can force 'this' to contain reference to any object. (explicit binding)
In C++ you cannot. Maybe you can with some hacks with calling convention and __thiscall, then access members (read raw memory) by offsetting the 'this' pointer.

In JS you can pass reference to function to another object and invoke it with different context.
In C++ you can pass a pointer to a method to another object, but you cannot invoke it for that object. (with the pointer to a method you pass pointer to an object for which a method will be invoked when you call it by pointer)

But the core functionality is actually the same
In JS, when you invoke a function, 'this' is a reference to object for which a function is being called.
In C++ when you invoke a method, 'this' is a pointer to object for which this method is being called.

[getify]

But the core functionality is actually the same

You're arbitrarily calling one of the rules "the core" and everything else "extension features". That's fine for your opinion, but I don't see it that way. JS's this is different because it has these other flexibilities, which are actually the embodiment of _dynamic context_ instead of _static context_. As I said, IMO that's a huge thing. As a matter of fact, dynamic context is the only reason that this is even remotely interesting to me.

But anyway, this is just debate on opinions and semantic splitting. Probably not going to be very productive, and not really the point of this issue tracker. Thanks for your thoughts, though.

[psxcode]

Thank you for your comments. Actually your books are the only source of truth in JS world. I learned a lot from them. Thank you for sharing your knowledge.