4 ms·

When people say it behaves like an implicit first parameter, they’re not claiming it literally is a parameter/variable. Of course it’s a keyword. Of course you

When people say it behaves like an implicit first parameter, they’re not claiming it literally is a parameter/variable. Of course it’s a keyword. Of course you can’t assign to it. You’re writing long rebuttals to made up arguments. You’re also misusing terminology by saying `this` is “dynamically scoped” (it does not have dynamic scope[1], that would be terrible) when documents you’re quoting say “dynamically bound”. The difference is important, which is why three people have corrected you on that now. [1] https://en.wikipedia.org/wiki/Scope_(computer_science)#Dynamic_scoping https://en.wikipedia.org/wiki/Scope_(computer_science)#Dynam...

DonHopkins 7y ago
So do you agree with goto8 when he says ""this" has lexical scope just like regular parameters" and "Nevertheless, scope wise it behaves like an implicit parameter with lexical scope"? Explain just how "this" is lexically scoped, what "lexically scoped" means, and then explain why they had to add fat arrow to the language, if "this" is "just like regular parameters", please? If "this" is lexically scoped, then why can call and apply change it at runtime? And how do explain this stackexchange discussion, which directly addresses and answers the question? The detailed answer "yes" got five votes and was accepted. The other answer "no" got one vote and was not accepted. What's your answer? https://softwareengineering.stackexchange.com/questions/396148/is-this-in-javascript-an-example-of-dynamic-scoping https://softwareengineering.stackexchange.com/questions/3961... Question> Is `this` in JavaScript an example of dynamic scoping? Accepted Answer> To be clear, JavaScript does not, in fact, have dynamic scope. It has lexical scope. Plain and simple. But the this mechanism is kind of like dynamic scope. >The key contrast: lexical scope is write-time, whereas dynamic scope (and this!) are runtime. Lexical scope cares where a function was declared, but dynamic scope cares where a function was called from. >Finally: this cares how a function was called, which shows how closely related the this mechanism is to the idea of dynamic scoping. And you ironically wrote: >(it does not have dynamic scope[1], that would be terrible) Whatever you call it and however you define dynamic scope, the dynamic way "this" behaves IS terrible, and undeniably causes lots of easy to make, hard to diagnose bugs. That is why Brendan Eich called it a "footgun". That was my point, and that was why they had to add fat arrow to the language.
- goto11 7y ago
  Unfortunately, people voting on StackOverflow are not always correct. If you want the correct answer without guessing, you can check the ECMAScript spec itself: 8.3.2 GetThisEnvironment ( ) The abstract operation GetThisEnvironment finds the Environment Record that currently supplies the binding of the keyword this. GetThisEnvironment performs the following steps: 1. Let lex be the running execution context’s LexicalEnvironment. 2. Repeat a. Let envRec be lex’s EnvironmentRecord. b. Let exists be envRec.HasThisBinding(). c. If exists is true, return envRec. d. Let outer be the value of lex’s outer environment reference. e. Let lex be outer. NOTE The loop in step 2 will always terminate because the list of environments always ends with the global environment which has a this binding. Source: http://www.ecma-international.org/ecma-262/6.0/#sec-getthisenvironment http://www.ecma-international.org/ecma-262/6.0/#sec-getthise... This is pretty unambiguous. The "this" binding is resolved in the lexical scope, not the dynamic scope.
- minitech 7y ago
  > So do you agree with [goto11 that] ""this" has lexical scope just like regular parameters" and "Nevertheless, scope wise it behaves like an implicit parameter with lexical scope"? Yes. > Explain just how "this" is lexically scoped, what "lexically scoped" means, and then explain why they had to add fat arrow to the language, if "this" is "just like regular parameters", please? `this` is lexically scoped* because the function it belongs to is determined by where it appears in the code. Fat arrow was added to the language with this difference because it’s useful to have a function without its own `this`. > If "this" is lexically scoped, then why can call and apply change it at runtime? It’s always set at call time. Not a matter of scope. (Parameters: also have values determined at call time, also lexically scoped.) function a() { return this; } let obj = {a}; obj.a() === obj > And how do explain this stackexchange discussion, which directly addresses and answers the question? The detailed answer "yes" got five votes and was accepted. The other answer "no" got one vote and was not accepted. What's your answer? The answer is wrong despite its votes. The comment on it by JacquesB is correct: “This is confusing values and variables. this cares cares how a function is called the same way parameters care how a function is called - they get their value at runtime when the function is called. But the scope of all variables (including this) is lexical and not dynamic.” > Whatever you call it and however you define dynamic scope, the dynamic way "this" behaves IS terrible, and undeniably causes lots of easy to make, hard to diagnose bugs. That is why Brendan Eich called it a "footgun". That was my point, and that was why they had to add fat arrow to the language. I disagree, but am mostly here to argue against objectively wrong information rather than opinions. * in contrast to dynamically scoped. In JavaScript it’s also common to use “lexical scope” in contrast to “function scope” to distinguish `let`/`const` vs. `var`. In the JavaScript spec, the lexical thisMode refers to where the (arrow) function appears, not the position of the `this`.

DonHopkins 7y ago

So do you agree with goto8 when he says ""this" has lexical scope just like regular parameters" and "Nevertheless, scope wise it behaves like an implicit parameter with lexical scope"? Explain just how "this" is lexically scoped, what "lexically scoped" means, and then explain why they had to add fat arrow to the language, if "this" is "just like regular parameters", please? If "this" is lexically scoped, then why can call and apply change it at runtime? And how do explain this stackexchange discussion, which directly addresses and answers the question? The detailed answer "yes" got five votes and was accepted. The other answer "no" got one vote and was not accepted. What's your answer? https://softwareengineering.stackexchange.com/questions/396148/is-this-in-javascript-an-example-of-dynamic-scoping https://softwareengineering.stackexchange.com/questions/3961... Question> Is `this` in JavaScript an example of dynamic scoping? Accepted Answer> To be clear, JavaScript does not, in fact, have dynamic scope. It has lexical scope. Plain and simple. But the this mechanism is kind of like dynamic scope. >The key contrast: lexical scope is write-time, whereas dynamic scope (and this!) are runtime. Lexical scope cares where a function was declared, but dynamic scope cares where a function was called from. >Finally: this cares how a function was called, which shows how closely related the this mechanism is to the idea of dynamic scoping. And you ironically wrote: >(it does not have dynamic scope[1], that would be terrible) Whatever you call it and however you define dynamic scope, the dynamic way "this" behaves IS terrible, and undeniably causes lots of easy to make, hard to diagnose bugs. That is why Brendan Eich called it a "footgun". That was my point, and that was why they had to add fat arrow to the language.

goto11 7y ago
Unfortunately, people voting on StackOverflow are not always correct. If you want the correct answer without guessing, you can check the ECMAScript spec itself: 8.3.2 GetThisEnvironment ( ) The abstract operation GetThisEnvironment finds the Environment Record that currently supplies the binding of the keyword this. GetThisEnvironment performs the following steps: 1. Let lex be the running execution context’s LexicalEnvironment. 2. Repeat a. Let envRec be lex’s EnvironmentRecord. b. Let exists be envRec.HasThisBinding(). c. If exists is true, return envRec. d. Let outer be the value of lex’s outer environment reference. e. Let lex be outer. NOTE The loop in step 2 will always terminate because the list of environments always ends with the global environment which has a this binding. Source: http://www.ecma-international.org/ecma-262/6.0/#sec-getthisenvironment http://www.ecma-international.org/ecma-262/6.0/#sec-getthise... This is pretty unambiguous. The "this" binding is resolved in the lexical scope, not the dynamic scope.
minitech 7y ago
> So do you agree with [goto11 that] ""this" has lexical scope just like regular parameters" and "Nevertheless, scope wise it behaves like an implicit parameter with lexical scope"? Yes. > Explain just how "this" is lexically scoped, what "lexically scoped" means, and then explain why they had to add fat arrow to the language, if "this" is "just like regular parameters", please? `this` is lexically scoped* because the function it belongs to is determined by where it appears in the code. Fat arrow was added to the language with this difference because it’s useful to have a function without its own `this`. > If "this" is lexically scoped, then why can call and apply change it at runtime? It’s always set at call time. Not a matter of scope. (Parameters: also have values determined at call time, also lexically scoped.) function a() { return this; } let obj = {a}; obj.a() === obj > And how do explain this stackexchange discussion, which directly addresses and answers the question? The detailed answer "yes" got five votes and was accepted. The other answer "no" got one vote and was not accepted. What's your answer? The answer is wrong despite its votes. The comment on it by JacquesB is correct: “This is confusing values and variables. this cares cares how a function is called the same way parameters care how a function is called - they get their value at runtime when the function is called. But the scope of all variables (including this) is lexical and not dynamic.” > Whatever you call it and however you define dynamic scope, the dynamic way "this" behaves IS terrible, and undeniably causes lots of easy to make, hard to diagnose bugs. That is why Brendan Eich called it a "footgun". That was my point, and that was why they had to add fat arrow to the language. I disagree, but am mostly here to argue against objectively wrong information rather than opinions. * in contrast to dynamically scoped. In JavaScript it’s also common to use “lexical scope” in contrast to “function scope” to distinguish `let`/`const` vs. `var`. In the JavaScript spec, the lexical thisMode refers to where the (arrow) function appears, not the position of the `this`.