Was Sie wissen müssen, um mit Promise zu beginnen

Dieses Mal werde ich Ihnen sagen, was Sie wissen müssen, um mit Promise zu beginnen. Welche Vorsichtsmaßnahmen Sie beachten müssen, um mit Promise zu beginnen?

Promise ist eine Lösung für die asynchrone Programmierung. Syntaktisch gesehen ist Promise ein Objekt, von dem Nachrichten für asynchrone Operationen abgerufen werden können.

Grundlegende Verwendung von Promise

PromiseKonstruktor akzeptiert eine Funktion als Parameter, und die beiden Parameter der Funktion sind Auflösung und Ablehnung. Dabei handelt es sich um zwei Funktionen, die von der JavaScript-Engine bereitgestellt werden.

• Die Funktion der Auflösungsfunktion besteht darin, den Status des Promise-Objekts von „unvollständig“ in „erfolgreich“ (d. h. von „Ausstehend“ in „Gelöst“) zu ändern, wenn das Der asynchrone Vorgang ist erfolgreich. Rufen Sie auf und übergeben Sie das Ergebnis des asynchronen Vorgangs als Parameter.

• Die Funktion der Ablehnungsfunktion besteht darin, den Status des Promise-Objekts von „unvollständig“ in „fehlgeschlagen“ zu ändern (d. h. von „Ausstehend“ in „Abgelehnt“) Der asynchrone Vorgang schlägt fehl. Rufen Sie auf und übergeben Sie den vom asynchronen Vorgang gemeldeten Fehler als Parameter. Die Methode

• then kann zwei

  Callback-Funktionen als Parameter akzeptieren. Die erste Rückruffunktion wird aufgerufen, wenn sich der Status des Promise-Objekts in „Resolved“ ändert, und die zweite Rückruffunktion wird aufgerufen, wenn sich der Status des Promise-Objekts in „Reject“ ändert .

var promise = new Promise(    //异步执行，Promise对象创建后会被立即执行
    function (resolve,reject) {        //耗时很长的异步操作　　if('异步处理成功') {　　
        resolve();    //数据处理成功时调用　　} else {
        reject();    //数据处理失败时调用    }
        
    }
)//Promise实例生成以后，可以用then方法分别指定Resolved状态和Reject状态的回调函数。promise.then(    function A() {        //数据处理成功后执行    },    function B() {        //数据处理失败后执行    }
)

Nehmen wir ein einfaches Beispiel, um den laufenden Prozess der asynchronen Betriebserfolgs- und asynchronen Betriebsfehlerfunktionen zu simulieren.

console.log('starting' promise =  Promise("2秒后，我运行了"'异步操作成功了');     
        
    }, 2000'异步操作成功后执行我:''异步操作失败后执行我:''我也运行了'

知代码3处的return 'hello' 语句在新建的new Promise对象中并没有被当作参数返回给then()函数内.那么会不会返回给promise了呢？我们用一段代码来测试一下

console.log('starting');var promise = new Promise(function(resolve, reject) {  
    setTimeout(function() { 
        console.log("2秒后，我运行了");
        resolve('异步操作成功了');     //1
        //reject('异步操作失败了');    //2
        return 'hello';
    }, 2000) 
    
})
promise.then(function (value) { 
    console.log('异步操作成功后执行我:',value);
},function (value) {
    console.log('异步操作失败后执行我:',value);
}
)
console.log('我也运行了');
console.log(promise);
setTimeout(function () {
    console.log('5秒后，我执行了');
    console.log(promise);
},5000);//starting//我也运行了//Promise { pending }　　//[[PromiseStatus]]:"pending"　　//[[PromiseValue]]:undefined　　//proto:Promise {constructor: , then: , catch: , …}//2秒后，我运行了//异步操作成功后执行我: 异步操作成功了//5秒后，我执行了//Promise { resolved }　　//[[PromiseStatus]]:"resolved"　　//[[PromiseValue]]:"异步操作成功了"　　//proto:Promise {constructor: , then: , catch: , …}

Aus den Ausführungsergebnissen ist ersichtlich, dass die Variable Promise immer noch eine Instanz des neuen Promise-Objekts ist. Obwohl die Return-Anweisung ausgeführt wird, hat sie daher keine Auswirkungen auf die Promise-Instanz, was einer Nichtexistenz gleichkommt.

Wie aus dem oben getesteten Code ersichtlich ist, weisen Promise-Objekte die folgenden zwei Merkmale auf.

(1) Der Zustand des Objekts wird von der Außenwelt nicht beeinflusst. Das Promise-Objekt stellt einen asynchronen Vorgang dar und hat drei Zustände: Ausstehend (in Bearbeitung), Gelöst (abgeschlossen, auch als „Erfüllt“ bezeichnet) und Abgelehnt (fehlgeschlagen).
Nur ​​das Ergebnis der asynchronen Operation kann bestimmen, welcher Zustand der aktuelle Zustand ist,

　 (2) Sobald sich der Zustand ändert, ändert er sich nicht mehr und das Ergebnis kann jederzeit abgerufen werden Zeit. Es gibt nur zwei Möglichkeiten, den Status eines Promise-Objekts zu ändern: von „Ausstehend“ zu „Gelöst“ und von „Ausstehend“ zu „Abgelehnt“. Solange diese beiden Situationen auftreten, wird der Zustand gefestigt und wird sich nicht mehr ändern und dieses Ergebnis beibehalten. Selbst wenn die Änderung bereits erfolgt ist, erhalten Sie das Ergebnis sofort, wenn Sie dem Promise-Objekt eine Rückruffunktion hinzufügen. Das ist etwas völlig anderes als ein Ereignis. Das Besondere an einem Ereignis ist, dass man kein Ergebnis erhält, wenn man es verpasst und noch einmal zuhört.

resolve(value) VS discover(Promise)

Wir rufen die Auflösungsfunktion

auf, wenn die asynchrone Operation erfolgreich ist, und ihre Funktion besteht darin, die zu ändern Der Status des Promise-Objekts aus „Pending“ wird „Resolved“ und das Ergebnis der asynchronen Operation wird als Parameter an den formalen Parameter der ersten Funktion in der then()-Methode übergeben.

Was ist also der Unterschied zwischen dem übergebenen Parameter als Wert und dem übergebenen Parameter als Promise-Objekt? Schauen wir uns ein Beispiel an.

Wenn der übergebene Parameter ein Wert ist:

var time = new Date();var promise = new Promise(function(resolve, reject) {  
    setTimeout(function() { 
        console.log("1秒后，我运行了");
        resolve('异步操作成功了');     //1
    }, 2000) 
    
}).then(function (value) {
    console.log(value,new Date() - time);
})//执行的输出结果为：//2秒后，我运行了//异步操作成功了 1002

Nach etwa einer Sekunde können wir sehen, dass wir in der Rückrufmethode des aufgelösten Zustands den obigen Kommentar ausgedruckt haben Inhalt. Wir können die Ergebnisse der Operation über die Auflösungsmethode weiterleiten und diese Ergebnisse dann in der Rückrufmethode verwenden.

Was passiert, wenn wir in Entschlossenheit eine Promise-Instanz übergeben?

 time =  promise =  Promise("2秒后，我运行了"'异步操作成功了');     2000 promise2 =  Promise(1000 Date() -

promise2 druckt das Ergebnis nach 2 Sekunden aus. Es ist seltsam. Haben wir versprochen2 nicht so eingestellt, dass es nach 1 Sekunde ausgeführt wird?

Um es einfach auszudrücken: Die Funktion „resolve()“ in Promise2 übergibt das Promise-Objekt. Zu diesem Zeitpunkt bestimmt der Status des Promise-Objekts den Status des Promises und der Rückgabewert wird an das Promise übergeben .

Promise/A+ legt

[[Resolve]](promise, x)

2.3.2 fest. Wenn x eine Promise-Instanz ist, wird der Zustand von x als Zustand des Versprechens verwendet

2.3 .2.1. Wenn der Status von x ausstehend ist, bleibt auch der Status von Versprechen ausstehend, bis sich der Status von x ändert.

2.3.2.2. Wenn der Status von x erfüllt ist, ist auch der Status des Versprechens erfüllt und der unveränderliche Wert von x wird als unveränderlicher Wert des Versprechens verwendet.

　 2.3.2.3.如果x的状态为rejected， promise的状态也为rejected， 并且以x的不可变原因作为promise的不可变原因。

2.3.4.如果x不是对象或函数，则将promise状态转换为fulfilled并且以x作为promise的不可变值。

 Promise.prototype.then()

Promise实例具有then方法，也就是说，then方法是定义在原型对象Promise.prototype上的。它的作用是为Promise实例添加状态改变时的回调函数。 前面说过，then方法的第一个参数是Resolved状态的回调函数，第二个参数（可选）是Rejected状态的回调函数。

then方法返回的是一个新的Promise实例（注意，不是原来那个Promise实例）。因此可以采用链式写法，即then方法后面再调用另一个then方法。

var promise = new Promise(function(resolve, reject) {  
    setTimeout(function() { 
        console.log("2秒后，我运行了");
        resolve('异步操作成功了');     //1
    }, 2000) 
    
})
promise.name = 'promise';
console.log('promise:',promise)var promise2 = promise.then(function (value) {
    console.log(value);
})
promise2.name = 'promise2';
console.log('promise2:',promise2);// promise://     Promise { pending }//     [[PromiseStatus]]:"pending"//     [[PromiseValue]]:undefined//     name:"promise"//     proto:Promise {constructor: , then: , catch: , …}// promise2:// Promise { pending }//     [[PromiseStatus]]:"pending"//     [[PromiseValue]]:undefined//     name:"promise2"//     proto:Promise {constructor: , then: , catch: , …}

我们可以知道promise.then()方法执行后返回的是一个新的Promise对象。也就是说上面代码中的promise2是一个Promise对象,它的实现效果和下面的代码是一样的，只不过在then()方法里，JS引擎已经自动帮我们做了。

promise2 = new Promise(function (resolve,reject) {})

既然在then()函数里已经自动帮我实现了一个promise对象，但是我要怎么才能给resolve()或reject()函数传参呢？其实在then()函数里，我们可以用return()的方式来给promise2的resolve()或reject()传参。看一个例子。

 promise =  Promise("2秒后，我运行了"'异步操作成功了');     
        
    }, 2000 promise2 = promise.then(
     (1 promise3 = promise2.then('is:''error:'= 'promise2'3000

Promise与错误状态处理

.then(null, rejection)，用于指定异步操作发生错误时执行的回调函数。下面我们做一个示例。

var promise = new Promise(function(resolve, reject) {
    setTimeout(function () {
            reject('error');
    },2000);
}).then(null,function(error) {
    console.log('rejected', error)
});//rejected error

我们知道then()方法执行后返回的也是一个promise对象，因此也可以调用then()方法，但这样的话为了捕获异常信息，我们就需要为每一个then()方法绑定一个.then(null, rejection)。由于Promise对象的错误信息具有“冒泡”性质，错误会一直向后传递，直到被捕获为止。因此Promise为我们提供了一个原型上的函数Promise.prototype.catch()来让我们更方便的 捕获到异常。

我们看一个例子

var promise = new Promise(function(resolve, reject) {
    setTimeout(function () {
            reject('error');
    },2000);
}).then(function(value) {
    console.log('resolve', value);
}).catch(function (error) {
    console.log(error);
})//运行结果//error

上面代码中，一共有二个Promise对象：一个由promise产生，一个由then产生。它们之中任何一个抛出的错误，都会被最后一个catch捕获。

但是如果用.then(null, rejection)方法来处理错误信息，我们需要在每一个rejection()方法中返回上一次异常信息的状态，这样当调用的then()方法一多的时候，对会对代码的清晰性和逻辑性造成影响。

所以，一般来说，不要在then方法里面定义Reject状态的回调函数（即then的第二个参数），总是使用catch方法。

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

在前端中的html基础知识 

知名的网站前端布局分析
关于前端的css基本知识

Das obige ist der detaillierte Inhalt vonWas Sie wissen müssen, um mit Promise zu beginnen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!