Hacker News Reader

Unfortunately, there are several problems with this approach:

1) You're creating a new function instance for `SomeClass.method` every single time you create an instance of SomeClass. This will slow down construction.

2) `method` is an instance property, not a prototype property, and so takes up more memory for a reference per instance, plus the memory of the function instance.

3) In that function instance, you're closing over the references to `someClass` and `arg1` even though they're already available in `method` as `this` and `this.arg1`, also increasing the memory of instances.

4) Setting method will cause an unnecessary hidden-class transition.

If you really want to hide `secretArg`, use a WeakMap:

    const secrets = new WeakMap();
    class SomeClass {

      constructor(arg1, secretArg) {
        this.arg1 = arg1;
        this.bar = undefined;
        secrets.set(this, secretArg);
      }

      method(foo) {
        this.bar = foo;
        const secret = secrets.get(this);
        secret.count++;
      }
    }

This will result in much lighter weight instances.

I understand there are some runtime implications but the vast majority of the "classes" created in my applications are instantiated once or only at startup. The memory usage and speed implications are negligible compared to the added maintainability.

In the grand scheme of all the allocation and computation taking place in my applications, these concerns are very far down the line.

Now, if you happen to be creating an application or framework that for some reason has to do a whole lot of allocating and might be meaningfully and measurably affected by such issues, then by all means use prototype "methods" when it will make a difference.

Personally, code clarity is much more important than making sure my application starts microseconds faster and allocates several bytes fewer per instance when there are only going to be ~10s of instances ever created.

As long as we are extremely clear of the implications it's a good enough reasoning.

Many people, especially newcomers, believe that just because their code initializes a class only N times it's being instanced exactly N times. This is false more often than not, especially in server environments.

I'd argue that adhering workaround for things that have language-level solutions nowadays hurts code clarity, if other people have to work with your code. Sure, the non-functional noise fades to the background when you're used to the pattern, but ES6 has been out for a while now, and it provides reasonable solutions.

Unless javascript removes alternate meanings of `this`, which will never happen, it does not have a language-level solution. In fact, I think it's easily as reasonable a solution as lambdas. I may be biased because I think ES6 is a hot mess, but the lack of `this` binding of lambdas is a serious misstep IMO.

If anything, ES6 lambdas add yet another way of interpreting `this` because while it is a function, it's not functionally scoped. Even better, a lambda is a function but `call` and `apply` are interpreted differently [1] since `this` is not bound. If you ever need to use `call` or `apply`, you'll have to know exactly how the called code is implemented to avoid bugs.

[1] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

> code clarity

This makes sense if it's only you working on a project, but it would be pretty confusing and weird for someone new to join.

What would be confusing and weird?

It being done nowhere else? Muscle memory? It looking non-standard and harder to parse?

The this/that antipattern is one reason I dislike the class pattern. I avoid it by using prototypes:

  SomeClass = function (arg1) {
    // Hopefully do something more interesting than this, indeed. :)
    this.arg1 = arg1;
  };

  /**
   * Assigns foo to the instance variable bar.
   */
  SomeClass.prototype.method = function (foo) {
    // Hopefully you do something more interesting than this, too!
    this.bar = foo;
  };


  someClass = new SomeClass();
  someclass.method(foo);

Then when I need a handler for a DOM element, I bind the instance to the method:

  someClass = new SomeClass();
  var handler = someclass.method.bind(someclass);
  $('.link').click(handler); // using jQuery as easy-to-read DOM shorthand; it's not required

Or if I'm creating the handler within the class:

  /**
   * Creates a click handler for <a class="link"> elements.
   */
  SomeClass.prototype.init = function () {
    var handler = this.method.bind(this);
    $('.link').click(handler);
  };

Over the years I've found it really easy to maintain code written like this. There's no callback hell, you don't even need Promises, and everything is easy to document. But often I find myself in an environment where I'm maintaining someone else's code, and I can't just refactor everything, so I grit my teeth and use 'that' or 'self'. I like your idea a lot better.

The main reason I've come to avoid prototypes in many cases (except when I really need to control memory) is that you can't keep any kind of information private (via closure) and share it across instance methods. It has to be a property on the instance, and is therefore accessible to anybody with access to the instance.

Conventions (like prefixing with _) are great, but they can only help loosely enforce encapsulation and provide no form of real privacy.

You can combine the two, creating a closure for private variables and using proper prototypes. The easiest way now is the ES2015 class keyword and its syntax, but for older versions of JS there are patterns and practices (and about a zillion helper libraries) to do so.

I just use factory functions that return an object that has arrow functions as properties, then I get private information via closures, and I don't have to worry about dealing with this.

https://www.youtube.com/watch?v=ImwrezYhw4w

Plus the prototype pattern is more idiomatic JS and combines better with other OO libraries than the class constructor pattern in top comment.

Also, the ES2015 class keyword is syntactic sugar for the best of both worlds of the prototype pattern, combined with the private variable support of the class pattern. It does the right thing with both `this` and `super` (which is possible but tough with the prototype pattern and nearly impossible or at least crazy tough to do right with the class constructor pattern) and is as useful/important to replacing that = this/self = this antipatterns as arrow functions are.

Why would you consider it an anti-pattern? To me, that term implies that an idiom has some sort of pitfall. Like using `==`, for instance. But `that = this` is actually pretty robust. Although, I'd say arrow functions are the better solution if all you need is a callback.

Pervasive usage of `bind` drives me mad. It can patch over problems if you're using it locally, but if a function is being passed around, it invisibly has different behavior from a normal function with dynamic `this`. It also is quite noisey, in my opinion.

Using methods of an object to contain the sequences of an async process is handy. But it's not as flexible as promises, because it only works if the async process is self-contained. Promises are far more composable, which is important for modular processes. And with `async` functions, they allow native flow control structures to cross async boundaries. By comparison, a the methods+callbacks approach feels like programing with GOTO in BASIC.

For some reason, this never occurred to me. This seems so much better than `that`, `self`, etc. Thanks for sharing.

I used to do that pattern just because it was the one I found when googling how to make classes in JavaScript back in 2011. It worked until I hit scaling issues and the inefficiency of it all caught up with me, and I had to learn the prototype pattern.

Personally, I think sticking to one pattern makes more sense than having to switch patterns and deal with the inconsistency of that depending on your performance use-case. I personally think the prototype pattern is nicer, too.

It's definitely not an antipattern. "Classes" as an ES6 concept make no sense unless member functions have a uniform notion of what "this" means. As a programmer, I don't want to think about what "this" is in the concept of an ES6 class.