Dev Faq
-1
votes

Mise en œuvre possible de la promesse.

En promesse.Race La promesse revient dès que la promesse principale revient. Dans la promesse.Tous les retours lorsque toutes les promesses résolvent, mais durent un problème. Si l'une de toutes les promesses rejette tous les autres sera rejetée.

au lieu de cela, existe un Proposition A> Pour une promesse.Toute, le retourne toutes les promesses seules, indépendantes de l'autre, sans bloquer la boucle d'événement. P>

EX: P> 

const logAfterWait = (seconds) => new Promise((resolve, reject) => {
    return setTimeout(() => resolve(console.log(`${time} time passed`)), seconds)
}) 

const watingList = [
    logAfterWait(convertToSeconds(10)),
    logAfterWait(convertToSeconds(30)),
    logAfterWait(convertToSeconds(5))
]

const logReading = async (fn) => {
    console.log(`${time}: reading file`)
    await fn()
}

const readFiles = (files) => Promise.all(watingList.map(logReading))
    .catch((error) => new Error(error))

5 commentaires

Je suis désolé, mais je n'ai pas votre question. Quels résultats obtenez-vous et quel résultat espérez-vous ? Et comment est la promesse.

Et il n'y a pas de "bloc d'IO" du tout.

Sur promis.Tous.

" promis.any, le retourne toutes les promesses seules, indépendantes de l'autre, " - non, ce n'est pas ce que promets.any fait. Cela fonctionne juste comme promess.race , à l'exception du court-circuit sur un rejet - il attend le premier accomplissement et renvoie une seule promesse pour ce résultat.

Il manque une notation à ce sujet.

3 Réponses :

0
votes

Vous pouvez exploiter le fait que promesse.race code> forme un monoïde en créant un prometteur code> qui ne règle jamais:

p> 

const empty = x => new Promise((res, rej) => x); // never settling promise

const ps = [
  Promise.reject(1).catch(empty),
  Promise.resolve(2).catch(empty),
  Promise.resolve(3).catch(empty)];

Promise.race(ps)
  .then(console.log); // 2

0 commentaires
0
votes

Vous pouvez penser à quelque chose comme ceci:

p> 

// a solution might just be not using async/await
const any = (promises) => new Promise((resolve, reject) => {
  let errors = [];
  let resolved;
  
  const onFulfill = (value) => {
    // skip if already resolved
    if (resolved) { return; }
    resolved = true;
    
    // resolve with the first available value
    resolve(value);
  };
  
  const onError = (error) => {
    // skip if already resolved
    if (resolved) { return; }
    
    // collect error
    errors = errors.concat(error);
    
    // reject promise combinator if all promises are failed
    if (errors.length === promises.length) {
      reject(errors);
    }
  };
  
  return promises.forEach((promise) => promise.then(
    onFulfill,
    onError,
  ));
});

const sleep = (ms) => new Promise(r => setTimeout(() => r(ms), ms));
const err = (ms) => sleep(ms).then(() => Promise.reject(ms));

// it would log 2000, since it is the first to resolve
any([sleep(3000), err(100), sleep(2000)]).then(console.info)


// it would an array of 2 failures
any([err(50), err(60)]).catch(console.error)

1 commentaires

Salut @hitmands. La question est de se connecter lors de la résolution, au lieu de bloquer toutes les promesses jusqu'à ce que la dernière résolution. Dans cet exemple, le résultat est similaire à la promesse.Race.

0
votes

Par conséquent, je suis arrivé à une conclusion. Sur la liste d'attente, au lieu d'une promesse, devrait être un monoïde qui réponde à la [gauche, à la rigth], en utilisant cette valeur pour manipuler les erreurs, la diminution des blocs de capture et la journalisation lors de la résolution. 

const time = () => `${new Date().getHours()}:${new Date().getMinutes()}:${new Date().getSeconds()}`;

const sleep = (ms) => new Promise((resolve, reject) => {
    return setTimeout(() => resolve(console.log(`${time()} time passed`)), ms)
}).catch(console.error)

const err = (ms) => new Promise((resolve, reject) => {
    return setTimeout(() => reject(console.log(`${time()} time passed`)), ms)
})

const watingList = [
    sleep(0).catch(console.error),
    sleep(3000).catch(console.error),
    sleep(5000).catch(console.error),
    err(5000).catch(console.error)
]

const logReading = (fn) => {
    return fn.then(console.log(`${time()}: reading file`))
        .catch(console.error)
}

0 commentaires

Articles qui pourrait vous intéresser :

Impossible d'importer le module "@ angular / material"
Interaction profonde avec break and catch
Utilisation de node.js comment renommer tous les fichiers d'un dossier
Google Chrome Uncaught (promis) DOMException lors de la lecture AUDIO