Sự kết hợp của hàm async + await + setTimeout

Tôi đang cố gắng sử dụng các tính năng không đồng bộ mới và tôi hy vọng việc giải quyết vấn đề của mình sẽ giúp ích cho những người khác trong tương lai. Đây là mã của tôi đang hoạt động:

  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
    });
  }

Vấn đề là, vòng lặp while của tôi chạy quá nhanh và tập lệnh gửi quá nhiều yêu cầu mỗi giây đến API google. Vì vậy, tôi muốn xây dựng một chức năng ngủ để làm chậm yêu cầu. Vì vậy, tôi cũng có thể sử dụng chức năng này để trì hoãn các yêu cầu khác. Nếu có cách nào khác để trì hoãn yêu cầu, vui lòng cho tôi biết.

Dù sao, đây là mã mới của tôi không hoạt động. Phản hồi của yêu cầu được trả lại cho hàm async ẩn danh trong setTimeout, nhưng tôi không biết làm cách nào để có thể trả lại phản hồi cho hàm sleep. vào hàm asyncGenerator ban đầu.

  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);
  }

Tôi đã thử một số tùy chọn: lưu trữ phản hồi trong một biến toàn cục và trả lại nó từ hàm sleep, gọi lại trong hàm ẩn danh, v.v.

sleepHàm của bạn không hoạt động vì setTimeoutkhông (chưa?) Trả về một lời hứa có thể được chỉnh sửa await. Bạn sẽ cần phải quảng bá nó theo cách thủ công:

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

Btw, để làm chậm vòng lặp của bạn, bạn có thể không muốn sử dụng một sleephàm thực hiện cuộc gọi lại và định nghĩa nó như thế này. Tôi muốn khuyên bạn nên làm điều gì đó như

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

cho phép tính toán parentsmất ít nhất 5 giây.

Kể từ Node 7.6 , bạn có thể kết hợp các hàm promisifychức năng từ mô-đun utils với setTimeout().

Node.js

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

Javascript

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

Sử dụng

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

Cách nhanh chóng, một lớp lót

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

setTimeoutkhông phải là một asynchàm, vì vậy bạn không thể sử dụng nó với ES7 async-await. Nhưng bạn có thể triển khai sleepchức năng của mình bằng cách sử dụng ES6 Promise :

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

Sau đó, bạn sẽ có thể sử dụng sleepchức năng mới này với ES7 async-await:

var fileList = await sleep(listFiles, nextPageToken)

Xin lưu ý rằng tôi chỉ trả lời câu hỏi của bạn về việc kết hợp ES7 async / await với setTimeout, mặc dù nó có thể không giúp giải quyết vấn đề của bạn với việc gửi quá nhiều yêu cầu mỗi giây.

Cập nhật: Các phiên bản node.js hiện đại có triển khai thời gian chờ không đồng bộ buid-in, có thể truy cập thông qua trình trợ giúp use.promisify :

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

Nếu bạn muốn sử dụng cùng một loại cú pháp như setTimeoutbạn có thể viết một hàm trợ giúp như sau:

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

Sau đó, bạn có thể gọi nó như vậy:

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

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

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

doStuffAsync();

Tôi đã nêu ý chính: 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

Đây là phiên bản của tôi với nodejs vào năm 2020 trong AWS labdas

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)
    ...
}

Cập nhật năm 2020

Bạn có thể await setTimeoutvới Node.js 15 trở lên:

const timersPromises = require('timers/promises');

(async () => {
  const result = await timersPromises.setTimeout(2000, 'resolved')
  // Executed after 2 seconds
  console.log(result); // "resolved"
})()

API Timers Promises: https://nodejs.org/api/timers.html#timers_timers_promises_api (thư viện đã được tích hợp sẵn trong Node)

Lưu ý: Tính ổn định: 1 - Không khuyến khích sử dụng tính năng này trong môi trường sản xuất.

Mã sau hoạt động trong Chrome và Firefox và có thể các trình duyệt khác.

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

Nhưng trong Internet Explorer, tôi gặp lỗi Cú pháp cho "(resolve **=>** setTimeout..."

Tạo ra một ứng dụng lấy cảm hứng từ câu trả lời của Dave

Về cơ bản được truyền trong một donecuộc gọi lại để gọi khi hoạt động kết thúc.

// 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);
});

Đây là cách tôi sử dụng nó:

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);
}

await setTimeout(()=>{}, 200);

Sẽ hoạt động nếu phiên bản Node của bạn là 15 trở lên.