Tôi đang phát triển một giao diện điều khiển như kịch bản cho nhu cầu cá nhân. Tôi cần có thể tạm dừng trong một khoảng thời gian dài, nhưng, từ nghiên cứu của tôi, node.js không có cách nào để dừng lại theo yêu cầu. Thật khó để đọc thông tin của người dùng sau một khoảng thời gian ... Tôi đã thấy một số mã ngoài đó, nhưng tôi tin rằng họ phải có mã khác bên trong để họ làm việc như:

setTimeout(function() {
}, 3000);

Tuy nhiên, tôi cần mọi thứ sau dòng mã này để thực thi sau khoảng thời gian.

Ví dụ,

//start-of-code
console.log('Welcome to My Console,');
some-wait-code-here-for-ten-seconds..........
console.log('Blah blah blah blah extra-blah');
//endcode. 

Tôi cũng đã thấy những thứ như

yield sleep(2000);

Nhưng node.js không nhận ra điều này.

Làm thế nào tôi có thể đạt được sự tạm dừng kéo dài này?

Cách tốt nhất để làm điều này là chia mã của bạn thành nhiều hàm, như thế này:

function function1() {
    // stuff you want to happen right away
    console.log('Welcome to My Console,');
}

function function2() {
    // all the stuff you want to happen after that pause
    console.log('Blah blah blah blah extra-blah');
}

// call the first chunk of code right away
function1();

// call the rest of the code and have it execute after 3 seconds
setTimeout(function2, 3000);

Nó tương tự như giải pháp của JohnnyHK , nhưng gọn gàng hơn và dễ mở rộng hơn.

Một câu trả lời mới cho một câu hỏi cũ. Hôm nay ( tháng 1 năm 2017 tháng 6 năm 2019) nó dễ dàng hơn nhiều. Bạn có thể sử dụng cú pháp mớiasync/await . Ví dụ:

async function init() {
  console.log(1);
  await sleep(1000);
  console.log(2);
}

function sleep(ms) {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
}   

Để sử dụng async/awaitngoài hộp mà không cần cài đặt và bổ trợ, bạn phải sử dụng nút-v7 hoặc nút-v8, sử dụng --harmonycờ.

Cập nhật tháng 6 năm 2019: Bằng cách sử dụng các phiên bản mới nhất của NodeJS, bạn có thể sử dụng nó ngay lập tức. Không cần phải cung cấp đối số dòng lệnh. Ngay cả Google Chrome cũng hỗ trợ nó ngay hôm nay.

Cập nhật tháng 5 năm 2020: Bạn sẽ sớm có thể sử dụng awaitcú pháp bên ngoài chức năng không đồng bộ. Ở cấp cao nhất như trong ví dụ này

await sleep(1000)
function sleep(ms) {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
} 

Đề xuất là trong giai đoạn 3 . Bạn có thể sử dụng nó ngay hôm nay bằng cách sử dụng webpack 5 (alpha),

Thêm thông tin:

• Cờ hài hòa trong Nodejs: https://nodejs.org/en/docs/es6/
• Tất cả Phiên bản NodeJS để tải xuống: https://nodejs.org/en/doad/release/

Giải pháp ngắn nhất mà không có bất kỳ sự phụ thuộc nào:

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

Đặt mã mà bạn muốn thực thi sau khi trì hoãn trong cuộc setTimeoutgọi lại:

console.log('Welcome to My Console,');
setTimeout(function() {
    console.log('Blah blah blah blah extra-blah');
}, 3000);

Đây là một kỹ thuật chặn đơn giản:

var waitTill = new Date(new Date().getTime() + seconds * 1000);
while(waitTill > new Date()){}

Nó chặn trong chừng mực vì sẽ không có gì khác xảy ra trong tập lệnh của bạn (như cuộc gọi lại). Nhưng vì đây là một kịch bản console, có thể nó là thứ bạn cần!

Trên nút 7.6.0 trở lên

Nút hỗ trợ chờ đợi nguyên bản:

const sleep = (waitTimeInMs) => new Promise(resolve => setTimeout(resolve, waitTimeInMs));

sau đó nếu bạn có thể sử dụng các chức năng không đồng bộ:

await sleep(10000); // sleep for 10 seconds

hoặc là:

sleep(10000).then(() => {
  // This will execute 10 seconds from now
});

Trên các phiên bản Node cũ hơn (câu trả lời gốc)

Tôi muốn có một giấc ngủ không đồng bộ hoạt động trong Windows & Linux, mà không làm hỏng CPU của tôi với một vòng lặp dài. Tôi đã thử gói ngủ nhưng nó sẽ không cài đặt trên hộp Windows của tôi. Tôi đã kết thúc bằng cách sử dụng:

https://www.npmjs.com/package/system-s ngủ

Để cài đặt nó, gõ:

npm install system-sleep

Trong mã của bạn,

var sleep = require('system-sleep');
sleep(10*1000); // sleep for 10 seconds

Hoạt động như một lá bùa.

Chức năng ngủ đơn giản và thanh lịch sử dụng Javascript hiện đại

function sleep(millis) {
    return new Promise(resolve => setTimeout(resolve, millis));
}

Không phụ thuộc, không có địa ngục gọi lại; đó là nó :-)

Xem xét ví dụ được đưa ra trong câu hỏi, đây là cách chúng ta sẽ ngủ giữa hai bản ghi giao diện điều khiển:

async function main() {
    console.log("Foo");
    await sleep(2000);
    console.log("Bar");
}

main();

"Hạn chế" là chức năng chính của bạn bây giờ cũng phải asyncnhư vậy. Nhưng, xem xét bạn đã viết mã Javascript hiện đại, có lẽ bạn (hoặc ít nhất là nên!) Sử dụng async/ awaittrên toàn bộ mã của bạn, vì vậy đây thực sự không phải là vấn đề. Tất cả các trình duyệt hiện đại ngày nay đều hỗ trợ nó.

Cung cấp một cái nhìn sâu sắc về sleepchức năng cho những người không quen sử dụng async/awaitvà vận hành mũi tên béo, đây là cách viết dài dòng:

function sleep(millis) {
    return new Promise(function (resolve, reject) {
        setTimeout(function () { resolve(); }, millis);
    });
}

Tuy nhiên, sử dụng toán tử mũi tên béo làm cho nó thậm chí còn nhỏ hơn (và thanh lịch hơn).

Bạn có thể sử dụng www.npmjs.com/package/s ngủ này

var sleep = require('sleep');
sleep.sleep(10); // sleep for ten seconds

Câu hỏi này khá cũ, nhưng gần đây V8 đã thêm Máy phát điện có thể thực hiện những gì OP yêu cầu. Các trình tạo thường dễ sử dụng nhất cho các tương tác không đồng bộ với sự hỗ trợ của thư viện như tạm ngưng hoặc chạy gen .

Đây là một ví dụ sử dụng đình chỉ:

suspend(function* () {
    console.log('Welcome to My Console,');
    yield setTimeout(suspend.resume(), 10000); // 10 seconds pass..
    console.log('Blah blah blah blah extra-blah');
})();

Đọc liên quan (bằng cách tự quảng cáo không biết xấu hổ): Thỏa thuận lớn với Máy phát điện là gì? .

Trên Linux / nodejs, nó hoạt động với tôi:

const spawnSync = Yêu cầu ('child_ process'). spawnSync;

var ngủ = spawnSync ('ngủ', [1.5]);

Nó đang chặn, nhưng nó không phải là một vòng lặp chờ đợi bận rộn.

Thời gian bạn chỉ định là tính bằng giây nhưng có thể là một phần nhỏ. Tôi không biết nếu các hệ điều hành khác có lệnh tương tự.

Nếu bạn muốn "đánh gôn", bạn có thể tạo một phiên bản ngắn hơn của một số câu trả lời khác tại đây:

const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));

Nhưng thực sự câu trả lời lý tưởng theo ý kiến ​​của tôi là sử dụng utilthư viện của Node và promisifychức năng của nó , được thiết kế cho chính xác loại điều này (tạo các phiên bản dựa trên lời hứa của các công cụ không dựa trên lời hứa trước đây):

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

Trong cả hai trường hợp, bạn có thể tạm dừng đơn giản bằng cách sử dụng awaitđể gọi sleephàm của mình :

await sleep(1000); // sleep for 1s/1000ms

Gần đây tôi đã tạo ra sự trừu tượng đơn giản hơn được gọi là Wait.for để gọi các hàm async trong chế độ đồng bộ hóa (dựa trên các sợi nút). Ngoài ra còn có một phiên bản dựa trên ES6 Generators sắp tới.

https://github.com/luciotato/waitfor

Sử dụng Wait.for , bạn có thể gọi bất kỳ chức năng async nodejs tiêu chuẩn nào, như thể đó là một chức năng đồng bộ hóa, mà không chặn vòng lặp sự kiện của nút.

Bạn có thể mã tuần tự khi bạn cần, đó là, (tôi đoán) hoàn hảo để đơn giản hóa các tập lệnh của bạn cho sử dụng cá nhân.

sử dụng Wait.cho mã của bạn sẽ là:

require('waitfor')

..in a fiber..
//start-of-code
console.log('Welcome to My Console,');
wait.miliseconds(10*1000); //defined in waitfor/paralell-tests.js - DOES NOT BLOCK
console.log('Blah blah blah blah extra-blah');
//endcode. 

Ngoài ra, bất kỳ chức năng async nào cũng có thể được gọi trong chế độ Đồng bộ hóa . Kiểm tra các ví dụ.

Vì, công cụ javascript (v8) chạy mã dựa trên chuỗi các sự kiện trong hàng đợi sự kiện, không có gì nghiêm ngặt khi javascript kích hoạt chính xác việc thực thi sau thời gian quy định. Đó là, khi bạn đặt một vài giây để thực thi mã sau đó, việc kích hoạt mã hoàn toàn dựa trên chuỗi trong hàng đợi sự kiện. Vì vậy, việc kích hoạt thực thi mã có thể mất nhiều thời gian hơn quy định.

Vì vậy, Node.js theo sau,

process.nextTick()

để chạy mã sau thay vì setTimeout (). Ví dụ,

process.nextTick(function(){
    console.log("This will be printed later");
});

Với các hỗ trợ ES6 Promise, chúng tôi có thể sử dụng chúng mà không cần bất kỳ sự trợ giúp nào của bên thứ ba.

const sleep = (seconds) => {
    return new Promise((resolve, reject) => {
        setTimeout(resolve, (seconds * 1000));
    });
};

// We are not using `reject` anywhere, but it is good to
// stick to standard signature.

Sau đó sử dụng nó như thế này:

const waitThenDo(howLong, doWhat) => {
    return sleep(howLong).then(doWhat);
};

Lưu ý rằng doWhatchức năng trở thành cuộc resolvegọi lại trong new Promise(...).

Cũng lưu ý rằng đây là giấc ngủ ASYNCHRONOUS. Nó không chặn vòng lặp sự kiện. Nếu bạn cần chặn giấc ngủ, hãy sử dụng thư viện này để nhận ra việc chặn giấc ngủ với sự trợ giúp của các ràng buộc C ++. (Mặc dù nhu cầu ngủ chặn trong Node như môi trường không đồng bộ là rất hiếm.)

https://github.com/erikdubbelboer/node-s ngủ

let co = require('co');
const sleep = ms => new Promise(res => setTimeout(res, ms));

co(function*() {
    console.log('Welcome to My Console,');
    yield sleep(3000);
    console.log('Blah blah blah blah extra-blah');
});

Mã này ở trên là tác dụng phụ của việc giải quyết vấn đề địa ngục gọi lại không đồng bộ của Javascript. Đây cũng là lý do tôi nghĩ rằng làm cho Javascript trở thành một ngôn ngữ hữu ích trong phần phụ trợ. Thực tế đây là cải tiến thú vị nhất được giới thiệu cho Javascript hiện đại theo ý kiến ​​của tôi. Để hiểu đầy đủ về cách thức hoạt động của nó, cách thức hoạt động của máy phát điện cần phải được hiểu đầy đủ. Các functiontừ khóa theo sau là một *được gọi là một chức năng máy phát điện trong Javascript hiện đại. Gói npm cocung cấp chức năng chạy để chạy máy phát điện.

Về cơ bản, hàm tạo đã cung cấp một cách để tạm dừng việc thực thi một hàm bằng yieldtừ khóa, đồng thời, yieldtrong một hàm tạo giúp cho việc trao đổi thông tin giữa bên trong máy phát và người gọi. Điều này cung cấp một cơ chế cho người gọi trích xuất dữ liệu từ một promisecuộc gọi không đồng bộ và chuyển dữ liệu đã giải quyết trở lại máy phát. Thực tế, nó làm cho một cuộc gọi không đồng bộ đồng bộ.

Đây là mô-đun có hương vị khoảnh khắc dựa trên phương pháp chặn bẩn được đề xuất bởi @ atlex2 . Chỉ sử dụng để thử nghiệm .

const moment = require('moment');

let sleep = (secondsToSleep = 1) => {
    let sleepUntill = moment().add(secondsToSleep, 'seconds');
    while(moment().isBefore(sleepUntill)) { /* block the process */ }
}

module.exports = sleep;

Nếu bạn chỉ cần tạm dừng cho mục đích thử nghiệm, bạn thực hiện luồng hiện tại, hãy thử điều này:

function longExecFunc(callback, count) {

    for (var j = 0; j < count; j++) {
        for (var i = 1; i < (1 << 30); i++) {
            var q = Math.sqrt(1 << 30);
        }
    }
    callback();
}
longExecFunc(() => { console.log('done!')}, 5); //5, 6 ... whatever. Higher -- longer

đơn giản, chúng tôi sẽ đợi 5 giây để một số sự kiện xảy ra (điều đó được biểu thị bằng biến đã thực hiện được đặt thành đúng ở một nơi khác trong mã) hoặc khi hết thời gian, chúng tôi sẽ kiểm tra sau mỗi 100ms

    var timeout=5000; //will wait for 5 seconds or untildone
    var scope = this; //bind this to scope variable
    (function() {
        if (timeout<=0 || scope.done) //timeout expired or done
        {
            scope.callback();//some function to call after we are done
        }
        else
        {
            setTimeout(arguments.callee,100) //call itself again until done
            timeout -= 100;
        }
    })();

Đối với một số người, câu trả lời được chấp nhận không hoạt động, tôi đã tìm thấy câu trả lời khác này và nó đang hoạt động với tôi: Làm cách nào tôi có thể chuyển tham số cho cuộc gọi lại setTimeout ()?

var hello = "Hello World";
setTimeout(alert, 1000, hello); 

'xin chào' là tham số được truyền, bạn có thể vượt qua tất cả các tham số sau khi hết thời gian. Cảm ơn @Fabio Phms đã trả lời.

Thay vì thực hiện tất cả các setTimeout này, ngủ và nhiều thứ khác, tốt hơn là sử dụng

const delay = require('delay');
await delay(2000); // will wait for 2 seconds before executing next line of code

Các câu trả lời khác rất hay nhưng tôi nghĩ tôi sẽ thực hiện một chiến thuật khác.

Nếu tất cả những gì bạn thực sự tìm kiếm là làm chậm một tệp cụ thể trong linux:

 rm slowfile; mkfifo slowfile; perl -e 'select STDOUT; $| = 1; while(<>) {print $_; sleep(1) if (($ii++ % 5) == 0); }' myfile > slowfile  &

nút myprog Slowfile

Điều này sẽ ngủ 1 giây mỗi năm dòng. Chương trình nút sẽ đi chậm như người viết. Nếu nó đang làm những việc khác họ sẽ tiếp tục ở tốc độ bình thường.

Mkfifo tạo ra một đường ống vào trước xuất trước. Đó là những gì làm cho công việc này. Dòng perl sẽ viết nhanh như bạn muốn. $ | = 1 nói không đệm đầu ra.

Tôi kết hợp lại, sau khi đọc câu trả lời trong câu hỏi này, một hàm đơn giản cũng có thể thực hiện gọi lại, nếu bạn cần điều đó:

function waitFor(ms, cb) {
  var waitTill = new Date(new Date().getTime() + ms);
  while(waitTill > new Date()){};
  if (cb) {
    cb()
  } else {
   return true
  }
}

Để biết thêm thông tin về

yield sleep(2000); 

bạn nên kiểm tra Redux-Saga . Nhưng nó là cụ thể cho sự lựa chọn của bạn về Redux làm khung mô hình của bạn (mặc dù hoàn toàn không cần thiết).