Kết hợp chức năng async + await + setTimeout

Tôi đang cố gắng sử dụng các tính năng async 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 của google. Vì vậy, tôi muốn xây dựng một chức năng ngủ làm trì hoãn yêu cầu. Do đó 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ó một cách khác để trì hoãn yêu cầu, xin 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ả về hàm async ẩn danh trong setTimeout, nhưng tôi không biết làm thế nào tôi có thể trả lại phản hồi cho chức năng ngủ. đến chức năng 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ả về từ hàm ngủ, gọi lại trong hàm ẩn danh, v.v.

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

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, có lẽ bạn không muốn sử dụng sleepchức năng gọi lại và trì hoãn nó như thế này. Tôi muốn giới thiệu để làm một cái 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 chức promisifynăng chứ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")
})()

Một cách nhanh chóng, nội tuyến

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

setTimeoutkhông phải là một asyncchức năng, vì vậy bạn không thể sử dụng nó với ES7 async-await. Nhưng bạn có thể thực hiện sleepchức năng của mình bằ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ù điều đó 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 ing.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ư thế này:

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 đã thực hiện một ý 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

Đoạn 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 cảm hứng từ câu trả lời của Dave

Về cơ bản được chuyể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);
}

Đây là phiên bản của tôi với nodejs bây giờ 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)
    ...
}

Đây là một sửa chữa nhanh hơn trong một lót.

Hy vọng điều này sẽ giúp.

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