ฉันกำลังพัฒนาคอนโซลเช่นสคริปต์สำหรับความต้องการส่วนบุคคล ฉันต้องหยุดชั่วคราวเป็นระยะเวลานาน แต่จากการวิจัยของฉัน node.js ไม่มีวิธีหยุดตามที่ต้องการ เป็นการยากที่จะอ่านข้อมูลของผู้ใช้หลังจากผ่านไประยะเวลาหนึ่ง ... ฉันได้เห็นโค้ดบางส่วนจากที่นั่น แต่ฉันเชื่อว่าพวกเขาต้องมีโค้ดอื่น ๆ อยู่ภายในเพื่อให้สามารถใช้งานได้เช่น:

setTimeout(function() {
}, 3000);

อย่างไรก็ตามฉันต้องการทุกอย่างหลังจากบรรทัดของรหัสนี้เพื่อดำเนินการหลังจากช่วงเวลา

ตัวอย่างเช่น,

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

ฉันเคยเห็นสิ่งต่าง ๆ เช่น

yield sleep(2000);

แต่ node.js ไม่รู้จักสิ่งนี้

ฉันจะบรรลุการหยุดชั่วคราวแบบขยายนี้ได้อย่างไร

วิธีที่ดีที่สุดในการทำเช่นนี้คือการแบ่งรหัสของคุณออกเป็นหลายฟังก์ชั่นดังนี้

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

มันคล้ายกับวิธีแก้ปัญหาของJohnnyHKแต่มีขนาดเล็กกว่าและขยายได้ง่ายกว่ามาก

คำตอบใหม่สำหรับคำถามเก่า วันนี้ ( มกราคม 2560มิถุนายน 2562) ง่ายกว่ามาก คุณสามารถใช้ใหม่async/awaitไวยากรณ์ ตัวอย่างเช่น:

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

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

สำหรับการใช้งานasync/awaitนอกกรอบโดยไม่ต้องติดตั้งและปลั๊กอินคุณต้องใช้ node-v7 หรือ node-v8 โดยใช้--harmonyแฟล็ก

อัปเดตมิถุนายน 2562:โดยการใช้ NodeJS เวอร์ชันล่าสุดคุณสามารถใช้งานได้ทันที ไม่จำเป็นต้องระบุอาร์กิวเมนต์บรรทัดคำสั่ง แม้แต่ Google Chrome ก็ยังรองรับอยู่ในปัจจุบัน

ปรับปรุงพฤษภาคม 2563: ในไม่ช้าคุณจะสามารถใช้awaitไวยากรณ์นอกฟังก์ชั่น async ได้ ในระดับสูงสุดเหมือนในตัวอย่างนี้

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

ข้อเสนอที่อยู่ในขั้นตอนที่ 3 คุณสามารถใช้งานได้แล้ววันนี้โดยใช้ webpack 5 (อัลฟา)

ข้อมูลเพิ่มเติม:

• ตั้งค่าสถานะ Harmony เป็น Nodejs: https://nodejs.org/en/docs/es6/
• ดาวน์โหลด NodeJS เวอร์ชั่นทั้งหมด: https://nodejs.org/en/download/releases/

ทางออกที่สั้นที่สุดโดยไม่ต้องพึ่งพาใด ๆ :

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

ใส่รหัสที่คุณต้องการดำเนินการหลังจากความล่าช้าในการsetTimeoutโทรกลับ:

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

นี่เป็นเทคนิคการบล็อกอย่างง่าย:

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

มันกำลังบล็อกอยู่ตราบเท่าที่จะไม่มีสิ่งใดเกิดขึ้นในสคริปต์ของคุณ (เช่นการเรียกกลับ) แต่เนื่องจากนี่เป็นสคริปต์คอนโซลอาจเป็นสิ่งที่คุณต้องการ!

บน Node 7.6.0 หรือสูงกว่า

โหนดรองรับการรอคอย:

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

ถ้าคุณสามารถใช้ฟังก์ชัน async ได้:

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

หรือ:

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

ในรุ่นโหนดเก่า (คำตอบเดิม)

ฉันต้องการการนอนแบบอะซิงโครนัสที่ทำงานใน Windows & Linux โดยไม่ต้องใช้ซีพียูในขณะที่วนซ้ำ ฉันลองแพคเกจสลีปแล้ว แต่จะไม่ติดตั้งลงในกล่อง Windows ของฉัน ฉันสิ้นสุดการใช้:

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

หากต้องการติดตั้งให้พิมพ์:

npm install system-sleep

ในรหัสของคุณ

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

ทำงานเหมือนจับใจ

ฟังก์ชั่นการนอนหลับที่เรียบง่ายและสง่างามโดยใช้ Javascript ที่ทันสมัย

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

ไม่มีการพึ่งพาไม่มีการเรียกกลับนรก แค่นั้นแหละ :-)

เมื่อพิจารณาตัวอย่างที่ให้มาในคำถามนี่คือวิธีที่เราจะพักระหว่างสองบันทึกของคอนโซล:

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

main();

"ข้อเสียเปรียบ" ก็คือฟังก์ชั่นหลักของคุณในตอนนี้ก็asyncเช่นกัน แต่เมื่อพิจารณาว่าคุณกำลังเขียนโค้ด Javascript ที่ทันสมัยอยู่แล้วคุณอาจจะ (หรืออย่างน้อยก็ควรจะเป็น!) โดยใช้async/ awaitทั่วรหัสของคุณดังนั้นนี่จึงไม่ใช่ปัญหา ทุกเบราว์เซอร์ที่ทันสมัยในปัจจุบันการสนับสนุนมัน

ให้ข้อมูลเชิงลึกเล็กน้อยเกี่ยวกับsleepฟังก์ชั่นสำหรับผู้ที่ไม่ได้ใช้async/awaitและผู้ประกอบการลูกศรไขมันนี่คือวิธีการเขียนอย่างละเอียด:

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

อย่างไรก็ตามการใช้ตัวดำเนินการลูกศรไขมันทำให้มันมีขนาดเล็กลง (และสวยงามยิ่งขึ้น)

คุณสามารถใช้www.npmjs.com/package/sleep

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

คำถามนี้ค่อนข้างเก่า แต่เมื่อเร็ว ๆ นี้ V8 ได้เพิ่มเครื่องกำเนิดไฟฟ้าซึ่งสามารถทำสิ่งที่ OP ต้องการได้ เครื่องกำเนิดไฟฟ้าโดยทั่วไปมักจะง่ายที่สุดที่จะใช้สำหรับการติดต่อ async ด้วยความช่วยเหลือของห้องสมุดเช่นระงับหรือGEN-วิ่ง

นี่คือตัวอย่างการใช้การระงับ:

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

การอ่านที่เกี่ยวข้อง (โดยวิธีการส่งเสริมตนเองที่ไร้ยางอาย): เรื่องใหญ่กับเครื่องกำเนิดไฟฟ้าคืออะไร? .

บน Linux / nodejs สิ่งนี้ใช้ได้กับฉัน:

const spawnSync = ต้องการ ('child_process') spawnSync;

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

มันกำลังบล็อก แต่มันไม่ใช่การรอคอยที่ไม่ว่าง

เวลาที่คุณระบุเป็นวินาที แต่อาจเป็นเศษส่วน ฉันไม่รู้ว่าระบบปฏิบัติการอื่นมีคำสั่งที่คล้ายกันหรือไม่

หากคุณต้องการ "code golf" คุณสามารถสร้างคำตอบสั้น ๆ ได้ที่นี่:

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

แต่จริงๆคำตอบที่ดีที่สุดในความคิดของฉันคือการใช้utilห้องสมุดของ Node และpromisifyฟังก์ชั่นของมันซึ่งได้รับการออกแบบมาสำหรับสิ่งนี้ (ทำรุ่นตามสัญญาของสิ่งที่ไม่ใช่สัญญาที่มีอยู่ก่อนหน้านี้):

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

ในกรณีใดกรณีหนึ่งจากนั้นคุณสามารถหยุดเพียงแค่ใช้awaitเพื่อเรียกsleepใช้ฟังก์ชันของคุณ:

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

ฉันเพิ่งสร้างนามธรรมที่ง่ายกว่าที่เรียกว่าwait.forเพื่อเรียกใช้ฟังก์ชัน async ในโหมดซิงค์ (ขึ้นอยู่กับโหนดของเส้นใย) นอกจากนี้ยังมีรุ่นตาม ES6 Generators ที่กำลังจะมาถึง

https://github.com/luciotato/waitfor

การใช้wait.forคุณสามารถเรียกใช้ฟังก์ชัน async nodejs มาตรฐานใด ๆ ราวกับว่ามันเป็นฟังก์ชั่นการซิงค์โดยไม่ปิดกั้นลูปเหตุการณ์ของโหนด

คุณสามารถเขียนโค้ดตามลำดับเมื่อคุณต้องการซึ่งก็คือ (ฉันเดา) เหมาะสำหรับการทำให้สคริปต์ของคุณง่ายขึ้นสำหรับการใช้งานส่วนตัว

ใช้wait.forรหัสของคุณจะเป็น:

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. 

นอกจากนี้ยังสามารถเรียกใช้ฟังก์ชัน async ใด ๆ ในโหมดซิงค์ ตรวจสอบตัวอย่าง

เนื่องจากเอ็นจิ้น javascript (v8) รันโค้ดตามลำดับเหตุการณ์ในคิวเหตุการณ์จึงไม่เข้มงวดที่จาวาสคริปต์จะเรียกใช้การทำงานในเวลาที่กำหนด นั่นคือเมื่อคุณตั้งค่าบางวินาทีเพื่อรันโค้ดในภายหลังรหัสทริกเกอร์จะขึ้นอยู่กับลำดับในคิวเหตุการณ์ ดังนั้นการเรียกใช้รหัสอาจใช้เวลาเกินกว่าที่กำหนด

ดังนั้น Node.js ดังนี้

process.nextTick()

เพื่อเรียกใช้รหัสในภายหลังแทน setTimeout () ตัวอย่างเช่น,

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

ด้วยการรองรับ ES6 Promiseเราสามารถใช้มันได้โดยไม่ต้องขอความช่วยเหลือจากบุคคลที่สาม

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.

จากนั้นใช้แบบนี้:

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

โปรดทราบว่าdoWhatฟังก์ชั่นกลายเป็นโทรกลับภายในresolvenew Promise(...)

นอกจากนี้โปรดทราบว่านี่เป็น ASYNCHRONOUS sleep มันไม่ได้ปิดกั้นห่วงเหตุการณ์ หากคุณต้องการปิดกั้นการนอนหลับให้ใช้ห้องสมุดนี้ซึ่งตระหนักถึงการปิดกั้นการนอนหลับด้วยความช่วยเหลือของการผูก C ++ (แม้ว่าความต้องการการสลีปบล็อคในโหนดเช่นสภาพแวดล้อม async จะไม่ค่อยเกิดขึ้น)

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

รหัสข้างต้นนี้เป็นผลข้างเคียงของการแก้ไขปัญหาการโทรกลับแบบอะซิงโครนัสของ Javascript นี่เป็นเหตุผลที่ฉันคิดว่าทำให้ Javascript เป็นภาษาที่มีประโยชน์ในแบ็กเอนด์ จริงๆแล้วนี่คือการปรับปรุงที่น่าตื่นเต้นที่สุดที่นำมาใช้กับ Javascript สมัยใหม่ในความคิดของฉัน เพื่อให้เข้าใจอย่างถ่องแท้ถึงวิธีการทำงานของเครื่องกำเนิดไฟฟ้าจะต้องเข้าใจอย่างสมบูรณ์ functionคำหลักตามด้วย*เรียกว่าฟังก์ชั่นเครื่องกำเนิดไฟฟ้าในปัจจุบัน Javascript แพ็กเกจ npm coจัดเตรียมฟังก์ชัน runner ให้เรียกใช้ตัวสร้าง

ฟังก์ชั่นเครื่องกำเนิดไฟฟ้าที่สำคัญเป็นวิธีการหยุดการทำงานของฟังก์ชั่นที่มีyieldคำหลักในเวลาเดียวกันyieldในฟังก์ชั่นเครื่องกำเนิดไฟฟ้าทำให้การแลกเปลี่ยนข้อมูลระหว่างภายในเครื่องกำเนิดไฟฟ้าและผู้โทร นี่เป็นกลไกสำหรับผู้โทรเพื่อดึงข้อมูลpromiseจากการโทรแบบอะซิงโครนัสและส่งข้อมูลที่ได้รับการแก้ไขกลับไปยังเครื่องกำเนิด อย่างมีประสิทธิภาพทำให้การโทรแบบอะซิงโครนัส

นี่คือ moment.js รสโมดูลบนพื้นฐานของความสกปรกวิธีการปิดกั้นการแนะนำโดย @ ใช้สำหรับการทดสอบเท่านั้น

const moment = require('moment');

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

module.exports = sleep;

หากคุณเพียงแค่ต้องระงับเพื่อการทดสอบคุณดำเนินการหัวข้อปัจจุบันลองนี้:

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

ง่าย ๆ เราจะรอ 5 วินาทีเพื่อให้เหตุการณ์บางอย่างเกิดขึ้น (ซึ่งจะถูกระบุโดยตัวแปรที่ทำเสร็จแล้วตั้งค่าเป็นจริงที่อื่นในรหัส) หรือเมื่อหมดเวลาหมดอายุที่เราจะตรวจสอบทุก ๆ 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;
        }
    })();

สำหรับบางคนคำตอบที่ยอมรับไม่ทำงานฉันพบคำตอบอื่นและทำงานได้สำหรับฉัน: ฉันจะส่งพารามิเตอร์ไปยังการเรียกกลับ setTimeout () ได้อย่างไร

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

'hello' คือพารามิเตอร์ที่ส่งผ่านคุณสามารถผ่านพารามิเตอร์ทั้งหมดได้หลังจากหมดเวลา ขอบคุณ @Fabio Phms สำหรับคำตอบ

แทนที่จะใช้ setTimeout, sleep และสิ่งอื่น ๆ ทั้งหมดเหล่านี้ควรใช้

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

คำตอบอื่น ๆ ที่ดี แต่ฉันคิดว่าฉันจะใช้ไหวพริบที่แตกต่างกัน

หากสิ่งที่คุณกำลังมองหาจริงๆคือการชะลอไฟล์เฉพาะใน linux:

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

node myprog slowfile

สิ่งนี้จะนอน 1 วินาทีทุกห้าบรรทัด โปรแกรมโหนดจะทำงานช้ากว่าตัวเขียน หากทำสิ่งอื่น ๆ พวกเขาจะดำเนินการต่อด้วยความเร็วปกติ

mkfifo สร้างไพพ์แบบเข้าก่อนออกก่อน มันเป็นสิ่งที่ทำให้งานนี้ บรรทัด Perl จะเขียนเร็วเท่าที่คุณต้องการ $ | = 1 บอกว่าอย่าบัฟเฟอร์เอาต์พุต

ฉันรวบรวมกันหลังจากอ่านคำตอบในคำถามนี้แล้วฟังก์ชั่นเรียบง่ายซึ่งสามารถโทรกลับได้ถ้าคุณต้องการ:

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

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ

yield sleep(2000); 

คุณควรตรวจสอบRedux-Saga แต่มันก็มีความเฉพาะกับ Redux ที่คุณเลือกเป็นกรอบโมเดลของคุณ (แม้ว่าจะไม่จำเป็นอย่างยิ่ง)