Comment by Alan Plum on "To use or not to use ES6 classes?"

Use them where you would previously have used constructor functions with prototypes.

Don't use them just because "class" feels more authoritative than having a bunch of functions and objects.

Classes are a wonderful tool in JS and you should learn them, but just because you have a hammer that doesn't mean everything is now a nail. Try to figure out what works best and be aware of the caveats before deciding whether you need a class or not.

I think "purists" like Eric Elliott who try to pretend these language features don't exist and instead come up with their own convoluted inheritance systems have it wrong, but pretending JS is now Java simply because we have syntax that looks kinda like Java if you squint isn't the answer either.

The beautiful thing about inheritance in JS is that classical inheritance is just a special case of prototypal inheritance, the class syntax just codifies a common idiom by giving you syntactic sugar for it. But the most important thing to know about inheritance is that you rarely need inheritance. In the vast majority of cases you instead simply want composition.

I actually found myself object composition over inhertiance much simplier and never using prototypes anymore, except when you need polyfills which have new keyword / constructor function.

Object.assign() from ES6 is my 'class' keyword and there is still Object.create().

I agree with Eric Elliott about many arguments and he is not the only one. Here is Spotify engineer's YouTube channel I enjoy watching - https://www.youtube.com/watch?v=wfMtDGfHWpA

There are also many questions on Quora - quora.com/Are-ES6-classes-bad-for-JavaScript

I wouldn't have any questions if we would have not a 'class', but, let say 'prototype' keyword, but with much more support, because how classes are still implemented, is a joke, you can't get a constructor function name, for example.

Prototype MyInput extends HTMLInputElement {
    static readonly property1; // readonly - non-writable
    nonenum protected property2; // protected = non-configurable; for non-enumerable have no ideas :(
    set value(value) {
       parent:set.value = value; // call parent descriptor so browser would redraw, for example, native form controls
       // do custom logic
   }
   getName() {
      console.log(self.name); // self = this.prototype.constructor or any special object/keyword inside prototype/"class" containing information about prototype (class)
      // parent:parent:parent.doSomething() // call a method on prototype chain 3 levels deeper
   }
}

And now the most powerful feature of prototypes classes can't:

Extend MyInput {
    // same as Array.prototype.customMethod = function ... but don't need to write Array.prototype on each line
}

Or something like this.

Search Hashnode