Kombinasi fungsi async + menunggu + setTimeout

Saya mencoba menggunakan fitur async baru dan saya berharap menyelesaikan masalah saya akan membantu orang lain di masa depan. Ini adalah kode saya yang berfungsi:

  async function asyncGenerator() {
    // other code
    while (goOn) {
      // other code
      var fileList = await listFiles(nextPageToken);
      var parents = await requestParents(fileList);
      // other code
    }
    // other code
  }

  function listFiles(token) {
    return gapi.client.drive.files.list({
      'maxResults': sizeResults,
      'pageToken': token,
      'q': query
    });
  }

Masalahnya adalah, bahwa loop sementara saya berjalan terlalu cepat dan script mengirim terlalu banyak permintaan per detik ke Google API. Oleh karena itu saya ingin membangun fungsi tidur yang menunda permintaan. Jadi saya juga bisa menggunakan fungsi ini untuk menunda permintaan lainnya. Jika ada cara lain untuk menunda permintaan, harap beri tahu saya.

Bagaimanapun, ini adalah kode baru saya yang tidak berfungsi. Respons permintaan dikembalikan ke fungsi async anonim dalam setTimeout, tetapi saya tidak tahu bagaimana saya bisa mengembalikan respons ke resp fungsi tidur. ke fungsi asyncGenerator awal.

  async function asyncGenerator() {
    // other code
    while (goOn) {
      // other code
      var fileList = await sleep(listFiles, nextPageToken);
      var parents = await requestParents(fileList);
      // other code
    }
    // other code
  }

  function listFiles(token) {
    return gapi.client.drive.files.list({
      'maxResults': sizeResults,
      'pageToken': token,
      'q': query
    });
  }

  async function sleep(fn, par) {
    return await setTimeout(async function() {
      await fn(par);
    }, 3000, fn, par);
  }

Saya sudah mencoba beberapa opsi: menyimpan respons dalam variabel global dan mengembalikannya dari fungsi tidur, panggilan balik dalam fungsi anonim, dll.

Anda sleepfungsi tidak bekerja karena setTimeouttidak (belum?) Kembali janji yang bisa awaited. Anda perlu mengesahkannya secara manual:

function timeout(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}
async function sleep(fn, ...args) {
    await timeout(3000);
    return fn(...args);
}

Btw, untuk memperlambat lingkaran Anda, Anda mungkin tidak ingin menggunakan sleepfungsi yang menerima panggilan balik dan menolaknya seperti ini. Saya lebih suka merekomendasikan untuk melakukan sesuatu seperti

while (goOn) {
  // other code
  var [parents] = await Promise.all([
      listFiles(nextPageToken).then(requestParents),
      timeout(5000)
  ]);
  // other code
}

yang memungkinkan perhitungan parentswaktu setidaknya 5 detik.

Sejak Node 7.6 , Anda dapat menggabungkan fungsi promisifyfungsi dari modul utils dengan setTimeout().

Node.js

const sleep = require('util').promisify(setTimeout)

Javascript

const sleep = m => new Promise(r => setTimeout(r, m))

Pemakaian

(async () => {
    console.time("Slept for")
    await sleep(3000)
    console.timeEnd("Slept for")
})()

Satu garis cepat, cara sejajar

 await new Promise(resolve => setTimeout(resolve, 1000));

setTimeoutbukan asyncfungsi, jadi Anda tidak dapat menggunakannya dengan ES7 async-tunggu. Tetapi Anda bisa mengimplementasikan sleepfungsi Anda menggunakan ES6 Promise :

function sleep (fn, par) {
  return new Promise((resolve) => {
    // wait 3s before calling fn(par)
    setTimeout(() => resolve(fn(par)), 3000)
  })
}

Maka Anda akan dapat menggunakan sleepfungsi baru ini dengan ES7 async-tunggu:

var fileList = await sleep(listFiles, nextPageToken)

Harap perhatikan bahwa saya hanya menjawab pertanyaan Anda tentang menggabungkan ES7 async / menunggu dengan setTimeout, meskipun mungkin tidak membantu menyelesaikan masalah Anda dengan mengirimkan terlalu banyak permintaan per detik.

Pembaruan: Versi node.js modern memiliki implementasi batas waktu async buid-in, dapat diakses melalui utilitas helper.

const {promisify} = require('util');
const setTimeoutAsync = promisify(setTimeout);

Jika Anda ingin menggunakan jenis sintaksis yang sama seperti setTimeoutAnda dapat menulis fungsi pembantu seperti ini:

const setAsyncTimeout = (cb, timeout = 0) => new Promise(resolve => {
    setTimeout(() => {
        cb();
        resolve();
    }, timeout);
});

Anda kemudian dapat menyebutnya seperti ini:

const doStuffAsync = async () => {
    await setAsyncTimeout(() => {
        // Do stuff
    }, 1000);

    await setAsyncTimeout(() => {
        // Do more stuff
    }, 500);

    await setAsyncTimeout(() => {
        // Do even more stuff
    }, 2000);
};

doStuffAsync();

Saya membuat intisari: https://gist.github.com/DaveBitter/f44889a2a52ad16b6a5129c39444bb57

var testAwait = function () {
    var promise = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('Inside test await');
        }, 1000);
    });
    return promise;
}

var asyncFunction = async function() {
    await testAwait().then((data) => {
        console.log(data);
    })
    return 'hello asyncFunction';
}

asyncFunction().then((data) => {
    console.log(data);
});

//Inside test await
//hello asyncFunction

Kode berikut berfungsi di Chrome dan Firefox dan mungkin browser lainnya.

function timeout(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}
async function sleep(fn, ...args) {
    await timeout(3000);
    return fn(...args);
}

Tetapi di Internet Explorer saya mendapatkan Kesalahan Sintaks untuk "(resolve **=>** setTimeout..."

Membuat util terinspirasi dari Dave 's jawaban

Pada dasarnya diteruskan dalam donepanggilan balik untuk menelepon ketika operasi selesai.

// Function to timeout if a request is taking too long
const setAsyncTimeout = (cb, timeout = 0) => new Promise((resolve, reject) => {
  cb(resolve);
  setTimeout(() => reject('Request is taking too long to response'), timeout);
});

Ini adalah bagaimana saya menggunakannya:

try {
  await setAsyncTimeout(async done => {
    const requestOne = await someService.post(configs);
    const requestTwo = await someService.get(configs);
    const requestThree = await someService.post(configs);
    done();
  }, 5000); // 5 seconds max for this set of operations
}
catch (err) {
  console.error('[Timeout] Unable to complete the operation.', err);
}

Ini adalah versi saya dengan nodejs sekarang pada tahun 2020 di lab AWS

const sleep = require('util').promisify(setTimeout)

async function f1 (some){
...
}

async function f2 (thing){
...
}

module.exports.someFunction = async event => {
    ...
    await f1(some)
    await sleep(5000)
    await f2(thing)
    ...
}

Ini adalah perbaikan yang lebih cepat dalam satu-liner.

Semoga ini bisa membantu.

// WAIT FOR 200 MILISECONDS TO GET DATA //
await setTimeout(()=>{}, 200);