Jak sprawdzić, czy obiekt jest obietnicą?

Niezależnie od tego, czy jest to obietnica ES6, czy obietnica bluebird, obietnica Q itp.

Jak sprawdzić, czy dany obiekt jest obietnicą?

Jak decyduje biblioteka obietnic

Jeśli ma jakąś .thenfunkcję - jest to jedyna standardowa używana biblioteka bibliotek obietnic.

Specyfikacja Promises / A + ma pojęcie „ thenzdolny”, które jest w zasadzie „przedmiotem z thenmetodą”. Obietnice będą i powinny przyswoić sobie wszystko za pomocą ówczesnej metody. Wszystkie wspomniane obietnice wykonania to robią.

Jeśli spojrzymy na specyfikację :

2.3.3.3 Jeśli thenjest funkcją, wywołaj ją z x jako tym, pierwszym argumentem resolPromise i drugim argumentem odrzuceniemPromise

Wyjaśnia również uzasadnienie tej decyzji projektowej:

Takie traktowanie umiejętności thenumożliwia współdziałanie implementacji obietnic, o ile ujawniają one thenmetodę zgodną z obietnicami / A + . Umożliwia także implementacjom Promises / A + „asymilację” niezgodnych implementacji za pomocą rozsądnych metod.

Jak powinieneś zdecydować

Nie powinieneś - zamiast tego zadzwoń Promise.resolve(x)( Q(x)w Q), który zawsze przekształci dowolną wartość lub zewnętrzną thenzdolność w zaufaną obietnicę. Jest to bezpieczniejsze i łatwiejsze niż samodzielne przeprowadzanie tych kontroli.

naprawdę musisz być pewien?

Zawsze możesz uruchomić go za pomocą zestawu testów : D

Sprawdzanie, czy coś jest obiecane, niepotrzebnie komplikuje kod, wystarczy użyć Promise.resolve

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

})

Oto moja pierwotna odpowiedź, która została ratyfikowana w specyfikacji jako sposób na sprawdzenie obietnicy:

Promise.resolve(obj) == obj

Działa to, ponieważ algorytm wyraźnie wymaga, Promise.resolveaby zwracał dokładnie przekazany obiekt wtedy i tylko wtedy, gdy jest to obietnica z definicji specyfikacji.

Mam tutaj inną odpowiedź, która kiedyś to mówiła, ale zmieniłem ją na coś innego, gdy w tym czasie nie działała z Safari. To było rok temu, a teraz działa niezawodnie nawet w Safari.

Zredagowałbym moją pierwotną odpowiedź, z wyjątkiem tego, że czułem się źle, biorąc pod uwagę, że więcej osób głosowało teraz na zmienione rozwiązanie w tej odpowiedzi niż w oryginale. Wierzę, że to lepsza odpowiedź i mam nadzieję, że się zgadzasz.

Aktualizacja: To nie jest już najlepsza odpowiedź. Zamiast tego proszę głosować na moją drugą odpowiedź .

obj instanceof Promise

powinien to zrobić. Pamiętaj, że może to działać niezawodnie tylko z natywnymi obietnicami es6.

Jeśli używasz podkładki dystansowej, biblioteki obietnic lub czegokolwiek innego, co udaje, że jest podobna do obietnicy, bardziej odpowiednie może być przetestowanie „niemożliwego” (cokolwiek za pomocą .thenmetody), jak pokazano w innych odpowiedziach tutaj.

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

Aby sprawdzić, czy dany obiekt jest obietnicą ES6 , możemy skorzystać z tego predykatu:

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

Calling toStringbezpośrednio z Object.prototypezwraca natywną reprezentację ciągu danego typu obiektu, co "[object Promise]"w naszym przypadku. Zapewnia to, że dany obiekt

• Pomija fałszywe alarmy, takie jak:
  • Zdefiniowany typ obiektu o tej samej nazwie konstruktora („Obietnica”).
  • Self-napisany toStringmetodą danego obiektu.
• Działa w wielu kontekstach środowiska (np. Iframe) w przeciwieństwie doinstanceof lub isPrototypeOf.

Jednak każdy konkretny obiekt hosta , który ma zmodyfikowany znacznikSymbol.toStringTag , może zwrócić "[object Promise]". Może to być zamierzony wynik lub nie, zależnie od projektu (np. Jeśli istnieje niestandardowa implementacja Promise).

Aby sprawdzić, czy obiekt pochodzi z natywnej obietnicy ES6 , możemy użyć:

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 
}

Zgodnie z tą i niniejszą sekcją specyfikacji ciąg reprezentujący funkcję powinien być:

„function Identifier ( FormalParameterList _opt ) { FunctionBody }”

co jest odpowiednio obsługiwane powyżej. FunctionBody jest [native code]we wszystkich głównych przeglądarkach.

MDN: Function.prototype.toString

Działa to również w wielu kontekstach środowiska.

Nie jest to odpowiedź na pełne pytanie, ale myślę, że warto wspomnieć, że w Node.js 10 isPromisezostała dodana nowa funkcja wywołana, która sprawdza, czy obiekt jest rodzimą obietnicą, czy nie:

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

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

Oto jak pakiet graphql-js wykrywa obietnice:

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

valuejest zwróconą wartością twojej funkcji. Używam tego kodu w moim projekcie i jak dotąd nie mam z tym problemu.

Oto formularz kodu https://github.com/ssnau/xkit/blob/master/util/is-promise.js

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

jeśli obiekt z thenmetodą, powinien być traktowany jako Promise.

Jeśli używasz Typescript , chciałbym dodać, że możesz użyć funkcji „predykat typu”. Powinien po prostu zawrzeć logiczną weryfikację w funkcji, która powraca, x is Promise<any>i nie trzeba wykonywać typecastów. Poniżej na moim przykładzie cznajduje się albo obietnica, albo jeden z moich typów, który chcę przekształcić w obietnicę, wywołując c.fetch()metodę.

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;
}

Więcej informacji: https://www.typescriptlang.org/docs/handbook/advanced-types.html

Jeśli używasz metody asynchronicznej, możesz to zrobić i uniknąć niejasności.

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

Jeśli funkcja zwróci obietnicę, będzie oczekiwać i powróci z rozstrzygniętą wartością. Jeśli funkcja zwróci wartość, zostanie potraktowana jako rozwiązana.

Jeśli funkcja nie zwróci dziś obietnicy, ale jutro zwróci obietnicę lub zostanie uznana za asynchroniczną, będziesz zabezpieczony na przyszłość.

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));
});

Używam tej funkcji jako uniwersalnego rozwiązania:

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

po znalezieniu niezawodnego sposobu na wykrycie funkcji asynchronicznych, a nawet obietnic , zakończyłem testem:

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

ES6:

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

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