Bir nesnenin bir söz olup olmadığını nasıl anlarım?

İster ES6 Sözü, ister mavi kuş Sözü, Q Sözü vb.

Belirli bir nesnenin bir Söz olup olmadığını nasıl test edebilirim?

Bir söz kütüphanesi nasıl karar verir

Bir .thenişlevi varsa - kütüphanelerin kullandığı tek standart vaat kütüphanesidir.

Promises / A + belirtimi then, temelde " thenyöntemli bir nesne" olan able adında bir nosyona sahiptir . Vaatler herhangi bir yöntemi bir yöntemle özümseyecek ve özümsemelidir . Bahsettiğiniz tüm söz uygulaması bunu yapıyor.

Şartnameye bakarsak :

2.3.3.3 thenbir işlevse, bunu x ile çağırın, ilk argüman resolPromise ve ikinci argüman rejectPromise

Ayrıca, bu tasarım kararının gerekçesini açıklar:

Bu thenables tedavisi, Promises / A + uyumlu bir thenyöntem ortaya koydukları sürece söz verilen uygulamaların birlikte çalışmasına izin verir . Ayrıca Promises / A + uygulamalarının uygun olmayan uygulamaları makul ve daha sonra yöntemlerle “özümsemesine” izin verir.

Nasıl karar vermelisin

Bunun yerine , herhangi bir değeri veya harici kabileyi her zaman güvenilir bir vaat haline dönüştürecek Promise.resolve(x)( Q(x)Q olarak) aramamalısınız. Bu kontrolleri kendiniz yapmaktan daha güvenli ve kolaydır.then

gerçekten emin olmalısın?

Her zaman test paketinden çalıştırabilirsiniz : D

Bir şeyin vaat edilip edilmediğini kontrol etmek kodu zorlaştırır, sadece kullanın Promise.resolve

Promise.resolve(valueOrPromiseItDoesntMatter).then(function(value) {

})

İşte o zamandan beri bir vaat için test etme yolu olarak spesifikasyonda onaylanan orijinal cevabım :

Promise.resolve(obj) == obj

Bu çalışır çünkü algoritmaPromise.resolve , yalnızca spesifikasyonun tanımına göre bir söz ise, geçirilen tam nesneyi döndürmesi gerektiğini açıkça talep eder .

Burada başka bir cevabım var, bunu söylerdim, ama o sırada Safari ile çalışmadığında başka bir şeye değiştirdim. Bu bir yıl önceydi ve şimdi Safari'de bile güvenilir bir şekilde çalışıyor.

Şimdiye kadar bu cevapta değiştirilen çözüme orijinalinden daha fazla insanın oy vermiş olması göz önüne alındığında, orijinal cevabımı düzenledim. Bunun daha iyi bir cevap olduğuna inanıyorum ve umarım katılıyorsunuz.

Güncelleme: Bu artık en iyi cevap değil. Lütfen bunun yerine diğer cevabımı oyla .

obj instanceof Promise

yapmalı. Bunun yalnızca yerel es6 vaatleriyle güvenilir bir şekilde çalışabileceğini unutmayın.

Bir şim, bir vaat kütüphanesi veya vaat benzeri gibi davranan başka bir şey kullanıyorsanız .then, buradaki diğer cevaplarda gösterildiği gibi bir "değiştirilebilir" ( yöntemle herhangi bir şey ) test etmek daha uygun olabilir .

if (typeof thing.then === 'function') {
    // probably a promise
} else {
    // definitely not a promise
}

Verilen nesnenin bir ES6 Sözü olup olmadığını görmek için bu yüklemden yararlanabiliriz:

function isPromise(p) {
  return p && Object.prototype.toString.call(p) === "[object Promise]";
}

Calling toStringdoğrudan Object.prototypegetiri bir yerli dize temsilini ise verilen nesne türünün "[object Promise]"bizim durumumuzda. Bu, verilen nesnenin

• Gibi yanlış pozitifleri atlar ..:
  • Aynı yapıcı adına sahip kendinden tanımlı nesne türü ("Promise").
  • toStringVerilen nesnenin kendi yazdığı yöntem.
• Veya öğesinin aksineinstanceof birden çok ortam bağlamında (örneğin iframe'ler) çalışır isPrototypeOf.

Ancak, etiketi değiştirilmiş olan herhangi bir ana bilgisayar nesnesi geri dönebilir . Bu, projeye bağlı olarak amaçlanan sonuç olabilir veya olmayabilir (örneğin özel bir Promise uygulaması varsa).Symbol.toStringTag"[object Promise]"

Nesnenin yerel bir ES6 Promise'dan olup olmadığını görmek için şunları kullanabiliriz:

function isNativePromise(p) {
  return p && typeof p.constructor === "function"
    && Function.prototype.toString.call(p.constructor).replace(/\(.*\)/, "()")
    === Function.prototype.toString.call(/*native object*/Function)
      .replace("Function", "Promise") // replacing Identifier
      .replace(/\(.*\)/, "()"); // removing possible FormalParameterList 
}

Göre bu ve bu bölümde spec, fonksiyonun dize temsilini olmalıdır:

"işlev Tanımlayıcısı ( FormalParameterList _opt ) { FunctionBody }"

yukarıda ele alınmaktadır. FunctionBody olan [native code]tüm büyük tarayıcılarda.

MDN: Function.prototype.toString

Bu, çoklu ortam bağlamlarında da çalışır.

Tam soruya bir cevap değil ama Node.js 10'da isPromisebir nesnenin yerel bir Promise olup olmadığını kontrol eden yeni bir util fonksiyonunun eklendiğini belirtmeye değer olduğunu düşünüyorum :

const utilTypes = require('util').types
const b_Promise = require('bluebird')

utilTypes.isPromise(Promise.resolve(5)) // true
utilTypes.isPromise(b_Promise.resolve(5)) // false

Bu nasıl graphql-js paket vaat algılar:

function isPromise(value) {
  return Boolean(value && typeof value.then === 'function');
}

valueişlevinizin döndürülen değeridir. Projemde bu kodu kullanıyorum ve şimdiye kadar hiçbir sorunum yok.

İşte https://github.com/ssnau/xkit/blob/master/util/is-promise.js kod formu

!!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';

thenyöntemli bir nesne, a olarak ele alınmalıdır Promise.

Kullandığınız durumda typescript , sana "tipi yüklem" özelliğini kullanabilirsiniz olduğunu eklemek istiyorum. Mantıksal doğrulamayı geri dönen bir fonksiyona sarmanız x is Promise<any>gerekir ve daktilo yapmak zorunda kalmazsınız. Aşağıda örneğimde, cbir söz veya c.fetch()yöntemi çağırarak bir söze dönüştürmek istediğim türlerimden biri .

export function toPromise(c: Container<any> | Promise<any>): Promise<any> {
    if (c == null) return Promise.resolve();
    return isContainer(c) ? c.fetch() : c;
}

export function isContainer(val: Container<any> | Promise<any>): val is Container<any> {
    return val && (<Container<any>>val).fetch !== undefined;
}

export function isPromise(val: Container<any> | Promise<any>): val is Promise<any> {
    return val && (<Promise<any>>val).then !== undefined;
}

Daha fazla bilgi: https://www.typescriptlang.org/docs/handbook/advanced-types.html

Zaman uyumsuz bir yöntemdeyseniz bunu yapabilir ve belirsizliklerden kaçınabilirsiniz.

async myMethod(promiseOrNot){
  const theValue = await promiseOrNot()
}

İşlev vaat döndürürse, bekleyecek ve çözümlenen değerle geri dönecektir. İşlev bir değer döndürürse, çözümlenmiş olarak kabul edilir.

İşlev bugün bir söz vermezse, yarın birini döndürürse veya zaman uyumsuz olarak bildirilirse, geleceğe dönük olacaksınız.

it('should return a promise', function() {
    var result = testedFunctionThatReturnsPromise();
    expect(result).toBeDefined();
    // 3 slightly different ways of verifying a promise
    expect(typeof result.then).toBe('function');
    expect(result instanceof Promise).toBe(true);
    expect(result).toBe(Promise.resolve(result));
});

Bu işlevi evrensel bir çözüm olarak kullanıyorum:

function isPromise(value) {
  return value && value.then && typeof value.then === 'function';
}

Async işlevlerini ve hatta Promises'ı tespit etmek için güvenilir bir yol aradıktan sonra , aşağıdaki testi kullanarak sonuçlandırdım:

() => fn.constructor.name === 'Promise' || fn.constructor.name === 'AsyncFunction'

ES6:

const promise = new Promise(resolve => resolve('olá'));

console.log(promise.toString().includes('Promise')); //true