如何使用承诺创建初始化函数？

Question

我需要一个只为一个模块调用一次的初始化函数。此函数是一个承诺，由执行函数调用。如果 execute 被调用两次，第二次必须等待初始化然后继续执行。

我写了这段代码，但是第二次调用 execute 总是在等待并且永远不会返回。我错过了什么？

var initialized = false;
var initializing = false;
var initializationPromise;

var init = function () {
    initializing = true;
    return q.promise(function (resolve) {
        // simulate initialization
        setTimeout(function () {
            // initialized
            initialized = true;
            resolve();
        }, 1000);
    }).fin(function () {
        initializing = false;
    });
};
var execute = function () {
    return q.promise(function (resolve, reject, notify) {
        if (initialized) {
            // already initialized
            resolve();
        } else {
            if (!initializing) {
                // initializing
                initializationPromise = init().then(function () {
                    // simulate execution
                    setTimeout(function () {
                        resolve();
                    }, 1000);
                }, function (reason) {
                    reject(reason);
                });
            } else {
                // Wait : initializing in progress
                return initializationPromise;
            }
        }

    });
};

execute().then(function () {
    // This is executed
});
execute().then(function () {
    // This is never executed
});

Answer 1

// Wait : initializing in progress
return initializationPromise;

不正确。这不会等待任何事情，它只是退出 q.promise 构造函数并且不做任何事情。此外，您似乎使用Promise constructor antipattern。

你应该做的是

var initialisationPromise = null;
function isInitialised() {
    return initialisationPromise != null && initialisationPromise.isFulfilled();
}
function isInitialising() {
    return initialisationPromise != null && initialisationPromise.isPending();
}

function init() {
    // init can be called as often as necessary, and returns when it's done
    if (initialisationPromise == null) { // do the test here!
        // this part runs only once
        initialisationPromise = q.promise(function (resolve) {
            // simulate initialization
            setTimeout(function () {
                // initialized
                resolve();
            }, 1000);
        });
    }
    return initialisationPromise;
}
function execute() {
    return init().then(function () {
        return q.promise(function(resolve, reject, notify) {
            // simulate execution
            setTimeout(function () {
                resolve();
            }, 1000);
        });
    });
}

Answer 2

已解决/已拒绝的 Promise 将保持其状态（已解决或已拒绝状态），因此您只能使用它来运行初始化代码一次。为此，init() 函数应该返回始终相同的承诺，而不是每次都创建它。

为此，我们在init() 方法之外创建一个延迟对象（initializationDeferred），并在每次调用init() 方法时使用initializationDeferred 返回相同的promise。我们还需要检查 init() 之前是否已经完成，如果在之前的调用中已经完成，我们使用共享变量 initializationStarted 跳过 setTimeout。

现在，在execute 内部，您可以确定then() 的onFulfilled 回调仅在init() 方法被初始化时被调用。

var initializationDeferred = Q.defer(); // Create here the deferred object so it's common to all init() invocations
var initializationStarted = false;

var init = function() {
  if (!initializationStarted) {
    initializationStarted = true;
    setTimeout(function() {
      // initialized
      console.log('Init timeout fired!');
      initializationDeferred.resolve(true); // Resolve the promise associated to the deferred object
    }, 1000);
  }

  return initializationDeferred.promise; // Return the promise associated to the deferred object
};

var execute = function() {

  return init().then(function(initialized) {
    // Here your module is initialized and you can do whatever you want
    // The value of "initialized" here is always "true"
    console.log('Execute: initialized?', initialized);
  });
};

execute().then(function() {
  // This is executed
  console.log('Execute First invocation');
});
execute().then(function() {
  // This is executed too
  console.log('Execute Second invocation');
});

<script src="http://cdnjs.cloudflare.com/ajax/libs/q.js/0.9.2/q.js"></script>