Co to jest dobry wzorzec dla "interwału z przekroczeniem czasu" przy użyciu Promises

Question

Piszę kod do wykonania pollingu dla zasobu co N ms, który powinien upłynąć po M sekundach. Chcę, żeby cała ta obietnica opierała się na Bluebirdie tak bardzo, jak to możliwe. Rozwiązanie, do którego do tej pory doszedłem, wykorzystuje interwał węzła, anulowane obietnice Bluebirda i funkcję limitu czasu bluebirda.

Zastanawiam się, czy istnieje lepszy sposób na ograniczenie interwałów z bluebirdem i obietnicami w ogóle? Głównie upewniając się, że interwał zatrzymuje się w punkcie i nigdy nie trwa w nieskończoność.

var Promise = require('bluebird'); 

function poll() { 
    var interval; 

    return new Promise(function(resolve, reject) { 
    // This interval never resolves. Actual implementation could resolve. 
    interval = setInterval(function() { 
     console.log('Polling...') 
    }, 1000).unref(); 
    }) 
    .cancellable() 
    .catch(function(e) { 
     console.log('poll error:', e.name); 
     clearInterval(interval); 
     // Bubble up error 
     throw e; 
    }); 
} 

function pollOrTimeout() { 
    return poll() 
    .then(function() { 
     return Promise.resolve('finished'); 
    }) 
    .timeout(5000) 
    .catch(Promise.TimeoutError, function(e) { 
     return Promise.resolve('timed out'); 
    }) 
    .catch(function(e) { 
     console.log('Got some other error'); 
     throw e; 
    }); 
} 

return pollOrTimeout() 
    .then(function(result) { 
    console.log('Result:', result); 
    }); 

wyjściowa:

Polling... 
Polling... 
Polling... 
Polling... 
poll error: TimeoutError 
Result: timed out 

Answer 1

chciałbym zrobić coś takiego -

function poll() { 
    return Promise.resolve().then(function() { 
    console.log('Polling...'); 
    if (conditionA) { 
     return Promise.resolve(); 
    } else if (conditionB) { 
     return Promise.reject("poll error"); 
    } else { 
     return Promise.delay(1000).then(poll); 
    } 
    }) 
    .cancellable() 
} 

być także świadomi Promise constructor anti-pattern

Answer 2

Rene Wooller sprawia naprawdę dobry punkt:

Ostrzeżenie: niestety, rekurencja w javascript jak to będzie ostatecznie nasycić stos wywołań i prowadzić z wyjątkami pamięci

Nawet jeśli to nie wyjątek, to jest marnowana przestrzeń, a ryzyko związane z wyjątkiem może zachęcić do nadmiernego opóźnienia w odpytywaniu.

myślę, że jest na tyle ważne, aby wolą setInterval:

var myPromise = new Promise((resolve, reject) => { 
    var id = window.setInterval(() => { 
     try { 
      if (conditionA) { 
       window.clearInterval(id); 
       resolve("conditionA"); 
      } else if (conditionB) { 
       throw new Error("conditionB!"); 
      } 
     } catch(e) { 
      window.clearInterval(id); 
      reject(e); 
     } 
    }, 1000); 
}); 

Istnieje kilka pakietów KMP że adres ten wymóg, którego lubię promise-waitfor najlepszy. Ma 38 linii i wykonuje swoją pracę.

var myPromise = waitFor(() => { 
    if(conditionA) return true; 
    if(conditionB) throw new Error("conditionB!"); 
    return false; 
});