Ist Async für es6 oder es7?

async ist es7. Async und Wait sind neue Ergänzungen zu ES7 und Lösungen für asynchrone Vorgänge. Man kann sagen, dass Async/Await syntaktischer Zucker für Co-Module und Generatorfunktionen ist und js asynchronen Code mit klarerer Semantik löst. Wie der Name schon sagt, bedeutet Async „asynchron“. Async wird verwendet, um zu deklarieren, dass eine Funktion asynchron ist. Es gibt eine strikte Regel zwischen Async und Wait.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, ECMAScript Version 6, Dell G3-Computer.

In ES7 (ES2017) vorgeschlagene asynchrone Front-End-Funktionen: asynchron, warten.

Was ist Async/Await?

Async und Wait sind neue Ergänzungen in ES7. Für Lösungen für asynchrone Vorgänge kann man sagen, dass Async/Await syntaktischer Zucker für Co-Module und Generatorfunktionen ist. Lösen Sie asynchronen js-Code mit klarerer Semantik.

async bedeutet, wie der Name schon sagt, „asynchron“. Mit async wird erklärt, dass eine Funktion asynchron ist. Und Warten bedeutet wörtlich „Warten“ und wird verwendet, um auf den asynchronen Abschluss zu warten.

Async und Wait haben eine strenge Regel. Beide können nicht ohne einander leben. Wait kann jedoch nur in asynchronen Funktionen geschrieben werden.

Studenten, die mit dem Co-Modul vertraut sind, sollten wissen, dass das Co-Modul ein von Master TJ geschriebenes Modul ist, das eine Generatorfunktion zur Lösung asynchroner Prozesse verwendet. Es kann als Ausführer der Generatorfunktion angesehen werden. Async/await ist ein Upgrade des Co-Moduls. Es verfügt über einen integrierten Generatorfunktions-Executor und ist nicht mehr auf das Co-Modul angewiesen. Gleichzeitig gibt async Promise zurück.

Aus der oben genannten Sicht wird Promise als grundlegendste Einheit verwendet, unabhängig davon, ob es sich um das Co-Modul oder um Async/Await handelt. Schüler, die nicht viel über Promise wissen, können zunächst mehr über Promise lernen.

Vergleichen Sie Promise, Co, Async/Await

Lassen Sie uns anhand eines einfachen Beispiels die Ähnlichkeiten, Unterschiede und Kompromisse zwischen den drei Methoden vergleichen.

Wir verwenden als Beispiel den NodeJS-Treiber von Mongodb, um die Mongodb-Datenbank abzufragen. Der Grund dafür ist, dass der JS-Treiber von Mongodb die Rückgabe von Promise standardmäßig implementiert hat und wir Promise nicht separat verpacken müssen.

Verwenden Sie die Promise-Kette

MongoClient.connect(url + db_name).then(db => {
    return db.collection('blogs');
}).then(coll => {
    return coll.find().toArray();
}).then(blogs => {
    console.log(blogs.length);
}).catch(err => {
    console.log(err);
})

Die then()-Methode von Promise kann ein anderes Promise oder einen synchronisierten Wert zurückgeben. Wenn ein synchronisierter Wert zurückgegeben wird, wird er in ein Promise gepackt. Im obigen Beispiel gibt db.collection() einen synchronisierten Wert zurück, d. h. ein Sammlungsobjekt, das jedoch in ein Promise eingeschlossen und transparent an die nächste then()-Methode übergeben wird. Das obige Beispiel verwendet eine Promise-Kette. Stellen Sie zunächst eine Verbindung zur Datenbank MongoClient her. connect () gibt ein Versprechen zurück, rufen Sie dann die Datenbankobjekt-Datenbank in der Methode then () ab, rufen Sie dann das Coll-Objekt ab und geben Sie es zurück. Rufen Sie das Coll-Objekt in der nächsten then()-Methode ab, führen Sie dann eine Abfrage durch, geben Sie die Abfrageergebnisse zurück und rufen Sie die then()-Methode Schicht für Schicht auf, um eine Promise-Kette zu bilden. Wenn in dieser Promise-Kette eine Ausnahme in einem Link auftritt, wird diese vom letzten Catch() abgefangen. Man kann sagen, dass dieser mit der Promise-Kette geschriebene Code eleganter und der Prozess klarer ist als der schichtweise Aufruf von Callback-Funktionen. Rufen Sie zuerst das Datenbankobjekt ab, dann das Sammlungsobjekt und fragen Sie schließlich die Daten ab. Hier liegt jedoch ein nicht sehr „elegantes“ Problem vor, nämlich dass das von jeder then()-Methode erhaltene Objekt die von der vorherigen then()-Methode zurückgegebenen Daten sind. Es kann nicht schichtübergreifend darauf zugegriffen werden. Das bedeutet, dass wir im dritten Fall (blogs => {}) nur das Abfrageergebnis blogs erhalten, aber das obige DB-Objekt und Coll-Objekt nicht verwenden können. Was ist zu diesem Zeitpunkt, wenn Sie die Datenbank db.close() schließen möchten, nachdem Sie die Blogliste ausgedruckt haben? Derzeit gibt es zwei Lösungen:

Die erste besteht darin, die Verschachtelung von then() zu verwenden. Wir unterbrechen die Promise-Kette und machen sie verschachtelt, genau wie bei der Verschachtelung von Callback-Funktionen:

MongoClient.connect(url + db_name).then(db => {
    let coll = db.collection('blogs');
    coll.find().toArray().then(blogs => {
        console.log(blogs.length);
        db.close();
    }).catch(err => {
        console.log(err);
    });
}).catch(err => {
    console.log(err);
})

Hier verschachteln wir zwei Promise, sodass im letzten Abfragevorgang das externe Datenbankobjekt aufgerufen werden kann. Diese Methode wird jedoch nicht empfohlen. Der Grund ist einfach: Wir sind von einer Art Callback-Funktionshölle zu einer anderen Promise-Callback-Hölle übergegangen.
Darüber hinaus müssen wir die Ausnahme jedes Versprechens abfangen, da Versprechen keine Kette bilden.

Es gibt eine andere Möglichkeit, nämlich die Datenbank in jeder then()-Methode zu übergeben:

MongoClient.connect(url + db_name).then(db => {
    return {db:db,coll:db.collection('blogs')};
}).then(result => {
    return {db:result.db,blogs:result.coll.find().toArray()};
}).then(result => {
    return result.blogs.then(blogs => {   //注意这里，result.coll.find().toArray()返回的是一个Promise，因此这里需要再解析一层
        return {db:result.db,blogs:blogs}
    })
}).then(result => {
    console.log(result.blogs.length);
    result.db.close();
}).catch(err => {
    console.log(err);
});

Bei der Rückgabe jeder then()-Methode kombinieren wir die Datenbank und ihre anderen Ergebnisse jedes Mal in einer Objektrückgabe. Bitte beachten Sie, dass es in Ordnung ist, wenn jedes Ergebnis ein synchronisierter Wert ist. Wenn es sich jedoch um einen Promise-Wert handelt, erfordert jedes Promise eine zusätzliche Analyseebene.
Im obigen Beispiel ist das von der zweiten then()-Methode zurückgegebene {db:result.db,blogs:result.coll.find().toArray()}对象中，blogs ein Promise. In der nächsten then()-Methode können wir nicht direkt auf den Array-Wert der Blogliste verweisen, daher müssen wir then() aufrufen. Methode, um zuerst eine Ebene zu analysieren und dann die beiden Synchronisationswerte db und blogs zurückzugeben. Beachten Sie, dass dies die Verschachtelung von Promise beinhaltet, ein Promise jedoch nur eine Ebene von then() verschachtelt.

这种方式，也是很蛋疼的一个方式，因为如果遇到then()方法中返回的不是同步的值，而是Promise的话，我们需要多做很多工作。而且，每次都透传一个“多余”的db对象，在逻辑上也有点冗余。

但除此之外，对于Promise链的使用，如果遇到上面的问题，好像也没其他更好的方法解决了。我们只能根据场景去选择一种“最优”的方案，如果要使用Promise链的话。

鉴于Promise上面蛋疼的问题，TJ大神将ES6中的生成器函数，用co模块包装了一下，以更优雅的方式来解决上面的问题。

co搭配生成器函数

如果使用co模块搭配生成器函数，那么上面的例子可以改写如下：

const co = require('co');
co(function* (){
    let db = yield MongoClient.connect(url + db_name);
    let coll = db.collection('blogs');
    let blogs = yield coll.find().toArray();
    console.log(blogs.length);
    db.close();
}).catch(err => {
    console.log(err);
});

co是一个函数，将接受一个生成器函数作为参数，去执行这个生成器函数。生成器函数中使用yield关键字来“同步”获取每个异步操作的值。
上面代码在代码形式上，比上面使用Promise链要优雅，我们消灭了回调函数，代码看起来都是同步的。除了使用co和yield有点怪之外。

使用co模块，我们要将所有的操作包装成一个生成器函数，然后使用co()去调用这个生成器函数。看上去也还可以接受，但是ES的进化是不满足于此的，于是async/await被提到了ES7的提案。

async/await

我们先看一下使用async/await改写上面的代码：

(async function(){
    let db = await MongoClient.connect(url + db_name);
    let coll = db.collection('blogs');
    let blogs = await coll.find().toArray();
    console.log(blogs.length);
    db.close();
})().catch(err => {
    console.log(err);
});

我们对比代码可以看出，async/await和co两种方式代码极为相似。co换成了async，yield换成了await。同时生成器函数变成了普通函数。这种方式在语义上更加清晰明了，async表明这个函数是异步的，同时await表示要“等待”异步操作返回值。

async函数返回一个Promise，上面的代码其实是这样：

let getBlogs = async function(){
    let db = await MongoClient.connect(url + db_name);
    let coll = db.collection('blogs');
    let blogs = await coll.find().toArray();
    db.close();
    return blogs;
};
getBlogs().then(result => {
    console.log(result.length);
}).catch(err => {
    console.log(err);
})

我们定义getBlogs为一个async函数，最后返回得到的博客列表最终会被包装成一个Promise返回，如上，我们直接调用getBlogs().then()方法可获取async函数返回值。

好了，上面我们简单对比了一下三种解决异步方案，下面我们来深入了解一下async/await。

深入async/await

async返回值

async用于定义一个异步函数，该函数返回一个Promise。
如果async函数返回的是一个同步的值，这个值将被包装成一个理解resolve的Promise，等同于return Promise.resolve(value)。
await用于一个异步操作之前，表示要“等待”这个异步操作的返回值。await也可以用于一个同步的值。

//返回一个Promise
let timer = async function timer(){
    return new Promise((resolve,reject) => {
        setTimeout(() => {
            resolve('500');
        },500);
    });
}
timer().then(result => {
  console.log(result);  //500
}).catch(err => {
    console.log(err.message);
});

//返回一个同步的值
let sayHi = async function sayHi(){
  let hi = await 'hello world';   
  return hi;  //等同于return Promise.resolve(hi);
}
sayHi().then(result => {
  console.log(result);
});

上面这个例子返回是一个同步的值，字符串’hello world’，sayHi()是一个async函数，返回值被包装成一个Promise，可以调用then()方法获取返回值。对于一个同步的值，可以使用await，也可以不使用await。效果效果是一样的。具体用不用，看情况。

比如上面使用mongodb查询博客那个例子，let coll = db.collection('blogs');，这里我们就没有用await，因为这是一个同步的值。当然，也可以使用await，这样会显得代码统一。虽然效果是一样的。

async函数的异常

let sayHi = async function sayHi(){
    throw new Error('出错了');
}
sayHi().then(result => {
  console.log(result);
}).catch(err => {
    console.log(err.message);   //出错了
});

我们直接在async函数中抛出一个异常，由于返回的是一个Promise，因此，这个异常可以调用返回Promise的catch()方法捕捉到。

和Promise链的对比：
我们的async函数中可以包含多个异步操作，其异常和Promise链有相同之处，如果有一个Promise被reject()那么后面的将不会再进行。

let count = ()=>{
    return new Promise((resolve,reject) => {
        setTimeout(()=>{
            reject('故意抛出错误');
        },500);
    });
}
let list = ()=>{
    return new Promise((resolve,reject)=>{
        setTimeout(()=>{
            resolve([1,2,3]);
        },500);
    });
}
let getList = async ()=>{
    let c = await count();
    let l = await list();
    return {count:c,list:l};
}
console.time('begin');
getList().then(result => {
    console.log(result);
}).catch(err => {
    console.timeEnd('begin');
    console.log(err);
});
//begin: 507.490ms
//故意抛出错误

如上面的代码，定义两个异步操作，count和list，使用setTimeout延时500毫秒，count故意直接抛出异常，从输出结果来看，count()抛出异常后，直接由catch()捕捉到了，list()并没有继续执行。

并行

使用async后，我们上面的例子都是串行的。比如上个list()和count()的例子，我们可以将这个例子用作分页查询数据的场景。先查询出数据库中总共有多少条记录，然后再根据分页条件查询分页数据，最后返回分页数据以及分页信息。

我们上面的例子count()和list()有个“先后顺序”，即我们先查的总数，然后又查的列表。其实，这两个操作并无先后关联性，我们可以异步的同时进行查询，然后等到所有结果都返回时再拼装数据即可。

let count = ()=>{
    return new Promise((resolve,reject) => {
        setTimeout(()=>{
            resolve(100);
        },500);
    });
}
let list = ()=>{
    return new Promise((resolve,reject)=>{
        setTimeout(()=>{
            resolve([1,2,3]);
        },500);
    });
}
let getList = async ()=>{
    let result = await Promise.all([count(),list()]);
    return result;
}
console.time('begin');
getList().then(result => {
    console.timeEnd('begin');  //begin: 505.557ms
    console.log(result);       //[ 100, [ 1, 2, 3 ] ]
}).catch(err => {
    console.timeEnd('begin');
    console.log(err);
});

我们将count()和list()使用Promise.all()“同时”执行，这里count()和list()可以看作是“并行”执行的，所耗时间将是两个异步操作中耗时最长的耗时。

Das Endergebnis ist ein Array, das aus den Ergebnissen der beiden Operationen besteht. Wir müssen nur die Werte im Array der Reihe nach herausnehmen.

【Empfohlenes Lernen: Javascript-Video-Tutorial】

Das obige ist der detaillierte Inhalt vonIst Async für es6 oder es7?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!