@pregunta reformulada
Conozco la Promise. Los métodos proporcionan formas simples de resolver AND (&& => Promise.all ), OR (|| => Promise.any ) o Promise.race para pruebas cuando desea que la primera promesa devuelva un resultado, pero me gustaría entender la lógica de construcción y si es posible aprovechar objetos asíncronos para hacer estas operaciones en funciones asíncronas (algo así como la suposición a continuación)
¿Alguien puede darme una luz?
const test = (time, response_value) => new Promise((resolve, reject) => { setTimeout(resolve, time, response_value); }); (async () => { //returns the first result that returns true console.log( await (test(Math.random()*500, 'one') || test(Math.random()*500, 'two')) ); //returns the last promise if the first returns true console.log( await (test(Math.random()*500, parseInt(Math.random()*2)) && test(Math.random()*500, 'two')) ); //returns the fastest result //??? })();Simplificando parte del código, estás preguntando sobre estos casos:
await (promiseA || promiseB || promiseC) // vs await (promiseA && promiseB) Es casi seguro que ambos no son lo que quieres hacer. El primero comenzará evaluando promiseA || promiseB || promiseC . Las promesas son objetos y los objetos son verdaderos , por lo que la primera parte de || es suficiente para satisfacerlo. Entonces, este cálculo da como resultado la promiseA y el código termina await promiseA con algunos efectos secundarios. Solo se esperará la promesa A, y solo contribuirá a la declaración de registro.
El segundo comienza evaluando promiseA && promiseB . Los objetos de promesa vuelven a ser verdaderos, y el operador && significa que este cálculo dará como resultado promiseB . Entonces terminas haciendo await promiseB .
Lo que muy probablemente quisiste hacer es usar || y && en los valores dentro de las promesas, no en las promesas mismas. Para hacer eso, deberá esperar todas las promesas y luego hacer una comparación con los valores resultantes. Así por ejemplo:
const a = await promiseA; const b = await promiseB; const c = await promiseC; console.log(a || b || c);O para hacerlo en paralelo:
const [a, b, c] = await Promise.all([promiseA, promiseB, promiseC]); console.log(a || b || c);Si desea probar cosas, probablemente no debería usar valores aleatorios, ya que esto no le dará resultados reproducibles que sean fáciles de entender.
Como ya dijo la otra respuesta, las promesas son objetos, por lo que promiseA || promiseB y promiseA && promiseB funcionan en esos objetos y no en los valores a los que posiblemente se resuelvan.
La await en await (promiseA || promiseB) y await (promiseA && promiseB) se aplica sobre el resultado de la evaluación de promiseA || promiseB (que es promiseA ) o de promiseA && promiseB (que siempre es promiseB )
Si desea trabajar en los valores que resuelven las Promesas, debe mover la await a las Promesas directamente:
async function run() { console.log(await Promise.resolve(0) || await Promise.resolve(1)) console.log(await Promise.resolve(0) && await Promise.resolve(1)) } run(); El comentario //returns the faster (but not) indica que buscas Promise.race() :
const test = (time, response_value) => new Promise((resolve, reject) => { setTimeout(resolve, time, response_value); }); (async() => { console.log(await Promise.race( [ test(300, 'one'), test(200, 'two'), test(100, 'three') ] )); })() El comentario //returns two if the first returns true indica que desea: await Promise.resolve(true) && await Promise.resolve('two')
async function run() { console.log(await Promise.resolve(true) && await Promise.resolve('two')) console.log(await Promise.resolve(false) && await Promise.resolve('two')) } run();