AngularJS：使用前/后解析/拒绝操作来增强或包装承诺

2 回答

• 3

  这是我在 Possible Solution 部分中提出的解决方案，因此可以对其进行详细讨论 .

  我've considered copying the original promise, but then overwriting the new one' s then 函数有一个解决原始承诺的实现，但这样安全吗？

  New Example

  function _enhancePromiseWithQueuing(promise, id) {
    // Copy the old promise and overwrite its then method.
    var enhancedPromise = angular.copy(promise);
    enhancedPromise.then = function(resolve, reject) {
      // Resolves the original promise once the existing `id` queue is clear.
      queue.enqueueRequest(id, function() { promise.then(resolve, reject); });
      return this;
    };
    return enhancedPromise;
  }
  

  Example 1 （来自上方）

  function _enhancePromiseWithAutoRetry(promise) {    
    // Copy the old promise and enhance it with the withAutoRetry method.
    var enhancedPromise = angular.copy(promise);
    // Add a function that enables 503 Retry-After handling when called.
    enhancedPromise.withAutoRetry = function(onRetry, timeout) {
      // Copy the old promise and overwrite its then method.
      var promiseWith503Handling = angular.copy(this);
      promiseWith503Handling.then = function(resolve, reject) {
        // Call the original promise then method with a modified reject handler.
        return this.then(resolve, get503Handler(this, resolve, reject,
                                                onRetry, timeout, new Date()));
      };
      return promiseWith503Handling;
    };    
    return enhancedPromise;
  }
  

  Example 2 （来自上方）

  function _enhancePromiseWithCache(promise, cacheGet, cachePut) {
    var enhancedPromise = angular.copy(promise);
    enhancedPromise.then = function(resolve, reject) {
      // Check if the value is cached using the provided function
      var cachedResponse = cacheGet !== undefined ? cacheGet() : undefined;
      if(cachedResponse !== undefined){
        return resolve(cachedResponse);
      } else {
        // Resolve the original promise, cache the result, then return it.
        promise.then(cachePut);
        return promise.then(resolve, reject);
      }
    };
    return enhancedPromise;
  }
  

  回复于 2024-04-28T00:47:46+08:00
• 0

  解决方案不是为了增强承诺本身，而是为了创造它们的工厂 .

  使用函数式编程和/或面向方面的编程方法来装饰原始函数 . 这不仅会减少错误，而且更简洁，可组合和可重用 .

  function decorate(makeThenable) {
      return function(...args) {
          … // before creating the thenable
          return makeThenable(...args).then(function(value) {
              … // handle fulfillment
              return …; // the resulting value
          }, function(error) {
              … // handle rejection
              return …; // (or throw)
          });
      };
  }
  var decorated = decorate(myThenablemaker);
  decorated(…).then(whenFulfilled, whenRejected);
  

  Example 1:

  function withAutoRetry(request, timeout) {
      return function() {
          var args = arguments;
          return request.apply(null, args).catch(function handle(e) {
              if (e instanceof Http503Error) // or whatever
                  return request.apply(null, args).catch(handle);
              else
                  throw e;
          });
      };
  }
  

  withAutoRetry(someRequest)().then(onSuccess, onError);
  
  withAutoRetry(function() {
      return someRequest().then(onSuccess, onAnyError);
  })().then(onSuccess, onNon503Error);
  

  Example 2:

  function withCache(request, hash) {
      var cache = {};
      if (!hash) hash = String;
      return function() {
          var key = hash.apply(this, arguments);
          if (key in cache)
              return cache[key];
          else
              return cache[key] = request.apply(this, arguments);
      };
  }
  

  lib.getNameOrigin = withCache(function(args) {
      return Restangular.all('people').one(args.id).get('nameOrigin');
  }, function(args) {
      return args.name;
  });
  

  回复于 2024-04-28T00:47:46+08:00