sleep ()의 JavaScript 버전은 무엇입니까?

sleep다음 pausecomp함수 ( 여기에서 가져온 것)보다 JavaScript에서을 엔지니어링하는 더 좋은 방법이 있습니까?

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

이것은 JavaScript에서 Sleep 의 복제본이 아닙니다 -동작 사이의 지연 ; 함수 중간에 실제로 잠을 자고 코드 조각이 실행되기 전에 지연되지 않기를 원합니다 .

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. awaitasync키워드가 접두사로 사용 되거나 일부 환경 (예 : Chrome DevTools 콘솔 또는 Runkit)에서 스크립트 의 최상위 수준 에서만 실행될 수 있습니다 .
2. await현재 async기능 만 일시 정지

두 가지 새로운 JavaScript 기능이이 "잠자기"기능을 작성하는 데 도움이되었습니다.

• ES2015 (일명 ES6) 의 기본 기능인 약속 . 또한 수면 기능 정의에 화살표 기능 을 사용 합니다.
• 이 async/await기능을 통해 코드는 약속이 해결 될 때까지 명시 적으로 기다릴 수 있습니다 (해결 또는 거부).

적합성

• 약속이 지원됩니다 노드 v0.12 +에서 와 널리 브라우저에서 지원 IE를 제외하고,
• async/ awaitV8에 상륙했으며 Chrome 55 (2016 년 12 월 출시) 이후 기본적 으로 사용 설정되었습니다.
  • 2016 년 10 월 노드 7에 상륙 했습니다.
  • 2016 년 11 월 Firefox Nightly에 상륙 했습니다.

당신이 (도달 노드보다 오래된 7 사용하고 어떤 이상한 이유로 경우 의 수명을 ), 또는 오래된 브라우저를 대상으로, async/ await여전히를 통해 사용할 수 있습니다 바벨 (도구를 것 transpile 평범한 구식 자바 스크립트로 자바 스크립트 + 새로운 기능) 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!
});

debug / 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
}

함수 이름이 각 부분이 수행하는 작업을 정확하게 설명하는지 확인하십시오 (예 : funcPart1 및 funcPart2가 아닌 IE GatherInputThenWait 및 CheckInput).

편집하다

이 방법은 제한 시간이 지나면 결정한 코드 줄을 실행하지 않고 큐에 대기 한 다른 항목을 실행하기 위해 클라이언트 PC로 다시 제어를 되 돌리는 목적을 달성합니다.

추가 편집

주석에서 지적했듯이 이것은 루프에서 절대 작동하지 않습니다. 루프에서 작동하도록 멋진 (추악한) 해킹을 수행 할 수는 있지만 일반적으로 비참한 스파게티 코드를 만들 것입니다.

$ 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>

2 초 간격마다 1 초 동안 텍스트가 숨겨집니다. setInterval 및 setTimeout을 사용하여 매초마다 텍스트를 표시하고 숨기는 방법을 보여줍니다.

나는 이것이 오래된 질문이라는 것을 알고 있지만 (나 같은) Rhino와 함께 Javascript를 사용하고 있다면 사용할 수 있습니다 ...

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

이제 다음과 같이 호출하십시오. sleep (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 및 meteor를 사용하는 경우 광섬유에서 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

다른 비동기 작업과 코드 일관성을 유지하기 위해 Promise에 setTimeOut을 캡슐화합니다. Demo in Fiddle

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

그런 식으로 사용 :

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

약속을 사용했던 경우 구문을 기억하기 쉽습니다.

Atomics.wait를 사용한 2019 업데이트

노드 9.3 이상에서 작동해야합니다.

Node.js에서 꽤 정확한 타이머가 필요했으며 그 기능이 훌륭합니다. 그러나 브라우저에서 지원이 극히 제한적인 것 같습니다.

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

몇 10 초 타이머 벤치 마크를 실행했습니다.

setTimeout을 사용하면 최대 7000 마이크로 초의 오류가 발생합니다. (7ms)

Atomics에서 내 오류는 600 마이크로 초 미만으로 유지됩니다. (0.6ms)

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){}
%>

여기에있는 대부분의 답변은 잘못 안내되거나 최소한 구식입니다. 자바 스크립트가 단일 스레드 여야하는 이유는 없으며 실제로는 그렇지 않습니다. Rhino 및 Node.js와 같은 다른 자바 스크립트 런타임이 멀티 스레딩을 지원하기 전에 오늘날 모든 주류 브라우저는 작업자를 지원합니다.

'자바 스크립트는 단일 스레드입니다'는 올바른 답변이 아닙니다. 예를 들어 작업자 내에서 절전 기능을 실행하면 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);

이 수면 모방은 스레드를 차단하지 않으므로 실제 수면 기능과 다릅니다. Javascript의 현재 setTimeout 함수 위에 설탕입니다. 이 기능 유형은 Task.js 에서 구현되었으며 오늘날 Firefox에서 작동합니다.

javascript sleep / wait에서 꽤 많은 웹 페이지를 검색 / 검색했으며 ... Javascript를 "RUN, DELAY, RUN"으로 설정하려는 경우 대답이 없습니다 ... 대부분의 사람들이 얻은 것은 "RUN, RUN (무용 지) stuff), RUN "또는"RUN, RUN + delayed 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에서 그런 식으로 잠을 잘 수 없거나 오히려해서는 안됩니다. 휴면 또는 while 루프를 실행하면 루프가 완료 될 때까지 사용자 브라우저가 정지됩니다.

참조한 링크에 지정된대로 타이머를 사용하십시오.

setTimeout ()을 사용하지 않고 sleep () 함수를 원할 수있는 한 가지 시나리오는 사용자 클릭에 응답하는 함수가 궁극적으로 새 ie 팝업 창을 열고 짧은 기간이 필요한 처리를 시작한 경우입니다. 팝업이 표시되기 전에 완료하십시오. 열린 창을 클로저로 이동하면 일반적으로 브라우저에 의해 차단됩니다.

동기 실행을 처리 해야하는 경우 절전 기능의 목적을 이해할 수 있습니다. 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)

여기서 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();

따라서 사용자가 버튼을 누르면 스크립트가 송장 페이지를로드 한 다음 대기하며, 1 초마다 확인하여 송장 페이지로드가 완료되었는지 확인한 다음 사용자가 인쇄 대화 상자를 프린터로 보낼 수 있도록합니다. QED.

많은 답변이 (직접적으로) 질문에 대답하지 않으며, 어느 것도 대답하지 않습니다 ...

내 두 센트 (또는 기능)는 다음과 같습니다.

setTimeoutand 보다 덜 교묘 한 함수를 원한다면 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광섬유에서 실행을 차단하는 방식으로 실제 작업을 수행 할 수 있지만 주 스레드 및 기타 광섬유에서는 차단되지 않습니다.

다음은 자신의 readme에서 새로 만든 예입니다.

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