asynchronous - nodejs - static class javascript

¿Son las clases JavaScript ES6 de algún uso con bases de código asíncrono?

Question

¿Qué pueden proporcionar las clases ES6 , como patrón de organización, al código asincrónico? A continuación se muestra un ejemplo con ES7 async / await, ¿puede una clase ES6 tener un método asincrónico o un constructor en ES7?

Puedo:

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

Y, si no, ¿cómo debería funcionar un constructor que hace esto?

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

Si ninguno de estos patrones funciona, ¿puede un constructor (y además clases) en una class ES6 soportar cualquier forma de asincronía que opere en el estado del objeto? ¿O son solo para bases de código puramente sincrónicas? Los ejemplos anteriores están en el constructor, pero no es necesario que lo estén ... Empujando el problema un nivel más hacia abajo ...

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

O, con un captador ...

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

Los únicos ejemplos que se me ocurren es ejecutar algo en paralelo dentro del mismo método / constructor / getter, pero que todo se resuelva antes de la conclusión. Estoy confundido porque parece que con todo el empuje hacia bibliotecas completamente asíncronas, esto solo sirve para confundir las cosas. Excepto por los ejemplos de libros de texto, no puedo encontrar una aplicación para la que sean útiles.

Answer 1

¿Puedo hacer async constructor()

No, es un error de sintaxis, al igual que el constructor* () . Un constructor es un método que no devuelve nada (sin promesa, sin generador), solo inicializa la instancia.

Y si no, ¿cómo debería funcionar un constructor que hace esto?

Tal constructor no debería existir en absoluto, ver ¿Es una mala práctica hacer que una función de constructor devuelva una Promesa?

¿Pueden las clases ES6 soportar cualquier forma de asincronía que opera en el estado del objeto? ¿O son solo para bases de código puramente sincrónicas?

Sí, puede usar métodos asincrónicos (incluso con la sintaxis async propuesta) en las clases, y los captadores también pueden devolver promesas.

Sin embargo, tendrá que decidir qué sucederá cuando se llame a un método mientras algún proceso asincrónico aún está activo. Si desea que secuencia todas sus operaciones, debe almacenar el estado de su instancia dentro de una promesa para el final de esa secuencia que pueda encadenar. O, si desea permitir operaciones paralelas, el mejor enfoque es hacer que sus instancias sean inmutables y devolver una promesa para otra instancia.

Answer 2

ECMAScript 2017 pretende ser clases de métodos asíncronos.

¡Invocar otra función asíncrona o de devolución de promesas es muy sencillo!

El código altamente expresivo lee sin interrupción de arriba a abajo, independientemente de la ejecución diferida

Si tiene devoluciones de llamada, controladores de errores alternativos, ejecución paralela u otras necesidades no satisfechas, cree promesas en el cuerpo de la función. Es mejor tener código en el cuerpo de la función en lugar de un ejecutor de la promesa, y tenga en cuenta que no hay un código de devolución de llamada de prueba try-catch: haga lo siguiente a nada.

El método asíncrono puede devolver una promesa, un valor regular o arrojar

Los apis de devolución de llamada que la gente de Node.js solía amar, ahora odiaremos con pasión: todos deben estar envueltos en promesas

La belleza de async / waitit es que los errores surgen implícitamente

class MyClass {
  async doEverything() {
    const sumOfItAll = await http.scrapeTheInternet() +
      await new Promise((resolve, reject) =>
        http.asyncCallback((e, result) => !e ? resolve(result) : reject(e)))
    return this.resp = sumOfItAll
  }
}

Si se limita a ECMAScript 2015 y no asíncrono, devuelva los valores prometidos:

class ES2015 {
  fetch(url) {
    return new Promise((resolve, reject) =>
      http.get(url, resolve).on(''error'', reject))
      .then(resp => this.resp = resp) // plain ECMAScript stores result
      .catch(e => { // optional internal error handler
        console.error(e.message)
        throw e // if errors should propagate
      })
  }
}

Esta versión de ECMAScript 2015 es lo que realmente está preguntando, cualquier comportamiento deseado puede codificarse utilizando la construcción de promesa devuelta.

Si realmente, realmente desea ejecutar promesas en el constructor, es una buena idea pasar las funciones de captura o proporcionar alguna construcción de devolución de llamada para que los consumidores puedan tomar medidas para cumplir o rechazar las promesas. En el constructor, también es una buena práctica esperar a nextTick / .then antes de hacer un trabajo real.

Toda promesa necesita una captura final o habrá problemas

Answer 3

Esta es una respuesta tardía, pero la razón por la que su segundo ejemplo no funciona es debido a un error de contexto. Cuando pasa una function () {} como argumento a Promise.prototype.then() , el léxico this dentro de la función será la función misma, y ​​no la clase. Es por eso que configurar this.res parece no hacer nada: this , en ese caso, se refiere al alcance de la función.

Hay varias formas de acceder a un alcance externo en Javascript, la clásica (que se ve abundantemente en el código ES5) es:

class Foo {
  constructor() {
    var _this = this

    getHTML().then(function (res) {
      _this.res = res
    })
  }
}

Al hacer referencia a la clase this , puede acceder a ella en ámbitos internos.

La forma de hacerlo de ES6 es usar funciones de flecha , que no crean un nuevo alcance, sino que "mantienen" el actual.

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

Aparte de las preocupaciones de contexto, en mi opinión, este todavía no es un patrón asíncrono óptimo, porque no tiene forma de saber cuándo getHTML() ha finalizado, o peor aún, ha fallado. Este problema se resuelve elegantemente con funciones asíncronas . Aunque no puede hacer un async constructor () { ... } , puede iniciar una promesa en el constructor y await en las funciones que dependen de él.

Ejemplo de una propiedad asíncrona en un constructor de clases.

Answer 4

Otra forma en que las clases pueden ser útiles para organizar tareas asincrónicas es con el uso exclusivo de métodos estáticos .

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();

Por supuesto, esto no es diferente a crear un simple objeto literal, o un nuevo archivo e incluirlo, excepto que puede extend más limpiamente.