this

The fat arrow can be used in different settings but it somehow doesn't always bind to the instance I want. The fat arrow binds at 3 occasions when declaring a method when declaring a function within a method when declaring a function in global context 1. When declaring a method When the Coffeescript compiler encouters the following syntactical pattern within a class declaration class A somemethod: (paramlist) => This will yield the following code within the constructor of class A this.somemethod = __bind(this.somemethod, this); That is the definition for that instance is overwriting the

Look into the following code: public class ClassA { private boolean ClassAattr = false; public ClassA() { ClassAHandler handler = new ClassAHandler(this); } } public class ClassAHandler extends GeneralHandler { ClassA ca = null; public ClassAHandler(ClassA classa) { this.ca = classa; } } I need to access ClassAattr on some ClassAHandler methods, among other attributes. Is there a way to do so without passing the origin class in the handler constructor. I don't really like how this solution "looks". Passing this to another method/object from inside the constructor can be rather dangerous. Many

I know about the general theory of this binding (function call site what matters, implicit, explicit binding, etc...) and the methods to solving the problem of this binding in React so it always points to what I want this to be (binding in constructor, arrow functions, etc), but I am struggling to get the inner mechanisms. Take a look at these two pieces of code: class demo extends React.component { goToStore(event) { console.log(this) } render() { <button onClick={(e) => this.goToStore(e)}>test</button> } } vs. class demo extends React.component { goToStore(event) { console.log(this) } render

var a = 1; var b = { a : 2, c : function () { console.log(this.a); } }; b.c(); // logs 2 (b.c)(); // logs 2 (0, b.c)(); // logs 1 The first is understandable, for "this" is pointed to Object "b". But why does the second one log the same result? I thought "this" should be pointed to the global execution context. And the third one, it seems that the comma operator influences the execution context. You really have a nice corner case there! My take on it: the first is straightforward. Just a standard call. The '.' operator lets you call the function setting b as the execution context. the second

I know this is probably painfully basic, but i am having a tough time wrapping my head around it. class Main { constructor() { requestAnimationFrame(this.update); //fine } update(): void { requestAnimationFrame(this.update); //error, because this is window } } It appears to be the case that I need a proxy, so lets say using Jquery class Main { constructor() { this.updateProxy = $.proxy(this.update, this); requestAnimationFrame(this.updateProxy); //fine } updateProxy: () => void update(): void { requestAnimationFrame(this.updateProxy); //fine } } But coming from an Actionscript 3 background, I