Ich versuche zu verstehen, wie async/await in Verbindung mit Versprechungen funktioniert.

Code

async function latestTime() {
  const bl = await web3.eth.getBlock('latest');
  console.log(bl.timestamp); // Returns a primitive
  console.log(typeof bl.timestamp.then == 'function'); //Returns false - not a promise
  return bl.timestamp;
}
const time = latestTime(); // Promise { <pending> }

Problem

Soweit ich weiß, sollte await blockieren und im obigen Code scheint es die Rückgabe eines Objekts zu blockieren bl mit dem Primitiven timestamp. Dann gibt meine Funktion den primitiven Wert zurück, die Zeitvariable wird jedoch auf ein ausstehendes Versprechen anstelle dieses Primitivs gesetzt. Was vermisse ich?

Async-Präfix ist eine Art Wrapper für Promises.

async function latestTime() {
    const bl = await web3.eth.getBlock('latest');
    console.log(bl.timestamp); // Returns a primitive
    console.log(typeof bl.timestamp.then == 'function'); //Returns false - not a promise
    return bl.timestamp;
}

Ist das gleiche wie

function latestTime() {
    return new Promise(function(resolve,success){
        const bl = web3.eth.getBlock('latest');
        bl.then(function(result){
            console.log(result.timestamp); // Returns a primitive
            console.log(typeof result.timestamp.then == 'function'); //Returns false - not a promise
            resolve(result.timestamp)
        })
}

Ein async Die Funktion gibt immer ein Promise zurück. So meldet es den Abschluss seiner asynchronen Arbeit. Wenn Sie es in einem anderen verwenden async Funktion, die Sie verwenden können await zu warten, bis sich sein Versprechen erfüllt, aber in einer nichtasync Funktion (häufig auf der obersten Ebene oder in einem Event-Handler), müssen Sie das Promise direkt verwenden, z.

latestTime()
.then(time => {
    console.log(time);
})
.catch(error => {
    // Handle/report error
});

Wenn Sie dies auf der obersten Ebene eines JavaScript-Moduls tun, unterstützen einige Umgebungen jetzt das kommende Höchststufe await in Modulen:

const time = await latestTime();

JavaScript-Engines erhalten Unterstützung für Top-Level awaitund Webpack bietet experimentelle Unterstützung dafürzum Beispiel.

Hier ist eine grobe Übersetzung von Ihnen async Funktion in expliziten Versprechensbedingungen:

function latestTime() {
    return new Promise((resolve, reject) => {
        web3.eth.getBlock('latest')
        .then(bl => {
            console.log(bl.timestamp);
            console.log(typeof bl.timestamp.then == 'function');
            resolve(bl.timestamp);
        })
        .catch(reject);
    });
}

Einige wichtige Hinweise dazu:

• Die Funktion, an die Sie übergeben new Promise (der Versprechen Vollstrecker Funktion) wird synchron von aufgerufen new Promise.
  • Deshalb beginnt die Operation, web3.eth.getBlock wird synchron aufgerufen, um die Arbeit zu starten.
• Jeder Fehler (usw.), der im Promise Executor geworfen wird, wird abgefangen new Promise und Umwandlung in eine Versprechensablehnung.
• Jeder Fehler (usw.), der in einem Promise-Callback geworfen wird (wie der, den wir übergeben then) wird abgefangen und in eine Ablehnung umgewandelt.

async Funktion wird zurückkehren Promise ohnehin. Der Rückgabewert ist `Promise, also in Ihrem Fall:

async function latestTime(): Promise<some primitive> {
  const bl = await web3.eth.getBlock('latest');
  return bl.timestamp;
}

Also, weiter können Sie es wie folgt verwenden:

const time = await latestTime();

Aber für das Erreichen einer allgemeinen Ansicht über async/await Feature wird es besser sein, Dokumentation zu lesen.