Are JavaScript ES6 Classes of any use with asynchronous code bases?

Question

What can ES6 Classes provide, as a pattern of organization, to asynchronous code. Below is an example with ES7 async/await, can an ES6-class have an asynchronous method, or constructor in ES7?

Can I do:

class Foo {     async constructor() {         let res = await getHTML();         this.res = res     } } 

And, if not how should a constructor work that does this?

class Foo {     constructor() {         getHTML().then( function (res) {             this.res = res         }     } } 

If neither of these patterns work, can a constructor (and moreover classes) in an ES6 class support any form of asynchronicity that operates on the object's state? Or, are they only for purely synchronous code bases? The above examples are in the constructor, but they don't need to be.. Pushing the problem down one more level..

class Foo {     myMethod () {       /* Can I do anything async here */     } } 

Or, with a getter...

class Foo {     get myProp() {         /* Is there any case that this is usefully asynchronous */     } } 

The only examples I could think of is to run something in parallel inside of the same method/constructor/getter, but to have the whole thing resolve before conclusion. I'm just confused because it seems with all the push to fully asynchronous libraries, this just serves to confuse things. Except for textbook examples, I can't find one application they're useful for.

Answer 1

Can I do async constructor()

No, that's a syntax error - just like constructor* (). A constructor is a method that doesn't return anything (no promise, no generator), it only initialises the instance.

And, if not how should a constructor work that does this

Such a constructor should not exist at all, see Is it bad practice to have a constructor function return a Promise?

Can ES6 classes support any form of asynchrony that operates on the object's state? Or, are they only for purely synchronous code bases?

Yes, you can use asynchronous methods (even with the proposed async syntax) on classes, and getters can return promises as well.

However, you will need to decide what should happen when a method is called while some asynchronous process is still active. If you want it to sequence all your operations, you should store your instance's state inside a promise for the end of that sequence that you can chain onto. Or, if you want to allow parallel operations, the best approach is to make your instances immutable and return a promise for another instance.

Answer 2

Another way that Classes can be useful for arranging asynchronous tasks is with the exclusive use of static methods.

class Organizer {     static async foo() {         const data = await this.bar();         data.key = value;         return data;     }     static async bar() {         return {foo:1, bar:2}     } };  Organizer.foo(); 

Of course, this is no different than creating a simple object literal, or a new file and including it, except you can more cleanly extend it.