Nasıl q uygulanan gibi kütüphane erteleme/bir söz var mı? Çalışıyordum okumak için kaynak kodu buldum ama bunu çok zor anlar, ben de öyle düşünmüştüm mükemmel olacak biri varsa açıklayabilir bana, bir yüksek seviye, ne kullanılan teknikler uygulamak ve söz tek iplik JS ortamlar gibi Düğüm ve tarayıcılar.

Daha zor bir örnek göstermek için daha açıklamak buluyorum, burada erteleme/söz ne olabilir çok basit bir uygulama.

Yasal Uyarı:Bu işlevsel bir uygulama değil ve Bir şartname/Söz bazı parçaları eksik, Bu sadece bir söz olarak açıklamaktır.

tl;dr:GidinSınıfları ve örnek oluşturmakbölüm tam olarak uygulamaya.

Söz:

İlk geri aramalar bir dizi nesne bir söz yaratmalıyız. Daha net çünkü nesnelerle çalışmaya başlayacağım:

var promise = {
  callbacks: []
}

şimdi yöntemi ile geri ekleyin:

var promise = {
  callbacks: [],
  then: function (callback) {
    callbacks.push(callback);
  }
}

Ve hata da geri istiyoruz:

var promise = {
  okCallbacks: [],
  koCallbacks: [],
  then: function (okCallback, koCallback) {
    okCallbacks.push(okCallback);
    if (koCallback) {
      koCallbacks.push(koCallback);
    }
  }
}

Tecil:

Bu erteleme yaratan bir söz olacak şimdi nesne:

var defer = {
  promise: promise
};

Erteleme çözülmesi gereken:

var defer = {
  promise: promise,
  resolve: function (data) {
    this.promise.okCallbacks.forEach(function(callback) {
      window.setTimeout(function () {
        callback(data)
      }, 0);
    });
  },
};

Ve red etmesi:

var defer = {
  promise: promise,
  resolve: function (data) {
    this.promise.okCallbacks.forEach(function(callback) {
      window.setTimeout(function () {
        callback(data)
      }, 0);
    });
  },

  reject: function (error) {
    this.promise.koCallbacks.forEach(function(callback) {
      window.setTimeout(function () {
        callback(error)
      }, 0);
    });
  }
};

Geri aramalar kodu her zaman asynchromous olmak izin vermek için bir bitim zamani 'sayi' denir unutmayın.

Bu çok basit bir erteleme söz veriyoum bir uygulama ihtiyacı var.

Sınıfları ve örnek oluşturmak:

Şimdi sınıflar için, ilk sözü: iki nesne dönüştürmek sağlar

var Promise = function () {
  this.okCallbacks = [];
  this.koCallbacks = [];
};

Promise.prototype = {
  okCallbacks: null,
  koCallbacks: null,
  then: function (okCallback, koCallback) {
    okCallbacks.push(okCallback);
    if (koCallback) {
      koCallbacks.push(koCallback);
    }
  }
};

Ve erteleme şimdi:

var Defer = function () {
  this.promise = new Promise();
};

Defer.prototype = {
  promise: null,
  resolve: function (data) {
    this.promise.okCallbacks.forEach(function(callback) {
      window.setTimeout(function () {
        callback(data)
      }, 0);
    });
  },

  reject: function (error) {
    this.promise.koCallbacks.forEach(function(callback) {
      window.setTimeout(function () {
        callback(error)
      }, 0);
    });
  }
};

Ve burada bir örnektir:

function test() {
  var defer = new Defer();
  // an example of an async call
  serverCall(function (request) {
    if (request.status === 200) {
      defer.resolve(request.responseText);
    } else {
      defer.reject(new Error("Status code was "   request.status));
    }
  });
  return defer.promise;
}

test().then(function (text) {
  alert(text);
}, function (error) {
  alert(error.message);
});

Gördüğünüz gibi temel parçalar basit ve küçük. Örneğin birden fazla söz çözünürlüğü: diğer seçenekleri eklediğinizde büyüyecek

Defer.all(promiseA, promiseB, promiseC).then()

ya da zincirleme söz:

getUserById(id).then(getFilesByUser).then(deleteFile).then(promptResult);

Özellikleri hakkında daha fazla bilgi için: CommonJS Promise Specification. Ana kütüphaneler not (Q,, rsvp.jswhen.js düğüm-söz, ...) Promises/A belirtimi izleyin.

Açık enaugh olduğumu umuyorum.

Düzenleme:

Yorum istedi, bu sürüm iki şey ekledim:

• Bir söz ver, ne olursa olsun o zaman aramak için olasılık.
• Zincir söz etmek mümkün.

Çözülmüş zaman söz arayabilir söz durumu eklemek gerekir, ve sonra çağrıldığında bu durumu kontrol edin. Eğer durum çözüldü ya da reddedilirse sadece veri veya bir hata ile geri arama yürütmek.

Olmak üzere zincir sözler ihtiyacınız üretmek için yeni bir erteleme için her arama için then ve, ne zaman söz çözümlenir/reddetti, gidermek/Reddet yeni vaadi ile sonucu geri arama. Eğer geri yeni bir söz verir, söz bittiğinde, söz then() ile döndü lidir. Değilse, sözünü geri arama sonucu ile çözüldü.

İşte söz:

var Promise = function () {
  this.okCallbacks = [];
  this.koCallbacks = [];
};

Promise.prototype = {
  okCallbacks: null,
  koCallbacks: null,
  status: 'pending',
  error: null,

  then: function (okCallback, koCallback) {
    var defer = new Defer();

    // Add callbacks to the arrays with the defer binded to these callbacks
    this.okCallbacks.push({
      func: okCallback,
      defer: defer
    });

    if (koCallback) {
      this.koCallbacks.push({
        func: koCallback,
        defer: defer
      });
    }

    // Check if the promise is not pending. If not call the callback
    if (this.status === 'resolved') {
      this.executeCallback({
        func: okCallback,
        defer: defer
      }, this.data)
    } else if(this.status === 'rejected') {
      this.executeCallback({
        func: koCallback,
        defer: defer
      }, this.error)
    }

    return defer.promise;
  },

  executeCallback: function (callbackData, result) {
    window.setTimeout(function () {
      var res = callbackData.func(result);
      if (res instanceof Promise) {
        callbackData.defer.bind(res);
      } else {
        callbackData.defer.resolve(res);
      }
    }, 0);
  }
};

Ve erteleme:

var Defer = function () {
  this.promise = new Promise();
};

Defer.prototype = {
  promise: null,
  resolve: function (data) {
    var promise = this.promise;
    promise.data = data;
    promise.status = 'resolved';
    promise.okCallbacks.forEach(function(callbackData) {
      promise.executeCallback(callbackData, data);
    });
  },

  reject: function (error) {
    var promise = this.promise;
    promise.error = error;
    promise.status = 'rejected';
    promise.koCallbacks.forEach(function(callbackData) {
      promise.executeCallback(callbackData, error);
    });
  },

  // Make this promise behave like another promise:
  // When the other promise is resoved/rejected this is also resolved/rejected
  // with the same data
  bind: function (promise) {
    var that = this;
    promise.then(function (res) {
      that.resolve(res);
    }, function (err) {
      that.reject(err);
    })
  }
};

Gördüğünüz gibi, biraz büyüdü.