To tłumaczenie jest niekompletne. Pomóż przetłumaczyć ten artykuł z języka angielskiego.

Promise obiekt reprezentuje ostateczne zakończenie (lub niepowodzenie) operacji asynchronicznej i jej wynikową wartość.

Artyku pokazuje wstp do construktora Promisa. By nauczy się czym jest Promis przeczytaj Użycie promisa . Constructor is używane głównie do zawijania (wrapowania) funkcji, które jeszcze nie wspierają Promisa

Syntax

new Promise( /* wykonawca */ function(resolve, reject) { ... } );

Parameters

wykonawca (executor)
Funkcja przekazywana z argumentami rozwiązuje resolve i odrzuca reject. Funkcja executora wykonywana jest natychmiast przez implementację Promise, przekazując funkcje rozstrzygania resolve i odrzucania reject (executor jest wywoływany, zanim konstruktor Promise zwróci nawet utworzony obiekt). Funkcje rozstrzygania i odrzucania, gdy są wywoływane, odpowiednio rozwiązują lub odrzucają obietnicę. Executor zwykle inicjuje pracę asynchroniczną, a następnie, po jej zakończeniu, wywołuje funkcję resolve w celu rozwiązania obietnicy lub odrzuca ją, jeśli wystąpił błąd.
Jeśli błąd zostanie zgłoszony w funkcji executora, obietnica zostaje odrzucona. Wartość zwracana executora jest ignorowana.

Description

Promise jest proxy dla wartości niekoniecznie znanej, gdy tworzona jest Promise. Umożliwia powiązanie modułów obsługi z ostateczną wartością sukcesu akcji asynchronicznej lub przyczyną niepowodzenia. Pozwala to metodom asynchronicznym zwracać wartości takie jak metody synchroniczne: zamiast natychmiastowego zwracania wartości końcowej, metoda asynchroniczna zwraca obietnicę dostarczenia wartości w pewnym momencie w przyszłości.

A Promise jest dostpny w jednym . tych stanów:

  • pending: initial state, neither fulfilled nor rejected.
  • fulfilled: meaning that the operation completed successfully.
  • rejected: meaning that the operation failed.

Obowiązujący Promis (objetnica) może być wypełniona wartością lub odrzucona z powodu (błędu). Kiedy dzieje się jedna z tych opcji, wywoływane są powiązane procedury obsługi w kolejce za pomocą metody Promise. (Jeśli Promise została już spełniona lub odrzucona, gdy dołączony jest odpowiedni moduł obsługi, zostanie wywołany moduł obsługi, więc nie ma warunków wyścigu między zakończeniem operacji asynchronicznej a jej obsługą).

Tak jak Promise.prototype.then() oraz Promise.prototype.catch() metoda zwróci promises, wtedy mogą być chainowane.

Nie mylić z: Kilka innych języków ma mechanizmy leniwego oceniania i odraczania obliczeń, które nazywają również "obietnicami", np. Schemat. Obietnice w JavaScript oznaczają procesy, które już się odbywają, które mogą być powiązane z funkcjami wywołania zwrotnego. Jeśli chcesz leniwie oceniać wyrażenie, rozważ  arrow function bez argumentów: f = () => expression stworzyć leniwo oszacowane wyrażenie, i f() by ocenić.

Nota: Mówi się, że obietnica zostanie uregulowana, jeśli zostanie spełniona lub odrzucona, ale nie oczekuje na rozpatrzenie. Usłyszysz także termin rozwiązany używany z obietnicami - oznacza to, że obietnica jest ustalona lub "zamknięta", aby dopasować się do stanu innej obietnicy. Stany i losy zawierają więcej szczegółów na temat obiecanej terminologii.

Properties

Promise.length
Właściwość Length, której wartość wynosi zawsze 1 (liczba argumentów konstruktora).
Promise.prototype
Reprezentuje prototyp konstruktora Promise.

Methods

Promise.all(iterable)
Returns a promise that either fulfills when all of the promises in the iterable argument have fulfilled or rejects as soon as one of the promises in the iterable argument rejects. If the returned promise fulfills, it is fulfilled with an array of the values from the fulfilled promises in the same order as defined in the iterable. If the returned promise rejects, it is rejected with the reason from the first promise in the iterable that rejected. This method can be useful for aggregating results of multiple promises.
Promise.race(iterable)
Returns a promise that fulfills or rejects as soon as one of the promises in the iterable fulfills or rejects, with the value or reason from that promise.
Promise.reject(reason)
Returns a Promise object that is rejected with the given reason.
Promise.resolve(value)
Returns a Promise object that is resolved with the given value. If the value is a thenable (i.e. has a then method), the returned promise will "follow" that thenable, adopting its eventual state; otherwise the returned promise will be fulfilled with the value. Generally, if you don't know if a value is a promise or not, Promise.resolve(value) it instead and work with the return value as a promise.

Promise prototype

Properties

Promise.prototype.constructor
Returns the function that created an instance's prototype. This is the Promise function by default.

Methods

Promise.prototype.catch(onRejected)
Appends a rejection handler callback to the promise, and returns a new promise resolving to the return value of the callback if it is called, or to its original fulfillment value if the promise is instead fulfilled.
Promise.prototype.then(onFulfilled, onRejected)
Appends fulfillment and rejection handlers to the promise, and returns a new promise resolving to the return value of the called handler, or to its original settled value if the promise was not handled (i.e. if the relevant handler onFulfilled or onRejected is not a function).
Promise.prototype.finally(onFinally)
Appends a handler to the promise, and returns a new promise which is resolved when the original promise is resolved. The handler is called when the promise is settled, whether fulfilled or rejected.

Creating a Promise

A Promise object is created using the new keyword and its constructor. This constructor takes as its argument a function, called the "executor function". This function should take two functions as parameters. The first of these functions (resolve) is called when the asynchronous task completes successfully and returns the results of the task as a value. The second (reject) is called when the task fails, and returns the reason for failure, which is typically an error object.

const myFirstPromise = new Promise((resolve, reject) => {
  // do something asynchronous which eventually calls either:
  //
  //   resolve(someValue); // fulfilled
  // or
  //   reject("failure reason"); // rejected
});

To provide a function with promise functionality, simply have it return a promise:

function myAsyncFunction(url) {
  return new Promise((resolve, reject) => {
    const xhr = new XMLHttpRequest();
    xhr.open("GET", url);
    xhr.onload = () => resolve(xhr.responseText);
    xhr.onerror = () => reject(xhr.statusText);
    xhr.send();
  });
}

Examples

Basic Example

let myFirstPromise = new Promise((resolve, reject) => {
  // We call resolve(...) when what we were doing asynchronously was successful, and reject(...) when it failed.
  // In this example, we use setTimeout(...) to simulate async code. 
  // In reality, you will probably be using something like XHR or an HTML5 API.
  setTimeout(function(){
    resolve("Success!"); // Yay! Everything went well!
  }, 250);
});

myFirstPromise.then((successMessage) => {
  // successMessage is whatever we passed in the resolve(...) function above.
  // It doesn't have to be a string, but if it is only a succeed message, it probably will be.
  console.log("Yay! " + successMessage);
});

Advanced Example

This small example shows the mechanism of a Promise. The testPromise() method is called each time the <button> is clicked. It creates a promise that will be fulfilled, using window.setTimeout(), to the promise count (number starting from 1) every 1-3 seconds, at random. The Promise() constructor is used to create the promise.

The fulfillment of the promise is simply logged, via a fulfill callback set using p1.then(). A few logs show how the synchronous part of the method is decoupled from the asynchronous completion of the promise.

'use strict';
var promiseCount = 0;

function testPromise() {
    let thisPromiseCount = ++promiseCount;

    let log = document.getElementById('log');
    log.insertAdjacentHTML('beforeend', thisPromiseCount +
        ') Started (<small>Sync code started</small>)<br/>');

    // We make a new promise: we promise a numeric count of this promise, starting from 1 (after waiting 3s)
    let p1 = new Promise(
        // The resolver function is called with the ability to resolve or
        // reject the promise
       (resolve, reject) => {
            log.insertAdjacentHTML('beforeend', thisPromiseCount +
                ') Promise started (<small>Async code started</small>)<br/>');
            // This is only an example to create asynchronism
            window.setTimeout(
                function() {
                    // We fulfill the promise !
                    resolve(thisPromiseCount);
                }, Math.random() * 2000 + 1000);
        }
    );

    // We define what to do when the promise is resolved with the then() call,
    // and what to do when the promise is rejected with the catch() call
    p1.then(
        // Log the fulfillment value
        function(val) {
            log.insertAdjacentHTML('beforeend', val +
                ') Promise fulfilled (<small>Async code terminated</small>)<br/>');
        })
    .catch(
        // Log the rejection reason
       (reason) => {
            console.log('Handle rejected promise ('+reason+') here.');
        });

    log.insertAdjacentHTML('beforeend', thisPromiseCount +
        ') Promise made (<small>Sync code terminated</small>)<br/>');
}

This example is started by clicking the button. You need a browser that supports Promise. By clicking the button several times in a short amount of time, you'll even see the different promises being fulfilled one after another.

Loading an image with XHR

Another simple example using Promise and XMLHttpRequest to load an image is available at the MDN GitHub js-examples repository. You can also see it in action. Each step is commented and allows you to follow the Promise and XHR architecture closely.

Specifications

Specification Status Comment
ECMAScript 2015 (6th Edition, ECMA-262)
The definition of 'Promise' in that specification.
Standard Initial definition in an ECMA standard.
ECMAScript Latest Draft (ECMA-262)
The definition of 'Promise' in that specification.
Draft  

Browser compatibility

FeatureChromeEdgeFirefoxInternet ExplorerOperaSafari
Basic support32 Yes29 No198
Promise() constructor32 Yes291 No1983
all32 Yes29 No198
prototype32 Yes29 No198
catch32 Yes29 No198
finally63 No58 No5011.1
then32 Yes29 No198
race32 Yes29 No198
reject32 Yes29 No198
resolve32 Yes29 No198
FeatureAndroid webviewChrome for AndroidEdge mobileFirefox for AndroidOpera AndroidiOS SafariSamsung Internet
Basic support4.4.432 Yes29 Yes8 Yes
Promise() constructor4.4.432 Yes291 Yes83 Yes
all4.4.432 Yes29 Yes8 Yes
prototype4.4.432 Yes29 Yes8 Yes
catch4.4.432 Yes29 Yes8 Yes
finally6363 No585011.1 No
then4.4.432 Yes29 Yes8 Yes
race4.4.432 Yes29 Yes8 Yes
reject4.4.432 Yes29 Yes8 Yes
resolve4.4.432 Yes29 Yes8 Yes

1. Constructor requires a new operator since version 37.

2. Constructor requires a new operator since version 4.

3. Constructor requires a new operator since version 10.

See also

Autorzy i etykiety dokumentu

Autorzy tej strony: szopenkrk
Ostatnia aktualizacja: szopenkrk,