¿Cómo no olvidar el uso de waitit en todas partes en Javascript?

asynchronous async-await

Question

Intentando escribir una pequeña extensión de Chrome, que se basa en las funciones de consulta de la interfaz de chrome.* , Rápidamente llegué a las promesas y async / wait, ya que necesitaba garantizar el orden de ciertas operaciones, mientras trataba de evitar la devolución de llamada infierno

Sin embargo, una vez que introduje async / wait en algunas funciones, todas las funciones que las usaron también tuvieron que convertirse en una async function para poder await el valor de retorno. Finalmente, incluso algunas constantes globales se convirtieron en promesas, por ejemplo

const DEBUG = new Promise(function(resolve){
    chrome.management.getSelf(resolve);
}).then(function(self){
    return self.installType == ''development'';
});

Sin embargo, ahora necesito escribir en await todas partes e introducir errores extraños como if(DEBUG){...} siempre se ejecuta se vuelve demasiado fácil.

Si bien parece posible identificar los errores utilizando ESLINT , escribir en await todas partes parece innecesariamente engorroso y, por lo tanto, me preguntaba si Javascript tiene una construcción mejor que me estoy perdiendo.

(Subjetivamente, mi uso actual de wait / async parece inverso; las promesas se mantienen tal cual, a menos que se esperen explícitamente, pero me parece más deseable que las promesas se esperen por defecto en las funciones asincrónicas y se mantengan como promesas desnudas solo cuando se solicite explícitamente).

Answer 1

Por la falta de un sistema de tipos que permita detectar fácilmente tales errores (¿consideró Typecript o Flow?), Puede usar la notación húngara de sistemas para sus nombres de variables. Elija un prefijo de sufijo como P , Promise o $ y agréguelo a todas sus variables de promesa, de forma similar a cómo las funciones asíncronas a menudo se nombran con un sufijo asíncrono. Entonces solo haz cosas como

const debug = await debugPromise

donde puede ver rápidamente if (debug) está bien pero if (debugPromise) no.

Una vez que introduje async / await en algunas funciones, cada función que las usaba también tenía que convertirse en una función asincrónica para poder esperar el valor de retorno. Finalmente, incluso algunas constantes globales se convirtieron en promesas

Yo no haría eso. Intente hacer que la menor cantidad de funciones sea lo más asíncrona posible. Si no están haciendo cosas intrínsecamente asíncronas, sino que solo se basan en los resultados de algunas promesas, declare esos resultados como parámetros de la función. Un simple ejemplo:

// Bad
async function fetchAndParse(options) {
    const response = await fetch(options);
    // do something
    return result;
}
// usage:
await fetchAndParse(options)

// Good:
function parse(response) {
    // do something
    return result;
}
// usage:
await fetch(options).then(parse) // or
parse(await fetch(options))

Se puede aplicar el mismo patrón para los globales: ya sea que sean parámetros explícitos de cada función o que sean parámetros de una función de módulo que contenga todos los demás como cierres. Luego, await las promesas globales solo una vez en el módulo, antes de declarar o ejecutar cualquier otra cosa, y luego use el valor de resultado simple.

// Bad:
async function log(line) {
    if (await debugPromise)
        console.log(line);
}
async function parse(response) {
    await log("parsing")
    // do something
    return result;
}
… await parse(…) …

// Good:
(async function mymodule() {
    const debug = await debugPromise;
    function log(line) {
        if (debug)
            console.log(line);
    }
    function parse(response) {
        log("parsing")
        // do something
        return result;
    }
    … parse(…) …
}());