web-dev-qa-db-fra.com

Est-il possible de résoudre une fonction asynchrone sans mot-clé de retour

J'ai commencé à utiliser la fonctionnalité async/await d'ES7, qui constitue la meilleure approche pour gérer les tâches asynchrones et rend votre code plus propre et lisible.

Cependant, il ne vous donne pas accès à Promise, créé par la fonction asynchrone. Par conséquent, si vous effectuez une requête asynchrone dans votre fonction asynchrone, vous devez la promettre, l'attendre puis renvoyer le résultat. Je veux dire ceci:

async function doStuff() {
    //stuff...
    var value = await new Promise(function(resolve) {
        $.get('http://some/url/...', function(result) {
            // stuff...
            resolve(result);
        });
    });
    return value;
}

Et si vous pouviez trouver un pointeur sur la promesse créée par la fonction afin que votre code ressemble à ceci:

async function doStuff() {
    //stuff...
    var p = arguments.callee.promise;
    $.get('http://some/url/...', function(result) {
        // stuff...
        p.resolve(result);
    });
}

ou même:

async function doStuff() {
    //stuff...
    $.get('http://some/url/...', function(result) {
        // stuff...
        async.resolve(result);
    });
}

De cette façon, vous n'avez pas besoin d'accéder directement à l'API Promises, ce qui rend votre code totalement concentré sur des tâches sans autre. 

javascriptasynchronousasync-awaitecmascript-2017
10
rokstar

Est-il possible de résoudre une fonction asynchrone sans mot-clé de retour

Non.

Il n’ya aucun moyen d’obtenir une référence à la promesse que l’appel au async function a créé, mais il n’est vraiment pas nécessaire d’y accéder (et btw, vous ne pouvez pas .resolve() une promesse, vous auriez réellement besoin d’avoir accès à la promesse fonctions de résolution).

Le but de async/await est de jouer à Nice avec des promesses et d'autres choses. L'idée est que chaque fonction asynchrone retourne une promesse et que vous n'avez rien à promettre (mais si vous devez le faire, faites-le séparément) - et en fait, $.get renvoie (jQuery) promis. Alors écrivez simplement

async function doStuff() {
    //stuff...
    var result = await $.get('http://some/url/...');
    // stuff...
    return value;
}

Si vous avez vraiment une fonction de rappel, utilisez un simple

async function doStuff() {
    // stuff…
    return new Promise(function(resolve, reject) {
        $.get({
            url: 'http://some/url/...',
            success: resolve,
            error: reject
            // don't do other "stuff" in here
        });
    });
}
13
Bergi

Lorsque vous retournez une promesse d'une fonction, il n'est pas nécessaire que la fonction soit asynchrone, en fait c'est même dommage car vous créez deux promesses!

function doStuff() {
    return new Promise(function(resolve, reject) {
        $.get('http://some/url/...', result => resolve(result));
    });
}

async function main() {
    const result = await doStuff();
}
0
Ali

Que diriez-vous de créer vos fonctions asynchrones et d’utiliser ensuite wait lorsque vous les appelez.

  //define
  async promiseFunction(foo) {
    return otherPromiseFunction(foo);
  async promiseFunction2(foo) {
    return '10';
  }
  async promiseFunction3(foo) {
    return new Promise((resolve, reject) => {
      resolve('foo')
    })
  }
//invoke
  anotherPromiseFunction(bar).then(async foo => {
    const fooResult = await promiseFunction(foo);
    return fooResult; 
  })
0
ariel guzman