5 ms·

The "this" keyword in JS has very bad characteristics and is full of traps. I really wish we could stop building on top of this abomination (fake ES6 classes,

The "this" keyword in JS has very bad characteristics and is full of traps. I really wish we could stop building on top of this abomination (fake ES6 classes, binding, etc) The |> operator (chaining of regular functions) would be so much better to program with. We don't need both. https://github.com/mindeavor/es-pipeline-operator https://github.com/mindeavor/es-pipeline-operator

_greim_ 10y ago
It's a pipe dream though. I mean, I wish an omnipotent, omni-benevolent dictator would force everyone to stop using `this` and refactor it out of all existing code as much as the next guy, but until that happens, the best path forward is to pave the cow paths and make the ugly parts easier to deal with.
- spion 10y ago
  Its just not taught correctly. `this` is the hidden function argument passed by putting it left of the dot; from that, everything else follows.
  - groovy2shoes 10y ago
    Which is, of course, the same way `this` or `self` works in virtually every OO language. I honestly thought this was common knowledge, and not that hard to grasp. How else is `this` being taught?
    - drewgross 10y ago
      The difference is the JS has late binding. myObj.myMethod(); Has different semantics than var x = myObj.myMethod; x(); Which causes code like: myList.map(myObj.myMethod); to behave somewhat unintuitively.
      - groovy2shoes 10y ago
        Your examples don't need late binding to have different semantics — dynamic dispatch will suffice. That's not different from any other OO language (except perhaps in C++ for non-virtual methods). That's how we get polymorphism out of subtypes, after all: methods are resolved based on the dynamic value of the receiver at runtime, yielding single dynamic dispatch. Regardless of language, the `this` or `self` reference within a method always semantically behaves as if it were an additional parameter (except in typed languages where the variance under the subtyping relation is reversed, iirc), and is often implemented as such, albeit usually implicitly. Of course, late binding implies dynamic dispatch, but the reverse isn't true. On the other hand, almost every untyped OO language uses late binding (I can't even think of one that doesn't, off the top of my head...), as do some typed languages (those that target the .NET CLR, for example), so even with your stronger assertion JS far from unique in that regard. That behavior is standard fare for OO. If anyone finds it tricky, I find it more likely that the struggling programmer has yet to internalize OO than that JS is doing something strange (in this particular case, I mean... JS does plenty of strange shit otherwise ;) ).
        spion 10y ago
        The difference is that JS has no binding, yet it still allows for first class methods. Thus the OO "illusion" (object owns the methods) is broken: there are no methods, just functions that take an argument named `this`, in a slightly weird way, only when attached to records.
        groovy2shoes 10y ago
        > The difference is that JS has no binding ... just functions that take an argument named `this` Associating a name with a value is precisely what binding is. Frankly, though, I don't understand this comment at all. Care to clarify for me?
        prodigal_erik 10y ago
        In Python b = foo.bar b() correctly invokes the bar method of the foo object. In JavaScript, you have to write let b = foo.bar.bind(foo) because foo.bar gives you a function (not a method) that doesn't remember which object it came from.
    - _greim_ 10y ago
      > I honestly thought this was common knowledge For whatever reason it isn't common knowledge in JS-land. > How else is `this` being taught? Sadly it very seldom is taught this way. It tends to be a realization people come to after using the language for a while [1]. [1] https://twitter.com/greim/status/778793044174704640 https://twitter.com/greim/status/778793044174704640
vkjv 10y ago
At one point I had memorized the corner cases* of `this` for the pointless reason of stumping people who thought they knew it. The only thing it really taught me was to avoid it. *My favorite is "what does `this` point to when running `eval()`"? The current context. "What if you assign `eval` to a variable and then use that?" The global context.

_greim_ 10y ago

It's a pipe dream though. I mean, I wish an omnipotent, omni-benevolent dictator would force everyone to stop using `this` and refactor it out of all existing code as much as the next guy, but until that happens, the best path forward is to pave the cow paths and make the ugly parts easier to deal with.

spion 10y ago
Its just not taught correctly. `this` is the hidden function argument passed by putting it left of the dot; from that, everything else follows.
- groovy2shoes 10y ago
  Which is, of course, the same way `this` or `self` works in virtually every OO language. I honestly thought this was common knowledge, and not that hard to grasp. How else is `this` being taught?
  - drewgross 10y ago
    The difference is the JS has late binding. myObj.myMethod(); Has different semantics than var x = myObj.myMethod; x(); Which causes code like: myList.map(myObj.myMethod); to behave somewhat unintuitively.
    - groovy2shoes 10y ago
      Your examples don't need late binding to have different semantics — dynamic dispatch will suffice. That's not different from any other OO language (except perhaps in C++ for non-virtual methods). That's how we get polymorphism out of subtypes, after all: methods are resolved based on the dynamic value of the receiver at runtime, yielding single dynamic dispatch. Regardless of language, the `this` or `self` reference within a method always semantically behaves as if it were an additional parameter (except in typed languages where the variance under the subtyping relation is reversed, iirc), and is often implemented as such, albeit usually implicitly. Of course, late binding implies dynamic dispatch, but the reverse isn't true. On the other hand, almost every untyped OO language uses late binding (I can't even think of one that doesn't, off the top of my head...), as do some typed languages (those that target the .NET CLR, for example), so even with your stronger assertion JS far from unique in that regard. That behavior is standard fare for OO. If anyone finds it tricky, I find it more likely that the struggling programmer has yet to internalize OO than that JS is doing something strange (in this particular case, I mean... JS does plenty of strange shit otherwise ;) ).
      - spion 10y ago
        The difference is that JS has no binding, yet it still allows for first class methods. Thus the OO "illusion" (object owns the methods) is broken: there are no methods, just functions that take an argument named `this`, in a slightly weird way, only when attached to records.
        groovy2shoes 10y ago
        > The difference is that JS has no binding ... just functions that take an argument named `this` Associating a name with a value is precisely what binding is. Frankly, though, I don't understand this comment at all. Care to clarify for me?
        prodigal_erik 10y ago
        In Python b = foo.bar b() correctly invokes the bar method of the foo object. In JavaScript, you have to write let b = foo.bar.bind(foo) because foo.bar gives you a function (not a method) that doesn't remember which object it came from.
  - _greim_ 10y ago
    > I honestly thought this was common knowledge For whatever reason it isn't common knowledge in JS-land. > How else is `this` being taught? Sadly it very seldom is taught this way. It tends to be a realization people come to after using the language for a while [1]. [1] https://twitter.com/greim/status/778793044174704640 https://twitter.com/greim/status/778793044174704640

vkjv 10y ago

At one point I had memorized the corner cases* of `this` for the pointless reason of stumping people who thought they knew it. The only thing it really taught me was to avoid it. *My favorite is "what does `this` point to when running `eval()`"? The current context. "What if you assign `eval` to a variable and then use that?" The global context.