path: root/files/bg/web/javascript/reference/global_objects/promise/index.html

---
title: Promise
slug: Web/JavaScript/Reference/Global_Objects/Promise
tags:
  - JavaScript
  - Promises
  - Refere
translation_of: Web/JavaScript/Reference/Global_Objects/Promise
---
<div>{{JSRef}}</div>

<p><strong><code>Promise</code></strong> обектът представлява евентуалният завършек (или неуспех) на една асинхронна операция и нейната получена стойност.</p>

<div class="note">
<p><strong>Бележка:</strong>  Тази статия описва <code>Promise</code> конструктора и методите и свойствата на такива обекти. За да научите начина по който работят <code>promises</code>и как може да ги използвате , съветваме ви първо да прочетете <a href="/docs/Web/JavaScript/Guide/Using_promises">Как да използваме promises.  </a>Конструктора се използва предимно за обхващане на функции, които вече не поддържат <code>promises</code></p>
</div>

<div>{{EmbedInteractiveExample("pages/js/promise-constructor.html")}}</div>

<p class="hidden">The source for this interactive demo is stored in a GitHub repository. If you'd like to contribute to the interactive demo project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p>

<h2 id="Синтаксис">Синтаксис</h2>

<pre class="syntaxbox">new Promise(<var>executor</var>);</pre>

<h3 id="Параметри">Параметри</h3>

<dl>
 <dt><code>екзекутор (executor)</code></dt>
 <dd>Функция , която се предава с аргументи <code>resolve</code> и <code>reject</code>. Екзекутор (<code>executor</code>) функцията се изпълнява незабавно след  изпълнението на <code>Promise</code>, предава <code>resolve</code> и <code>reject</code> функции (Екзекутора (<code>executor</code>) се извиква преди <code>Promise</code> конструктора , дори връща създадения обект). <code>resolve</code> и <code>reject</code> функциите, когато се извикват, разрешават или отхвърлят съответния  <code>promise</code>. Екзекутора (<code>executor</code>) обикновено инициира някаква асинхронна работа и след като веднъж приключи, извиква <code>resolve</code> функцията, за да разреши <code>promise</code> или дори да го отхвъли ако възникне грешка. Ако възникне грешка в екзекутора (<code>executor</code>) , <code>promise</code>  се отхвърля и върнатата стойност от екзекутора (<code>executor</code>) се отхвърля.</dd>
</dl>

<h2 id="Описание">Описание</h2>

<p><code><strong>Promise</strong></code> е прокси за стойността, която не е непременно известна , когато се създава <code>promise</code>. Позволява ви да свържете манипулаторите с асинхронно действие, евентуално връщайки успешна стойност или грешка. Това позволява асинхронните методи да връщат стойност като синхронни методи: вместо да ни върне незабавно финална стойност, асинхронния метод връща <em>promise</em>, който да ни предостави стойността в някакъв бъдещ момент.</p>

<p><code>Promise</code> се намира в едно от тези състояния:</p>

<ul>
 <li><em>pending (изчакващо)</em>: първоначално състояние, нито изпълнено или отхвърлено.</li>
 <li><em>fulfilled</em> (изпълнено): означава , че операцията е завършила успешно.</li>
 <li><em>rejected (отказано)</em>: означава , че операцията не е завършила успешно.</li>
</ul>

<p>Изчакващият promise може да бъде изпълнен със стойност или отказан с описание за грешка. Когато някоя от тези опции се случи, се извикват асоциираните манипулатори, поставени на опашка, след което се извикват <code>then</code> методите. (Ако promise вече е бил изпълнен или отказан, когато е приложен съответния манипулатор , манипулатора ще бъде извикан. Така че няма никакво състезателно условие между завършването на асинхронната операция и манипулаторите които са и били приложени.)</p>

<p>Като <code>{{jsxref("Promise.then", "Promise.prototype.then()")}}</code> и <code>{{jsxref("Promise.catch", "Promise.prototype.catch()")}}</code> методи връщат promises, те могат да бъдат обхванати.</p>

<p><img alt="" src="https://mdn.mozillademos.org/files/15911/promises.png" style="height: 297px; width: 801px;"></p>

<div class="note">
<p><strong>Забележка, не трябва да се бърка с:</strong>  Няколко дргуи езика имат механизъм за мързеливо (lazy) оценяване и отлагане на изчисления, които те също наричат "promises" ... схема. Promises в JavaScript представляват процеси, които вече се случват и могат да бъдат обхванати с функции за обратно извикване (callback functions).  Ако търсите мързеливо да изчислите израз, разгледайте <a href="/docs/Web/JavaScript/Reference/Functions/Arrow_functions">функциите със стрелка (arrow function)</a> без аргументи: <code>f = () =&gt; <em>израз(expression)</em></code> за създаване на мързеливо-изчислителен израз  и <code>f()</code> за изчисление.</p>
</div>

<div class="note">
<p><strong>Забележка</strong>: Казва се че Promise се счита за <em>установен</em> ако е изпълнен или отказан, но не изчакващ. Също така ще чуете и термина <em>resolved</em>, който се изпозлва с promises — това означава че promise е установен или “заключен”, изчаквайки да съответства на състоянието на друг promise. <a href="https://github.com/domenic/promises-unwrapping/blob/master/docs/states-and-fates.md">States and fates</a> съдържа повече детайли относно promise терминологията.</p>
</div>

<h2 id="Свойства">Свойства</h2>

<dl>
 <dt><code>Promise.length</code></dt>
 <dd>Дължина на свойство, чиято дължина е винаги 1 (номер на аругмента на конструктора).</dd>
 <dt>{{jsxref("Promise.prototype")}}</dt>
 <dd>Представялва прототипа на <code>Promise</code> конструктора.</dd>
</dl>

<h2 id="Методи">Методи</h2>

<dl>
 <dt>{{jsxref("Promise.all", "Promise.all(iterable)")}}</dt>
 <dd>Изчаква всички promises да бъдат разрешени или отказани.</dd>
 <dd>Ако върнатия promise е решен(resolves), той се решава с агрегиращ масив от стойности от разрешените promises в същата последователност, както е дефиниран в многобройните promises. Ако е отхвърлен, той се отхвърля с причина от първият promise който е бил отказан.</dd>
 <dt>{{jsxref("Promise.allSettled", "Promise.allSettled()")}}</dt>
 <dd>Изчаква докато всички promises са приключени/уредени (всеки може да бъде разрешен или отказан).</dd>
 <dd>Връща promise което се решава след всички дадени promises били те разрешени или отказани, с масив от обекти , които описват резултата от всеки promise.</dd>
 <dt>{{jsxref("Promise.race", "Promise.race(iterable)")}}</dt>
 <dd>Изчаква докато някой от promises е разрешен или отказан.</dd>
 <dd>Ако върнатият promise е разрешен,е разрешен със стойноста от първият promise.Ако е отказан, е отакзан с причината от първият promise който е бил отказан.</dd>
 <dt>{{jsxref("Promise.reject", "Promise.reject()")}}</dt>
 <dd>Връща нов <code>Promise</code> обект, който е отказан с предоставена причина.</dd>
 <dt>{{jsxref("Promise.resolve", "Promise.resolve()")}}</dt>
 <dd>Връща нов <code>Promise</code> който е разрешен с дадената му стойност. Ако стойността е  thenable (i.e. има <code>then</code> метод), върнатият promise ще "следва" този thenable, приемайки евентуалното му състояние; в противен случай върнатия promise ще бъде запълнен със стойността. Обикновенно ако не знаете дадена стойност дали е promise или не, {{jsxref("Promise.resolve", "Promise.resolve(value)")}} замества и работи с върнатата стойност като promise.</dd>
</dl>

<h2 id="Promise_прототип">Promise прототип</h2>

<h3 id="Свойства_2">Свойства</h3>

<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Properties')}}</p>

<h3 id="Методи_2">Методи</h3>

<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Methods')}}</p>

<h2 id="Създаване_на_Promise">Създаване на Promise</h2>

<p><code>Promise</code> се създава, използвайки ключовата дума <code>new</code> и нейният конструктор. Този конструктор приема като аргумент функция, наричаща се "executor function". Тази функция трябва да приеме две функции като параметри. Първата от тези функции (<code>resolve</code>) се извиква когато асинхронната задача завърши успешно и върне резултата от задачата като стойност. Вторият (<code>reject</code>) се извиква когато задачата се провали и връща причината за този провал, който обикновенно е обект съдържайки в себе си грешката.</p>

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

<p>За да предоставите функция с promise функционалност, просто върнете promise:</p>

<pre class="brush: js">function myAsyncFunction(url) {
  return new Promise((resolve, reject) =&gt; {
    const xhr = new XMLHttpRequest();
    xhr.open("GET", url);
    xhr.onload = () =&gt; resolve(xhr.responseText);
    xhr.onerror = () =&gt; reject(xhr.statusText);
    xhr.send();
  });
}</pre>

<h2 id="Примери">Примери</h2>

<h3 id="Основни_примери">Основни примери</h3>

<pre class="brush: js">let myFirstPromise = new Promise((resolve, reject) =&gt; {
  // 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) =&gt; {
  // 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);
});
</pre>

<h3 id="Разширени_примери">Разширени примери</h3>

<pre class="brush: html hidden">&lt;button id="btn"&gt;Make a promise!&lt;/button&gt;
&lt;div id="log"&gt;&lt;/div&gt;
</pre>

<p>Този малък пример показва механизма на <code>Promise</code>. <code>testPromise()</code> метод се извиква всеки път когато  {{HTMLElement("button")}} е натиснат. Създава promise който ще бъде изпълнен, използвайки {{domxref("window.setTimeout()")}}, към promise броенето(номер започващ от 1) на всеки 1-3 секунди на случаен принцип. The <code>Promise()</code> се използва за създаването на promise.</p>

<p>Изпълнението на promise е просто записано, чрез сет за обратно извикване (callback set) , използвайки {{jsxref("Promise.prototype.then()","p1.then()")}}. <span lang="bg">Няколко logs (данни) показват как синхронната част на метода е отделена от асинхронното завършване на обещанието.</span></p>

<pre class="brush: js">'use strict';
var promiseCount = 0;

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

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

    // We make a new promise: we promise a numeric count of this promise, starting from 1 (after waiting 3s)
    let p1 = new Promise(
        // The executor function is called with the ability to resolve or
        // reject the promise
       (resolve, reject) =&gt; {
            log.insertAdjacentHTML('beforeend', thisPromiseCount +
                ') Promise started (&lt;small&gt;Async code started&lt;/small&gt;)&lt;br/&gt;');
            // 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 (&lt;small&gt;Async code terminated&lt;/small&gt;)&lt;br/&gt;');
        }).catch(
        // Log the rejection reason
       (reason) =&gt; {
            console.log('Handle rejected promise ('+reason+') here.');
        });

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

<pre class="brush:js hidden">if ("Promise" in window) {
  let btn = document.getElementById("btn");
  btn.addEventListener("click",testPromise);
} else {
  log = document.getElementById('log');
  log.innerHTML = "Live example not available as your browser doesn't support the &lt;code&gt;Promise&lt;code&gt; interface.";
}
</pre>

<p>Този пример ще се стартира като кликнете на бутона. Имате нужда от браузер който поддържа <code>Promise</code>. Натискайки на бутона няколко пъти в кратки периоди от време , ще видите дори разллични promises , които се изпълняват един след друг.</p>

<p>{{EmbedLiveSample("Advanced_Example", "500", "200")}}</p>

<h2 id="Зареждане_на_снимка_с_XHR">Зареждане на снимка с XHR</h2>

<p>Друг опростен пример използва <code>Promise</code> и {{domxref("XMLHttpRequest")}} за зареждане на снимки е наличен в GitHub профила на MDN и се казва <a href="https://github.com/mdn/js-examples/tree/master/promises-test">js-examples</a>. Тук също може да го видите и в действие <a href="https://mdn.github.io/js-examples/promises-test/">see it in action</a>. Всяка стъпка е коментирана и ви позволява да следвате Promise и XHR архитектурата внимателно.</p>

<h2 id="Спецификации">Спецификации</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Specification</th>
   <th scope="col">Status</th>
   <th scope="col">Comment</th>
  </tr>
  <tr>
   <td>{{SpecName('ES2015', '#sec-promise-objects', 'Promise')}}</td>
   <td>{{Spec2('ES2015')}}</td>
   <td>Initial definition in an ECMA standard.</td>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-promise-objects', 'Promise')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td></td>
  </tr>
 </tbody>
</table>

<h2 id="Съвместимост_с_браузърите">Съвместимост с браузърите</h2>

<p class="hidden">To contribute to this compatibility data, please write a pull request against this repository: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p>

<p>{{Compat("javascript.builtins.Promise")}}</p>

<h2 id="See_also">See also</h2>

<ul>
 <li><a href="/en-US/docs/Web/JavaScript/Guide/Using_promises">Using promises</a></li>
 <li><a href="http://promisesaplus.com/">Promises/A+ specification</a></li>
 <li><a href="https://medium.com/@ramsunvtech/promises-of-promise-part-1-53f769245a53">Venkatraman.R - JS Promise (Part 1, Basics)</a></li>
 <li><a href="https://medium.com/@ramsunvtech/js-promise-part-2-q-js-when-js-and-rsvp-js-af596232525c#.dzlqh6ski">Venkatraman.R - JS Promise (Part 2 - Using Q.js, When.js and RSVP.js)</a></li>
 <li><a href="https://tech.io/playgrounds/11107/tools-for-promises-unittesting/introduction">Venkatraman.R - Tools for Promises Unit Testing</a></li>
 <li><a href="http://www.html5rocks.com/en/tutorials/es6/promises/">Jake Archibald: JavaScript Promises: There and Back Again</a></li>
 <li><a href="http://de.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript">Domenic Denicola: Callbacks, Promises, and Coroutines – Asynchronous Programming Patterns in JavaScript</a></li>
 <li><a href="http://www.mattgreer.org/articles/promises-in-wicked-detail/">Matt Greer: JavaScript Promises ... In Wicked Detail</a></li>
 <li><a href="https://www.promisejs.org/">Forbes Lindesay: promisejs.org</a></li>
 <li><a href="https://github.com/jakearchibald/es6-promise/">Promise polyfill</a></li>
 <li><a href="https://www.udacity.com/course/javascript-promises--ud898">Udacity: JavaScript Promises</a></li>
</ul>