Tworzę konsolę podobną do skryptu na potrzeby osobiste. Muszę być w stanie wstrzymać się na dłuższy czas, ale z moich badań wynika, że ​​node.js nie ma możliwości zatrzymania się zgodnie z wymaganiami. Po pewnym czasie trudno jest odczytać informacje o użytkownikach ... Widziałem trochę kodu, ale uważam, że muszą mieć w sobie inny kod, aby działały, takie jak:

setTimeout(function() {
}, 3000);

Potrzebuję jednak wszystkiego po tym wierszu kodu, aby wykonać po pewnym czasie.

Na przykład,

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

Widziałem też takie rzeczy

yield sleep(2000);

Ale node.js tego nie rozpoznaje.

Jak mogę osiągnąć tę dłuższą przerwę?

Najlepszym sposobem na to jest podzielenie kodu na wiele funkcji, takich jak:

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

Jest podobny do rozwiązania JohnnyHK , ale o wiele ładniejszy i łatwiejszy do rozszerzenia.

Nowa odpowiedź na stare pytanie. Dzisiaj ( styczeń 2017 czerwca 2019) jest znacznie łatwiej. Możesz użyć nowej async/awaitskładni . Na przykład:

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

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

Aby używać async/awaitod razu po instalacji bez instalacji i wtyczek, musisz użyć node-v7 lub node-v8, używając --harmonyflagi.

Aktualizacja czerwca 2019 r .: Korzystając z najnowszych wersji NodeJS, możesz go używać od razu po wyjęciu z pudełka. Nie trzeba podawać argumentów wiersza poleceń. Nawet Google Chrome obsługuje go dzisiaj.

Aktualizacja maj 2020: wkrótce będzie można używać awaitskładni poza funkcją asynchroniczną. Na najwyższym poziomie, jak w tym przykładzie

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

Wniosek znajduje się na etapie 3 . Możesz z niego korzystać dzisiaj, używając webpacka 5 (alfa),

Więcej informacji:

• Flaga harmonii w Nodejs: https://nodejs.org/en/docs/es6/
• Wszystkie wersje NodeJS do pobrania: https://nodejs.org/en/download/releases/

Najkrótsze rozwiązanie bez żadnych zależności:

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

Wpisz kod, który chcesz wykonać po opóźnieniu w ciągu setTimeout wywołania zwrotnego:

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

Jest to prosta technika blokowania:

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

To blokowanie , o ile nic innego nie będzie się działo w skrypcie (jak wywołania zwrotne). Ale ponieważ jest to skrypt konsoli, być może jest to, czego potrzebujesz!

W węźle 7.6.0 lub nowszym

Węzeł obsługuje natywne oczekiwanie:

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

to jeśli możesz użyć funkcji asynchronicznych:

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

lub:

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

W starszych wersjach węzłów (oryginalna odpowiedź)

Chciałem asynchronicznego trybu uśpienia, który działał w systemach Windows i Linux, bez konieczności zapychania mojego procesora długą pętlą while. Próbowałem pakietu uśpienia, ale nie można go zainstalować na moim komputerze z systemem Windows. Skończyło się na tym, że:

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

Aby go zainstalować, wpisz:

npm install system-sleep

W twoim kodzie

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

Działa jak marzenie.

Prosta i elegancka funkcja snu z wykorzystaniem nowoczesnego Javascript

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

Bez zależności, bez piekła zwrotnego; Otóż ​​to :-)

Biorąc pod uwagę przykład podany w pytaniu, w ten sposób chcielibyśmy spać między dwoma dziennikami konsoli:

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

main();

„Wada” polega na tym, że teraz musi być asyncrównież twoja główna funkcja . Ale biorąc pod uwagę, że już piszesz nowoczesny kod JavaScript, prawdopodobnie (lub przynajmniej powinieneś!) Używasz async/ awaitcałego kodu, więc to naprawdę nie jest problem. Wszystkie współczesne przeglądarki obsługują obecnie to.

Dając trochę wglądu w sleepfunkcję dla tych, którzy nie są przyzwyczajeni async/awaiti operatorzy grubych strzał, jest to pełny sposób pisania:

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

Jednak użycie operatora grubych strzałek czyni go jeszcze mniejszym (i bardziej eleganckim).

Możesz użyć tego www.npmjs.com/package/sleep

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

To pytanie jest dość stare, ale ostatnio V8 dodało Generatory, które mogą spełnić wymagania OP. Generatory są zazwyczaj najłatwiejsze w użyciu do interakcji asynchronicznych z pomocą biblioteki, takiej jak zawieszenie lub uruchomienie generatora .

Oto przykład użycia zawieszenia:

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

Literatura pokrewna (poprzez bezwstydną autopromocję): O co chodzi z generatorami? .

W systemie Linux / nodejs działa to dla mnie:

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

var sleep = spawnSync („sleep”, [1.5]);

Blokuje, ale nie jest zajęta pętla oczekiwania.

Określony czas jest w sekundach, ale może być ułamkiem. Nie wiem, czy inne systemy operacyjne mają podobne polecenia.

Jeśli chcesz „kodować golfa”, możesz utworzyć krótszą wersję niektórych innych odpowiedzi tutaj:

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

Ale naprawdę idealną odpowiedzią jest moim zdaniem użycie utilbiblioteki Node i jej promisifyfunkcji, która została zaprojektowana właśnie do tego rodzaju rzeczy (tworzenie opartych na obietnicach wersji wcześniej istniejących rzeczy nieobjętych obietnicą):

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

W obu przypadkach można następnie wstrzymać, używając funkcji awaitwywoływania sleep:

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

Niedawno stworzyłem prostszą abstrakcję o nazwie wait.for aby wywoływać funkcje asynchroniczne w trybie synchronizacji (na podstawie włókien węzłowych). Istnieje również wersja oparta na nadchodzących generatorach ES6.

https://github.com/luciotato/waitfor

Korzystanie z wait.for można wywoływać dowolną standardową funkcję asynchroniczną nodejs, tak jakby to była funkcja synchronizacji, bez blokowania pętli zdarzeń węzła.

Możesz kodować sekwencyjnie, kiedy jest to potrzebne, co jest (tak sądzę) idealne, aby uprościć skrypty do użytku osobistego.

za pomocą wait.for twój kod będzie:

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. 

W trybie synchronizacji można również wywołać dowolną funkcję asynchroniczną . Sprawdź przykłady.

Ponieważ silnik javascript (v8) uruchamia kod na podstawie sekwencji zdarzeń w kolejce zdarzeń, nie ma ścisłego wymogu, aby javascript dokładnie uruchamiał wykonywanie po określonym czasie. Oznacza to, że po ustawieniu kilku sekund na wykonanie kodu później kod wyzwalający opiera się wyłącznie na sekwencji w kolejce zdarzeń. Wywołanie wykonania kodu może więc zająć więcej niż określony czas.

Więc Node.js podąża

process.nextTick()

aby uruchomić kod później zamiast setTimeout (). Na przykład,

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

Dzięki obsłudze ES6 Promisemożemy z nich korzystać bez żadnej pomocy strony trzeciej.

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.

Następnie użyj go w następujący sposób:

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

Zauważ, że doWhatfunkcja staje się resolvewywołaniem zwrotnym w obrębie new Promise(...).

Zauważ też, że jest to sen ASYNCHRONICZNY. Nie blokuje pętli zdarzeń. Jeśli potrzebujesz blokowania snu, skorzystaj z tej biblioteki, która realizuje blokowanie snu za pomocą powiązań C ++. (Chociaż potrzeba blokowania snu w Węzłach, takich jak środowiska asynchroniczne, jest rzadka).

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

Powyższy kod jest efektem ubocznym rozwiązania problemu asynchronicznego wywołania zwrotnego asynchronicznego kodu JavaScript. Jest to również powód, dla którego uważam, że JavaScript jest przydatnym językiem w backend. Moim zdaniem jest to najbardziej ekscytujące ulepszenie wprowadzone we współczesnym Javascript. Aby w pełni zrozumieć, jak to działa, należy w pełni zrozumieć sposób działania generatora. Słowo functionkluczowe, po którym następuje a, *nazywa się funkcją generatora we współczesnym Javascript. Pakiet npmco funkcję Runner do uruchamiania generatora.

Zasadniczo funkcja generatora zapewniła sposób na wstrzymanie wykonania funkcji ze yieldsłowem kluczowym, a jednocześnie yieldw funkcji generatora umożliwiła wymianę informacji między generatorem a dzwoniącym. Dało to mechanizmowi wywołującemu wyodrębnienie danych z promisepołączenia asynchronicznego i przekazanie rozstrzygniętych danych z powrotem do generatora. Skutecznie sprawia, że ​​połączenie asynchroniczne jest synchroniczne.

Jest to moduł o smaku moment.js oparty na podejściu brudnego blokowania sugerowanym przez @ atlex2 . Używaj tego tylko do testowania .

const moment = require('moment');

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

module.exports = sleep;

Jeśli potrzebujesz tylko zawiesić w celu testowania, bieżące wykonanie wątku spróbuj:

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

po prostu poczekamy 5 sekund, aby zdarzyło się jakieś zdarzenie (byłoby to wskazane przez zrobioną zmienną ustawioną na true w innym miejscu w kodzie) lub gdy upłynie limit czasu, że sprawdzamy co 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;
        }
    })();

Dla niektórych osób zaakceptowana odpowiedź nie działa, znalazłem inną odpowiedź i działa ona dla mnie: Jak mogę przekazać parametr do wywołania zwrotnego setTimeout ()?

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

„hello” jest przekazywanym parametrem, wszystkie parametry można przekazać po upływie limitu czasu. Dzięki @Fabio Phms za odpowiedź.

Zamiast robić wszystkie te setTimeout, spać i wiele innych rzeczy, lepiej użyć

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

Inne odpowiedzi są świetne, ale pomyślałem, że wybiorę inny takt.

Jeśli naprawdę szukasz jedynie spowolnienia określonego pliku w systemie Linux:

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

węzeł slowprile mójprog

Będzie to spało 1 sekundę co pięć linii. Program węzła będzie działał tak wolno, jak program piszący. Jeśli robi inne rzeczy, będą kontynuować z normalną prędkością.

Program mkfifo tworzy potok typu „pierwsze weszło, pierwsze wyszło”. To sprawia, że ​​to działa. Linia perla napisze tak szybko, jak chcesz. $ | = 1 mówi, że nie buforuj danych wyjściowych.

Po przeczytaniu odpowiedzi na to pytanie stworzyłem prostą funkcję, która może również wykonać oddzwonienie, jeśli potrzebujesz:

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

Aby uzyskać więcej informacji na temat

yield sleep(2000); 

powinieneś sprawdzić Redux-Saga . Ale jest to specyficzne dla twojego wyboru Redux jako modelu modelu (choć absolutnie nie jest to konieczne).