Kişisel ihtiyaçlar için komut dosyası gibi bir konsol geliştiriyorum. Uzun bir süre duraklayabilmem gerekiyor, ancak araştırmamdan node.js'nin gerektiği gibi durması mümkün değil. Bir süre sonra kullanıcıların bilgilerini okumak zorlaşıyor ... Orada bazı kodlar gördüm, ancak bunların çalışması için bunların içinde başka bir kod olması gerektiğine inanıyorum:

setTimeout(function() {
}, 3000);

Ancak, zaman sonra yürütmek için bu kod satırı sonra her şeyi gerekir.

Örneğin,

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

Ayrıca şöyle şeyler gördüm

yield sleep(2000);

Ancak node.js bunu tanımıyor.

Bu uzatılmış duraklamayı nasıl başarabilirim?

Bunu yapmanın en iyi yolu, kodunuzu aşağıdaki gibi birden fazla işleve bölmektir:

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

Bu JohnnyHK'nın çözümüne benzer , ancak çok daha temiz ve genişletilmesi daha kolay.

Eski bir soruya yeni bir cevap. Bugün ( Ocak 2017 Haziran 2019) çok daha kolay. Yeni async/awaitsözdizimini kullanabilirsiniz . Örneğin:

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

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

Kullanmak için async/awaityükleme ve eklentileri olmadan kutunun dışında, kullandığınız, düğüm-v7 veya düğüm-v8'i kullanmak zorunda --harmonybayrağı.

Haziran 2019'u Güncelle: NodeJS'nin en son sürümlerini kullanarak kutunun dışında kullanabilirsiniz. Komut satırı bağımsız değişkenleri sağlamanıza gerek yoktur. Google Chrome bile bugün bunu destekliyor.

Mayıs 2020 Güncellemesi: Yakında awaitsözdizimini bir zaman uyumsuz işlevin dışında kullanabileceksiniz . Bu örnekteki gibi üst düzeyde

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

Teklif 3. aşamada . Bugün webpack 5 (alfa) kullanarak kullanabilirsiniz,

Daha fazla bilgi:

• Nodejs'deki Harmony Bayrağı: https://nodejs.org/en/docs/es6/
• İndirmek için tüm NodeJS Sürümü: https://nodejs.org/en/download/releases/

Herhangi bir bağımlılığı olmayan en kısa çözüm:

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

Gecikmeden sonra yürütülmesini istediğiniz kodu geri aramaya koyun setTimeout:

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

Bu basit bir engelleme tekniğidir:

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

Bu oluyor engelleme başka bir şey (geri aramaları gibi) komut olacak şekilde sürece. Ama bu bir konsol betiği olduğundan, belki de ihtiyacınız olan şey budur!

Düğüm 7.6.0 veya üzeri

Düğüm yerel olarak beklemeyi destekler:

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

zaman uyumsuz işlevleri kullanabiliyorsanız:

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

veya:

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

Eski Düğüm sürümlerinde (orijinal yanıt)

Windows ve Linux'ta çalışan, zaman zaman CPU'mun üzerinden geçmeden eşzamansız bir uyku istedim. Uyku paketini denedim ama Windows kutuma yüklenmedi. Ben kullanarak sona erdi:

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

Yüklemek için şunu yazın:

npm install system-sleep

Kodunuzda,

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

Tıkır tıkır çalışıyor.

Modern Javascript kullanarak basit ve zarif uyku fonksiyonu

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

Bağımlılık yok, geri arama yok; bu kadar :-)

Soruda verilen örnek göz önüne alındığında, iki konsol günlüğü arasında şu şekilde uyuyacağız:

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

main();

"Dezavantajı" şimdi ana işlevi de olması gerektiği async. Ancak, zaten modern Javascript kodu yazdığınız düşünüldüğünde, muhtemelen (veya en azından olmalı!) Kodunuzu async/ awaitüzerinde kullanıyorsunuz , bu gerçekten bir sorun değil. Bugün tüm modern tarayıcılar bunu destekliyor .

sleepKullanılmayanlar async/awaitve şişman ok operatörleri için işleve biraz bilgi vererek , bu yazmanın ayrıntılı yolu:

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

Bununla birlikte, yağ ok operatörünün kullanılması onu daha da küçük (ve daha zarif) hale getirir.

Bu www.npmjs.com/package/sleep adresini kullanabilirsiniz

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

Bu soru oldukça eski, ancak son zamanlarda V8 OP'nin taleplerini yerine getirebilecek Jeneratörler ekledi. Jeneratörler genellikle askıya alma veya gen-run gibi bir kütüphanenin yardımıyla asenkron etkileşimler için kullanımı en kolaydır .

Askıya alma kullanan bir örnek:

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

İlgili okuma (utanmaz öz-tanıtım yoluyla): Jeneratörlerle Önemli Olan Nedir? .

Linux / nodejs'de bu benim için çalışıyor:

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

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

Engelleniyor, ancak meşgul bir bekleme döngüsü değil.

Belirttiğiniz süre saniye cinsindendir ancak kesir olabilir. Diğer işletim sistemlerinin benzer bir komutu olup olmadığını bilmiyorum.

Eğer "kod golf" yapmak istiyorsanız, burada diğer bazı cevapların daha kısa bir versiyonunu yapabilirsiniz:

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

Ama bence gerçekten ideal cevap, Node'nin utilkütüphanesini ve promisifytam olarak bu tür şeyler için tasarlanan işlevini kullanmaktır (daha önce vaat edilen vaatlere dayalı olmayan şeylerin söz tabanlı versiyonlarını yapmak):

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

Her iki durumda da await, sleepişlevinizi çağırmak için düğmesini kullanarak duraklatabilirsiniz :

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

Son zamanlarda senkronizasyon modunda (düğüm liflerine dayalı) zaman uyumsuz işlevleri çağırmak için wait.for adı verilen daha basit bir soyutlama oluşturdum . Ayrıca yaklaşan ES6 Jeneratörlerine dayalı bir versiyon da var.

https://github.com/luciotato/waitfor

kullanma Wait.for , düğümün olay döngüsünü engellemeden herhangi bir standart nodejs async işlevini sanki bir eşitleme işleviymiş gibi çağırabilirsiniz.

İhtiyacınız olduğunda sırayla kod yazabilirsiniz, yani, komut dosyalarınızı kişisel kullanım için basitleştirmek için mükemmel (tahmin ediyorum).

wait.for kodunu kullanarak :

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. 

Ayrıca Eşitleme modunda herhangi bir eşzamansız işlevi çağrılabilir . Örnekleri kontrol edin.

Javascript motoru (v8), olay kuyruğundaki olayların sırasına göre kod çalıştırdığından, javascript'in belirtilen süreden sonra yürütmeyi tam olarak tetiklediği kesin değildir. Yani, kodu daha sonra yürütmek için birkaç saniye ayarladığınızda, tetikleme kodu yalnızca olay kuyruğundaki sıralamaya dayandırılır. Bu nedenle, kodun yürütülmesinin tetiklenmesi belirtilen süreden daha uzun sürebilir.

Böylece Node.js takip ediyor,

process.nextTick()

kodu daha sonra çalıştırmak için setTimeout () kullanın. Örneğin,

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

ES6 destekleyicileri ile Promisebunları üçüncü taraf yardımı olmadan kullanabiliriz.

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.

Sonra şu şekilde kullanın:

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

doWhatİşlevin içindeki resolvegeri arama haline geldiğini unutmayın new Promise(...).

Ayrıca bunun ASYNCHRONOUS uyku olduğunu unutmayın. Olay döngüsünü engellemez. Engelleme uykusuna ihtiyacınız varsa, C ++ bağlamaları yardımıyla engelleme uykusunu gerçekleştiren bu kütüphaneyi kullanın. (Düğümde eşzamansız ortamlar gibi tıkanık bir uykuya ihtiyaç duyulması nadirdir.)

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

Yukarıdaki bu kod Javascript'in eşzamansız geri çağrı cehennem sorununun çözülmesinin yan etkisidir. Bu da Javascript'i arka uçta yararlı bir dil haline getirdiğini düşünüyorum. Aslında bu, modern Javascript'e sunulan en heyecan verici gelişme. Nasıl çalıştığını tam olarak anlamak için, jeneratörün nasıl çalıştığı tam olarak anlaşılmalıdır. functionA'nın ardından gelen anahtar kelimeye *modern Javascript'te bir üreteç işlevi denir. Npm paketi cobir jeneratörü çalıştırmak için bir koşucu işlevi sağlamıştır.

Temelde jeneratör fonksiyonu, bir fonksiyonun bir jeneratör fonksiyonunda yieldanahtar kelimeyle yürütülmesini duraklatmanın bir yolunu sağladı yieldve jeneratör ile arayan arasında bilgi alışverişini mümkün kıldı. Bu, arayan kişinin promisebir asenkron çağrısından veri ayıklaması ve çözülen verileri jeneratöre geri aktarması için bir mekanizma sağladı . Etkili bir şekilde, eşzamansız bir çağrıyı senkronize eder.

@ Atlex2 tarafından önerilen kirli engelleme yaklaşımına dayanan moment.js aromalı bir modüldür . Bunu sadece test için kullanın .

const moment = require('moment');

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

module.exports = sleep;

Sadece test amacıyla askıya almanız gerekiyorsa, geçerli iş parçacığı yürütmeyi deneyin:

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

basit bir olay gerçekleşmesi için 5 saniye bekleyeceğiz (kodda başka bir yerde true değerine ayarlanmış yapılan değişken ile gösterilir) veya zaman aşımı süresi sona erdiğinde her 100 ms'de bir kontrol edeceğiz

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

Bazı insanlar için, kabul edilen cevap çalışmıyor, başka bir cevap buldum ve benim için çalışıyor: Bir parametreyi setTimeout () geri aramasına nasıl iletebilirim?

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

'merhaba' geçirilen parametredir, zaman aşımı süresinden sonra tüm parametreleri iletebilirsiniz. Cevap için @Fabio Phms'a teşekkürler.

Tüm bu seti yapmak yerine Zaman aşımı, uyku ve diğer birçok şeyi kullanmak daha iyidir

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

Diğer cevaplar harika ama farklı bir dokunuş alacağımı düşündüm.

Gerçekten aradığınız tek şey Linux'ta belirli bir dosyayı yavaşlatmaksa:

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

düğüm benimprog yavaş dosya

Bu, her beş satırda 1 saniye uyuyacaktır. Düğüm programı yazar kadar yavaş ilerleyecektir. Başka şeyler yapıyorsa normal hızda devam ederler.

Mkfifo bir ilk giren ilk çıkar boru oluşturur. Bu işe yarar. Perl satırı istediğiniz kadar hızlı yazacaktır. $ | = 1 çıktıyı arabelleğe almadığını söylüyor.

Bu sorunun cevabını okuduktan sonra, gerekirse geri arama yapabilen basit bir işlevi bir araya getirdim:

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

Hakkında daha fazla bilgi için

yield sleep(2000); 

Redux-Saga'yı kontrol etmelisin . Ancak, model çerçeveniz olarak Redux seçiminize özgüdür (kesinlikle gerekli olmamasına rağmen).