Що таке JavaScript-версія ()?

Чи є кращий спосіб інженерії sleepв JavaScript, ніж наступна pausecompфункція ( взята звідси )?

function pausecomp(millis)
{
    var date = new Date();
    var curDate = null;
    do { curDate = new Date(); }
    while(curDate-date < millis);
}

Це не дублікат режиму сну в JavaScript - затримка між діями ; Я хочу справжнього сну в середині функції, а не затримки перед тим, як виконати фрагмент коду.

Оновлення 2017 - 2019 років

З 2009 року, коли було задано це питання, JavaScript значно розвинувся. Усі інші відповіді застаріли або надмірно складні. Ось поточна найкраща практика:

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

async function demo() {
  console.log('Taking a break...');
  await sleep(2000);
  console.log('Two seconds later, showing sleep in a loop...');

  // Sleep in loop
  for (let i = 0; i < 5; i++) {
    if (i === 3)
      await sleep(2000);
    console.log(i);
  }
}

demo();

Ось воно. await sleep(<duration>).

Або як однолінійний:

await new Promise(r => setTimeout(r, 2000));

Зауважте,

1. awaitможе виконуватися лише у функціях з префіксом asyncключового слова або на верхньому рівні сценарію в деяких середовищах (наприклад, консолі Chrome DevTools або Runkit).
2. awaitлише призупиняє поточну asyncфункцію

Дві нові функції JavaScript допомогли написати цю функцію "сну":

• Обіцянки, рідна особливість ES2015 (він же ES6). Також ми використовуємо функції стрілок у визначенні функції сну.
• Ця async/awaitфункція дозволяє коду явно чекати, коли обіцянка вирішиться (вирішить або відхилить).

Сумісність

• обіцянки підтримуються в Node v0.12 + і широко підтримуються в браузерах , крім IE
• async/ awaitприземлився у V8 і його було включено за замовчуванням з Chrome 55 (випущено в грудні 2016)
  • він приземлився у Вузлі 7 у жовтні 2016 року
  • а також приземлився в Firefox Nightly у листопаді 2016 року

Якщо ви з якоїсь дивної причини використовуєте Node старше 7 років (який закінчився термін служби ) або націлений на старі веб-переглядачі, async/ awaitвсе одно можна використовувати через Babel (інструмент, який перетворює JavaScript + нові функції у звичайний старий JavaScript) , з transform-async-to-generatorплагіном.

(Дивіться оновлену відповідь за 2016 рік )

Я думаю, що цілком розумно хотіти виконати дію, почекати, а потім виконати іншу дію. Якщо ви звикли писати на багатопотокових мовах, ви, мабуть, маєте ідею підняти виконання протягом певного часу, поки ваш потік не прокинеться.

Проблема тут полягає в тому, що JavaScript є однопоточною моделлю на основі подій. Хоча в конкретному випадку може бути приємно, щоб весь двигун зачекав кілька секунд, загалом це погана практика. Припустимо, я хотів використати ваші функції під час написання власної? Коли я зателефонував до вашого методу, всі мої методи замерзли. Якщо JavaScript міг би якось зберегти контекст виконання вашої функції, зберігати її десь, потім повернути її та продовжувати пізніше, тоді може спатись, але це, в основному, буде потоком.

Таким чином, ви в значній мірі застрягли з тим, що запропонували інші - вам потрібно буде розбити код на кілька функцій.

Тоді ваше запитання - помилковий вибір. Немає способу спати так, як ти хочеш, і не слід шукати запропонованого рішення.

У JavaScript я переписую кожну функцію, щоб вона закінчилася якнайшвидше. Ви хочете, щоб браузер повернувся до керування, щоб він міг змінити ваш DOM.

Кожен раз, коли мені хотілося сну в середині своєї функції, я відремонтувався на використання setTimeout().

Редагувати

Про ганебний сон або затримку функціонування в рамках будь-якої мови багато дискутується. Одні скажуть, що завжди повинен бути сигнал або зворотний виклик для запуску заданої функціональності, інші стверджують, що іноді корисний довільний момент затримки. Я кажу, що кожне своє і одне правило ніколи нічого не може диктувати в цій галузі.

Написати функцію сну просто та зробити її ще більш зручною для використання з обіцянками JavaScript:

// sleep time expects milliseconds
function sleep (time) {
  return new Promise((resolve) => setTimeout(resolve, time));
}

// Usage!
sleep(500).then(() => {
    // Do something after the sleep!
});

Лише для налагодження / dev , я публікую це, якщо комусь це корисно

Цікаві речі, в Firebug (і, ймовірно, інших js-консолях) нічого не відбувається після натискання клавіші Enter, лише після вказаної тривалості сну (...)

function sleepFor( sleepDuration ){
    var now = new Date().getTime();
    while(new Date().getTime() < now + sleepDuration){ /* do nothing */ } 
}

Приклад використання:

function sleepThenAct(){ sleepFor(2000); console.log("hello js sleep !"); }

Я погоджуюся з іншими плакатами, насичений сон - це лише погана ідея.

Однак setTimeout не витримує виконання, він виконує наступний рядок функції відразу після встановлення тайм-ауту SET, а не після закінчення тайм-ауту, так що не виконує того самого завдання, яке виконував б сон.

Спосіб зробити це - розподілити свою функцію на до і після частин.

function doStuff()
{
  //do some things
  setTimeout(continueExecution, 10000) //wait ten seconds before continuing
}

function continueExecution()
{
   //finish doing things after the pause
}

Переконайтесь, що назви ваших функцій все ще точно описують, що робить кожен твір (IE GatherInputThenWait і CheckInput, а не funcPart1 та funcPart2)

Редагувати

Цей метод домагається не виконувати рядки коду, який ви вирішили, поки ПІСЛЯ час тактичного очікування, при цьому все одно повертаючи управління назад на клієнтський ПК, щоб виконати все, що ще було в черзі.

Подальше редагування

Як зазначалося в коментарях, це абсолютно НЕ ПРАЦЮЄ в циклі. Ви можете зробити химерні (некрасиві) злому, щоб змусити його працювати в циклі, але в цілому це просто призведе до згубного коду спагетті.

Для любові до $ DEITY, будь ласка, не вмикайте функцію сну в зайнятому режимі очікування. setTimeoutі setIntervalробити все необхідне.

var showHide = document.getElementById('showHide');
setInterval(() => {
    showHide.style.visibility = "initial";
    setTimeout(() => {
        showHide.style.visibility = "hidden"
    }, 1000);
    ;
}, 2000);   

<div id="showHide">Hello! Goodbye!</div>

Кожні дві секунди інтервал приховує текст на одну секунду. Тут показано, як використовувати setInterval та setTimeout для показу та приховування тексту щосекунди.

Я знаю, це трохи старе питання, але якщо (як і я) ви використовуєте Javascript з Rhino, ви можете використовувати ...

try
{
  java.lang.Thread.sleep(timeInMilliseconds);
}
catch (e)
{
  /*
   * This will happen if the sleep is woken up - you might want to check
   * if enough time has passed and sleep again if not - depending on how
   * important the sleep time is to you.
   */
}

Якщо ви використовуєте jQuery, хтось фактично створив плагін "затримка", це не що інше, як обгортка для setTimeout:

// Delay Plugin for jQuery
// - http://www.evanbot.com
// - © 2008 Evan Byrne

jQuery.fn.delay = function(time,func){
    this.each(function(){
        setTimeout(func,time);
    });

    return this;
};

Потім ви можете просто використовувати його у рядку викликів функцій, як очікувалося:

$('#warning')
.addClass('highlight')
.delay(1000)
.removeClass('highlight');

Я також шукав рішення для сну (не для виробничого коду, лише для розробників / тестів) і знайшов цю статтю:

http://narayanraman.blogspot.com/2005/12/javascript-sleep-or-wait.html

... і ось ще одне посилання на рішення клієнта: http://www.devcheater.com/

Крім того, під час дзвінка alert()ваш код буде призупинено, і при появі попередження - потрібно знайти спосіб не відображати попередження, але отримати той же ефект. :)

Ось просте рішення за допомогою синхронного XMLHttpRequest:

function sleep(n){
  var request = new XMLHttpRequest();
  request.open('GET', '/sleep.php?n=' + n, false);  // `false` makes the request synchronous
  request.send(null);
}

вміст sleep.php:

<?php sleep($_GET['n']);

Тепер назвіть це за допомогою: сон (5);

Ось ви йдете. Як говорить код, не будьте поганим розробником і використовуйте це на веб-сайтах. Це утиліта розвитку.

// Basic sleep function based on ms.
// DO NOT USE ON PUBLIC FACING WEBSITES.
function sleep(ms) {
    var unixtime_ms = new Date().getTime();
    while(new Date().getTime() < unixtime_ms + ms) {}
}

Мені особисто подобається просте:

function sleep(seconds){
    var waitUntil = new Date().getTime() + seconds*1000;
    while(new Date().getTime() < waitUntil) true;
}

тоді:

sleep(2); // Sleeps for 2 seconds

Я використовую це весь час для створення підробленого часу завантаження під час створення скриптів у P5js

Спочатку:

Визначте функцію, яку потрібно виконати так:

function alertWorld(){
  alert("Hello World");
}

Потім заплануйте його виконання методом setTimeout:

setTimeout(alertWorld,1000)

Зауважте дві речі

• другий аргумент - час у мілісекундах
• в якості першого аргументу ви повинні передавати лише ім'я (посилання) функції без дужок

Краще рішення, щоб зробити речі схожими на те, що хоче більшість людей, - використовувати анонімну функцію:

alert('start');
var a = 'foo';
//lots of code
setTimeout(function(){  //Beginning of code that should run AFTER the timeout
    alert(a);
    //lots more code
},5000);  // put the timeout here

Це, мабуть, найближче, коли ти знайдеш щось, що просто робить те, що ти хочеш.

Зауважте, якщо вам потрібно кілька сну, це може стати некрасивим поспіхом, і вам, можливо, доведеться переосмислити свій дизайн.

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

переконайтеся, що ваша функція виклику асинхронізована

перевірено і працює добре

Для браузерів я згоден, що setTimeout і setInterval - це шлях.

Але для коду на стороні сервера може знадобитися функція блокування (наприклад, щоб ви могли ефективно мати синхронізацію потоків).

Якщо ви використовуєте node.js та метеор, можливо, ви зіткнулися з обмеженнями використання setTimeout у волокні. Ось код для сну на сервері.

var Fiber = require('fibers');

function sleep(ms) {
    var fiber = Fiber.current;
    setTimeout(function() {
        fiber.run();
    }, ms);
    Fiber.yield();
}

Fiber(function() {
    console.log('wait... ' + new Date);
    sleep(1000);
    console.log('ok... ' + new Date);
}).run();
console.log('back in main');

Дивіться: https://github.com/laverdet/node-fibers#sleep

Я б інкапсулював setTimeOut у обіцянку за узгодженість коду з іншими асинхронними завданнями: Демо в Fiddle

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

Використовується так:

sleep(2000).then(function() { 
   // Do something
});

Легко запам’ятати синтаксис, якщо ви використовували Promises.

Оновлення 2019 року за допомогою Atomics.wait

Має працювати в Вузлі 9.3 або вище.

Мені потрібен був досить точний таймер у Node.js, і він чудово працює для цього. Однак здається, що в браузерах підтримка надзвичайно обмежена.

let ms = 10000;
Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);

Отримав декілька 10-секундних орієнтирів таймера.

За допомогою setTimeout я отримую помилку до 7000 мікросекунд. (7 мс)

З Atomics моя помилка, здається, залишається менше 600 мікросекунд. (0,6 мс)

Оновлення 2020 року: Підсумок

function sleep(millis){ // need help of a server-side page
  let netMillis=Math.max(millis-5,0); //assuming 5ms overhead
  let xhr=new XMLHttpRequest();
  xhr.open('GET','/sleep.jsp?millis='+netMillis+'&rand='+Math.random(), false);
  try{
    xhr.send();
  }catch(e){
  }
}
function sleepAsync(millis){ // use only in async function
  let netMillis=Math.max(millis-1,0); // assuming 1ms overhead
  return new Promise((resolve)=>{
    setTimeout(resolve, netMillis);
  });
}
function sleepSync(millis){ // use only in worker thread, currently Chrome-only
  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, millis);
}

function sleepTest(){
  console.time('sleep');
  sleep(1000);
  console.timeEnd('sleep');
}
async function sleepAsyncTest(){
  console.time('sleepAsync');
  await sleepAsync(1000);
  console.timeEnd('sleepAsync');
}
function sleepSyncTest(){ 
  let source=`${sleepSync.toString()}
    console.time('sleepSync');
    sleepSync(1000);
    console.timeEnd('sleepSync');`;
  let src='data:text/javascript,'+encodeURIComponent(source);
  console.log(src);
  var worker=new Worker(src);
}

з яких sleep.jspвиглядає сторінка на сервері, наприклад

<%
try{
  Thread.sleep(Long.parseLong(request.getParameter("millis")));
}catch(InterruptedException e){}
%>

Більшість відповідей тут є помилковими або принаймні застарілими. Немає жодної причини, щоб javascript мав бути однопоточним, і справді це не так. Сьогодні всі основні браузери підтримують працівників, раніше це було так, як інші версії JavaScript, такі як Rhino та Node.js, підтримували багатопотоковість.

"Javascript - єдиний потік" - не вірна відповідь. Наприклад, запуск функції сну в межах робочого не блокує жоден код, що працює в потоці ui.

У новіші періоди виконання, що підтримують генератори та вихід, можна створити аналогічні функції функції сну в єдиному потоковому середовищі:

// This is based on the latest ES6 drafts.
// js 1.7+ (SpiderMonkey/Firefox 2+) syntax is slightly different

// run code you want to sleep here (ommit star if using js 1.7)
function* main(){
    for (var i = 0; i < 10; i++) {
        // to sleep for 10 milliseconds 10 times in a row
        yield 10;
    }

    yield 5;
    console.log('I just slept 5 milliseconds!');
}

// resume the given generator after ms milliseconds
function resume(ms, generator){
    setTimeout(function(){
        // ommit .value if using js 1.7
        var nextSleep = generator.next().value;
        resume(nextSleep, generator);
    }, ms);
}

// initialize generator and get first sleep for recursive function
var
    generator = main(),
    firstSleep = generator.next().value;

// initialize recursive resume function
resume(firstSleep, generator);

Ця імітація сну відрізняється від справжньої функції сну, оскільки не блокує нитку. Це просто цукор поверх поточної функції setTimeout в JavaScript. Цей тип функціоналу реалізований у Task.js і має працювати сьогодні у Firefox.

Я шукав / googled досить багато веб-сторінок у режимі сну / очікування javascript ... і немає відповіді, якщо ви хочете, щоб javascript "RUN, DELAY, RUN" ... те, що отримала більшість людей, було або "RUN, RUN (марно речі), RUN "або" RUN, RUN + затримка RUN "....

Тож я з’їв трохи гамбургерів і задумався ::: ось рішення, яке працює ... але ви повинні порубати свої запущені коди ... ::: так, я знаю, це просто прочитання рефакторингу .. ... все ще ...

// ......................................... // example1:

<html>
<body>
<div id="id1">DISPLAY</div>

<script>
//javascript sleep by "therealdealsince1982"; copyrighted 2009
//setInterval
var i = 0;

function run() {
    //pieces of codes to run
    if (i==0){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" is ran</p>"; }
    if (i==1){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" is ran</p>"; }
    if (i==2){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" is ran</p>"; }
    if (i >2){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" is ran</p>"; }
    if (i==5){document.getElementById("id1").innerHTML= "<p>all code segment finished running</p>"; clearInterval(t); } //end interval, stops run
    i++; //segment of code finished running, next...
}

run();
t=setInterval("run()",1000);

</script>
</body>
</html>

// .................................... // example2:

<html>
<body>
<div id="id1">DISPLAY</div>

<script>
//javascript sleep by "therealdealsince1982"; copyrighted 2009
//setTimeout
var i = 0;

function run() {
    //pieces of codes to run, can use switch statement
    if (i==0){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" ran</p>"; sleep(1000);}
    if (i==1){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" ran</p>"; sleep(2000);}
    if (i==2){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" ran</p>"; sleep(3000);}
    if (i==3){document.getElementById("id1").innerHTML= "<p>code segment "+ i +" ran</p>";} //stops automatically
    i++;
}

function sleep(dur) {t=setTimeout("run()",dur);} //starts flow control again after dur

run(); //starts
</script>
</body>
</html>

// ................. приклад3:

<html>
<body>
<div id="id1">DISPLAY</div>

<script>
//javascript sleep by "therealdealsince1982"; copyrighted 2009
//setTimeout
var i = 0;

function flow() {
    run(i);
    i++; //code segment finished running, increment i; can put elsewhere
    sleep(1000);
    if (i==5) {clearTimeout(t);} //stops flow, must be after sleep()
}

function run(segment) {
    //pieces of codes to run, can use switch statement
    if (segment==0){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment==1){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment==2){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment >2){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
}

function sleep(dur) {t=setTimeout("flow()",dur);} //starts flow control again after dur

flow(); //starts flow
</script>
</body>
</html>

// .............. example4:

<html>
<body>
<div id="id1">DISPLAY</div>

<script>
//javascript sleep by "therealdealsince1982"; copyrighted 2009
//setTimeout, switch
var i = 0;

function flow() {
    switch(i)
    {
        case 0:
            run(i);
            sleep(1000);
            break;
        case 1:
            run(i);
            sleep(2000);
            break;
        case 5:
            run(i);
            clearTimeout(t); //stops flow
            break;
        default:
            run(i);
            sleep(3000);
            break;
    }
}

function run(segment) {
    //pieces of codes to run, can use switch statement
    if (segment==0){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment==1){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment==2){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    if (segment >2){document.getElementById("id1").innerHTML= "<p>code segment "+ segment +" is ran</p>"; }
    i++; //current segment of code finished running, next...
}

function sleep(dur) {t=setTimeout("flow()",dur);} //starts flow control again after dur

flow(); //starts flow control for first time...
</script>
</body>
</html>

function sleep(milliseconds) {
  var start = new Date().getTime();
  for (var i = 0; i < 1e7; i++) {
    if ((new Date().getTime() - start) > milliseconds){
      break;
    }
  }
}

Найкоротше рішення без будь-яких залежностей:

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

Ви не можете спати так, як у JavaScript, а точніше - не слід. Виконання циклу сну або деякого часу призведе до того, що браузер користувача зависне, доки цикл не буде виконаний.

Використовуйте таймер, як зазначено у посиланні, на яке ви посилалися.

Один із сценаріїв, коли ви можете захотіти функцію sleep (), а не використовувати setTimeout (), - якщо у вас є функція, що реагує на натискання користувача, що в кінцевому підсумку відкриє нове, тобто спливаюче вікно, і ви ініціювали деяку обробку, яка вимагає короткого періоду. завершити до появи спливаючого вікна. Переміщення відкритого вікна в закриття означає, що браузер його зазвичай блокує.

Я можу зрозуміти призначення функції сну, якщо вам доведеться мати справу з синхронним виконанням. Функції setInterval і setTimeout створюють паралельний потік виконання, який повертає послідовність виконання назад в основну програму, що малоефективно, якщо доведеться чекати певного результату. Звичайно, можна використовувати події та обробники, але в деяких випадках це не те, що призначено.

Додавання моїх двох біт. Мені потрібно було зайнято-чекати для тестування. Я не хотів розділяти код, тому що це буде багато роботи, тому простий для мене це зробив.

for (var i=0;i<1000000;i++){                    
     //waiting
  }

Я не бачу жодних недоліків у цьому, і це зробило для мене трюк.

Це можна зробити за допомогою методу сну Java. Я перевірив це на FF та IE, і він не блокує комп'ютер, не пережовує ресурси або не спричиняє нескінченних хітів сервера. Мені здається, чисте рішення.

Спочатку ви повинні завантажити Java на сторінку та зробити її доступними. Для цього я зробив це:

<html>
<head>

<script type="text/javascript">

  function load() {
    var appletRef = document.getElementById("app");
    window.java = appletRef.Packages.java;
  } // endfunction

</script>

<body onLoad="load()">

<embed id="app" code="java.applet.Applet" type="application/x-java-applet" MAYSCRIPT="true" width="0" height="0" />

Тоді, все, що вам потрібно зробити, коли вам потрібно безболісна пауза у вашому JS, це:

java.lang.Thread.sleep(xxx)

Де ххх - час у мілісекундах. У моєму випадку (з обґрунтуванням) це було частиною виконання замовлення в дуже невеликій компанії, і мені потрібно було надрукувати рахунок-фактуру, яку потрібно було завантажити з сервера. Я зробив це, завантаживши рахунок-фактуру (як веб-сторінку) в iFrame, а потім надрукувавши iFrame. Звичайно, мені довелося чекати, поки сторінка не буде повністю завантажена, перш ніж я могла надрукувати, тому JS довелося зробити паузу. Я досяг цього, внаслідок того, щоб сторінка рахунків-фактур (в iFrame) змінила приховане поле форми на батьківській сторінці за допомогою події onLoad. А код на батьківській сторінці для друку рахунка-фактури виглядав приблизно так (нерелевантні частини вирізані для наочності):

var isReady = eval('document.batchForm.ready');
isReady.value=0;

frames['rpc_frame'].location.href=url;

while (isReady.value==0) {
  java.lang.Thread.sleep(250);
} // endwhile

window.frames['rpc_frame'].focus();
window.frames['rpc_frame'].print();

Таким чином, користувач натискає кнопку, сценарій завантажує сторінку рахунків-фактур, потім чекає, перевіряючи кожну чверть секунди, щоб побачити, чи закінчена завантаження сторінки рахунків-фактур, після чого з'являється діалогове вікно друку для користувача, щоб надіслати його на принтер. QED.

Дуже багато відповідей (безпосередньо) не відповідають на питання, і жодна з них не відповідає ...

Ось два мої центи (або функції):

Якщо ви хочете менше незграбних функцій, ніж setTimeoutі setInterval, ви можете обернути їх у функції, які просто змінюють порядок аргументів і дають їм приємні імена:

function after(ms, fn){ setTimeout(fn, ms); }
function every(ms, fn){ setInterval(fn, ms); }

Версії CoffeeScript:

after = (ms, fn)-> setTimeout fn, ms
every = (ms, fn)-> setInterval fn, ms

Потім ви можете їх красиво використовувати з анонімними функціями:

after(1000, function(){
    console.log("it's been a second");
    after(1000, function(){
        console.log("it's been another second");
    });
});

Тепер він легко читається як "через N мілісекунд, ..." (або "кожні N мілісекунд, ...")

Для конкретного випадку, коли потрібно виділити набір викликів, виконаних циклом, ви можете використовувати щось на зразок коду, наведеного нижче, з прототипом. Без прототипу ви можете замінити функцію затримки setTimeout.

function itemHandler(item)
{
    alert(item);
}

var itemSet = ['a','b','c'];

// Each call to itemHandler will execute
// 1 second apart
for(var i=0; i<itemSet.length; i++)
{
    var secondsUntilExecution = i;
    itemHandler.delay(secondsUntilExecution, item)
}

Якщо ви перебуваєте на node.js, ви можете подивитися на волокна - нативним розширенням C до вузла, симулятором свого роду багатопотокових моделей.

Це дозволяє зробити справжнє sleepтаким чином, що блокує виконання у волокні, але це не блокування в основній нитці та інших волокнах.

Ось приклад із їхнього власного читання:

// sleep.js

var Fiber = require('fibers');

function sleep(ms) {
    var fiber = Fiber.current;
    setTimeout(function() {
        fiber.run();
    }, ms);
    Fiber.yield();
}

Fiber(function() {
    console.log('wait... ' + new Date);
    sleep(1000);
    console.log('ok... ' + new Date);
}).run();
console.log('back in main');

- і результати:

$ node sleep.js
wait... Fri Jan 21 2011 22:42:04 GMT+0900 (JST)
back in main
ok... Fri Jan 21 2011 22:42:05 GMT+0900 (JST)