Saya sedang mengembangkan konsol seperti naskah untuk kebutuhan pribadi. Saya harus dapat berhenti untuk waktu yang lama, tetapi, dari penelitian saya, node.js tidak memiliki cara untuk berhenti seperti yang diperlukan. Semakin sulit membaca informasi pengguna setelah jangka waktu tertentu ... Saya telah melihat beberapa kode di luar sana, tetapi saya percaya mereka harus memiliki kode lain di dalamnya agar mereka dapat bekerja seperti:

setTimeout(function() {
}, 3000);

Namun, saya perlu segalanya setelah baris kode ini untuk dieksekusi setelah periode waktu.

Sebagai contoh,

//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. 

Saya juga pernah melihat hal-hal seperti

yield sleep(2000);

Tetapi node.js tidak mengenali ini.

Bagaimana saya bisa mencapai jeda yang diperpanjang ini?

Cara terbaik untuk melakukannya adalah dengan memecah kode Anda menjadi beberapa fungsi, seperti ini:

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

Ini mirip dengan solusi JohnnyHK , tetapi jauh lebih rapi dan lebih mudah diperluas.

Jawaban baru untuk pertanyaan lama. Hari ini ( Jan 2017 Juni 2019) jauh lebih mudah. Anda dapat menggunakan sintaks baruasync/await . Sebagai contoh:

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

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

Untuk menggunakan di async/awaitluar kotak tanpa menginstal dan plugin, Anda harus menggunakan node-v7 atau node-v8, menggunakan --harmonyflag.

Pembaruan Juni 2019: Dengan menggunakan versi terbaru NodeJS Anda dapat menggunakannya di luar kotak. Tidak perlu memberikan argumen baris perintah. Bahkan Google Chrome mendukungnya hari ini.

Pembaruan Mei 2020: Anda akan segera dapat menggunakan awaitsintaks di luar fungsi async. Di tingkat atas seperti dalam contoh ini

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

Proposal ada di tahap 3 . Anda dapat menggunakannya hari ini dengan menggunakan webpack 5 (alpha),

Info lebih lanjut:

• Bendera Harmoni di Nodejs: https://nodejs.org/en/docs/es6/
• Semua Versi NodeJS untuk diunduh: https://nodejs.org/en/download/releases/

Solusi terpendek tanpa ketergantungan:

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

Masukkan kode yang ingin Anda jalankan setelah penundaan dalam setTimeoutpanggilan balik:

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

Ini adalah teknik pemblokiran sederhana:

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

Ini memblokir sejauh tidak ada hal lain yang akan terjadi dalam skrip Anda (seperti panggilan balik). Tetapi karena ini adalah skrip konsol, mungkin itu yang Anda butuhkan!

Pada Node 7.6.0 atau lebih tinggi

Node mendukung menunggu secara asli:

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

maka jika Anda dapat menggunakan fungsi async:

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

atau:

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

Pada versi Node yang lebih lama (jawaban asli)

Saya ingin tidur asinkron yang bekerja di Windows & Linux, tanpa memonopoli CPU saya dengan loop yang lama. Saya mencoba paket tidur tetapi tidak mau menginstal di kotak Windows saya. Saya akhirnya menggunakan:

https://www.npmjs.com/package/system-sleep

Untuk menginstalnya, ketik:

npm install system-sleep

Dalam kode Anda,

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

Bekerja seperti pesona.

Fungsi tidur sederhana dan elegan menggunakan Javascript modern

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

Tidak ada ketergantungan, tidak ada panggilan balik neraka; itu dia :-)

Mempertimbangkan contoh yang diberikan dalam pertanyaan, ini adalah bagaimana kita akan tidur di antara dua log konsol:

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

main();

"Kelemahan" adalah bahwa fungsi utama Anda sekarang juga harus async. Tapi, mengingat Anda sudah menulis kode Javascript modern, Anda mungkin (atau setidaknya seharusnya!) Menggunakan async/ awaitseluruh kode Anda, jadi ini benar-benar bukan masalah. Semua browser modern saat ini mendukungnya .

Memberikan sedikit wawasan tentang sleepfungsi bagi mereka yang tidak terbiasa async/awaitdan operator panah gemuk, ini adalah cara tertulis untuk menuliskannya:

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

Namun, menggunakan operator panah gemuk membuatnya lebih kecil (dan lebih elegan).

Anda dapat menggunakan www.npmjs.com/package/sleep ini

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

Pertanyaan ini cukup lama, tetapi baru-baru ini V8 telah menambahkan Generator yang dapat memenuhi apa yang diminta OP. Generator umumnya paling mudah digunakan untuk interaksi async dengan bantuan perpustakaan seperti suspend atau gen-run .

Berikut ini contoh menggunakan penangguhan:

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

Bacaan terkait (dengan cara mempromosikan diri yang tidak tahu malu): Apa Kesepakatan Besar dengan Generator? .

Di Linux / nodejs ini berfungsi untuk saya:

const spawnSync = membutuhkan ('child_process'). spawnSync;

var sleep = spawnSync ('sleep', [1.5]);

Itu memblokir, tetapi itu bukan loop menunggu yang sibuk.

Waktu yang Anda tentukan adalah dalam detik tetapi bisa berupa pecahan. Saya tidak tahu apakah OS lain memiliki perintah serupa.

Jika Anda ingin "golf kode", Anda dapat membuat versi pendek dari beberapa jawaban lain di sini:

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

Tapi sebenarnya jawaban ideal menurut saya adalah menggunakan utilperpustakaan Node dan promisifyfungsinya, yang dirancang untuk hal semacam ini (membuat versi berbasis janji dari hal-hal yang sebelumnya tidak berbasis janji):

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

Dalam kedua kasus tersebut, Anda dapat menjeda hanya dengan menggunakan awaituntuk memanggil sleepfungsi Anda :

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

Saya baru-baru ini membuat abstraksi sederhana bernama wait.for untuk memanggil fungsi-fungsi async dalam mode sinkronisasi (berdasarkan pada node-fiber). Ada juga versi berdasarkan ES6 Generator yang akan datang.

https://github.com/luciotato/waitfor

Menggunakan wait.for , Anda dapat memanggil fungsi async nodejs standar apa saja, seolah-olah itu adalah fungsi sinkronisasi, tanpa memblokir loop peristiwa simpul.

Anda dapat kode secara berurutan saat Anda membutuhkannya, yaitu, (saya kira) sempurna untuk menyederhanakan skrip Anda untuk penggunaan pribadi.

menggunakan wait.for kode Anda akan:

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. 

Fungsi async apa pun dapat dipanggil dalam mode Sinkronisasi . Lihat contohnya.

Karena, mesin javascript (v8) menjalankan kode berdasarkan urutan peristiwa dalam antrian-acara, Tidak ada batasan ketat bahwa javascript memicu eksekusi tepat setelah waktu yang ditentukan. Yaitu, ketika Anda menetapkan beberapa detik untuk mengeksekusi kode nanti, memicu kode murni berdasarkan urutan dalam antrian acara. Jadi memicu eksekusi kode mungkin membutuhkan waktu lebih dari waktu yang ditentukan.

Jadi Node.js mengikuti,

process.nextTick()

untuk menjalankan kode nanti, alih-alih setTimeout (). Sebagai contoh,

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

Dengan dukungan ES6 Promise, kita dapat menggunakannya tanpa bantuan pihak ketiga.

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.

Kemudian gunakan seperti ini:

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

Perhatikan bahwa doWhatfungsi menjadi resolvepanggilan balik di dalamnew Promise(...) .

Perhatikan juga bahwa ini adalah tidur ASYNCHRONOUS. Itu tidak memblokir loop acara. Jika Anda perlu memblokir tidur, gunakan perpustakaan ini yang menyadari memblokir tidur dengan bantuan binding C ++. (Meskipun kebutuhan untuk memblokir tidur di Node seperti lingkungan async jarang terjadi.)

https://github.com/erikdubbelboer/node-sleep

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

Kode di atas adalah efek samping dari penyelesaian masalah neraka panggilan balik asinkron Javascript. Ini juga alasan saya berpikir bahwa menjadikan Javascript bahasa yang berguna di backend. Sebenarnya ini adalah peningkatan paling menarik yang diperkenalkan ke Javascript modern menurut saya. Untuk sepenuhnya memahami cara kerjanya, bagaimana generator bekerja harus dipahami sepenuhnya. Kata functionkunci yang diikuti oleh *disebut fungsi generator dalam Javascript modern. Paket npm comenyediakan fungsi pelari untuk menjalankan generator.

Pada dasarnya fungsi generator menyediakan cara untuk menghentikan eksekusi fungsi dengan yieldkata kunci, pada saat yang sama, yielddalam fungsi generator memungkinkan untuk bertukar informasi antara di dalam generator dan pemanggil. Ini menyediakan mekanisme bagi pemanggil untuk mengekstrak data dari promisepanggilan asinkron dan untuk meneruskan data yang diselesaikan ke generator. Secara efektif, itu membuat panggilan tidak sinkron sinkron.

Ini adalah modul rasa moment.js berdasarkan pendekatan pemblokiran kotor yang disarankan oleh @ atlex2 . Gunakan ini hanya untuk pengujian .

const moment = require('moment');

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

module.exports = sleep;

Jika Anda hanya perlu menangguhkan untuk tujuan pengujian, eksekusi utas Anda saat ini coba ini:

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

sederhana kita akan menunggu 5 detik untuk beberapa peristiwa terjadi (yang akan ditunjukkan oleh variabel yang disetel ke true di tempat lain dalam kode) atau ketika batas waktu habis bahwa kita akan memeriksa setiap 100 ms

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

Bagi sebagian orang, jawaban yang diterima tidak berfungsi, saya menemukan jawaban yang lain dan ini berfungsi untuk saya: Bagaimana saya bisa meneruskan parameter ke callback setTimeout ()?

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

'halo' adalah parameter yang dilewati, Anda dapat melewati semua parameter setelah batas waktu. Terima kasih kepada @Fabio Phms untuk jawabannya.

Daripada melakukan semua setTimeout ini, tidur dan banyak hal lainnya, lebih baik digunakan

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

Jawaban lainnya bagus, tetapi saya pikir saya akan mengambil kebijaksanaan yang berbeda.

Jika yang benar-benar Anda cari adalah memperlambat file tertentu di linux:

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

node myprog slowfile

Ini akan tidur 1 detik setiap lima baris. Program simpul akan berjalan lambat seperti penulis. Jika melakukan hal lain, mereka akan melanjutkan dengan kecepatan normal.

Mkfifo menciptakan pipa pertama-masuk-pertama-keluar. Inilah yang membuat ini bekerja. Baris perl akan menulis secepat yang Anda inginkan. $ | = 1 mengatakan jangan buffer output.

Saya mengumpulkan, setelah membaca jawaban dalam pertanyaan ini, fungsi sederhana yang juga dapat melakukan panggilan balik, jika Anda membutuhkannya:

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

Untuk info lebih lanjut

yield sleep(2000); 

Anda harus memeriksa Redux-Saga . Tapi itu khusus untuk pilihan Anda Redux sebagai kerangka kerja model Anda (meskipun sangat tidak perlu).