नींद का जावास्क्रिप्ट संस्करण () क्या है?


2335

क्या sleepजावास्क्रिप्ट में इंजीनियर के लिए एक बेहतर तरीका निम्न pausecompफ़ंक्शन ( यहां से लिया गया ) है?

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

यह जावास्क्रिप्ट में नींद की नकल नहीं है - कार्यों के बीच देरी ; मैं एक फ़ंक्शन के बीच में एक वास्तविक नींद चाहता हूं , और कोड निष्पादित होने से पहले देरी नहीं करता।


4
इसे थोड़ी देर के बीच में सेट करना है, अगर मैं सेटटाइमआउट का उपयोग करता हूं, तो अधिक सेट टाइमआउट की प्रक्रिया और कतार जारी रहेगी जो अंततः उसी समय चल रही होगी और
सुगम बना लेगी

158
यह एक भयानक समाधान है - आप कुछ भी नहीं करते हुए प्रसंस्करण चक्रों को चबाते जा रहे हैं।
१ of २६

12
एक नींद का एकमात्र उद्देश्य मतदान है या कॉलबैक के लिए इंतजार कर रहा है - setInterval और setTimeout दोनों इस से बेहतर करते हैं।
annakata

1
संभवतः आप वही कर सकते हैं जो आप जावास्क्रिप्ट में जारी रखने की शैली के साथ चाहते हैं। इस लेख
ओग्यान दिमित्रोव

जवाबों:


2559

2017 - 2019 अपडेट

2009 के बाद से जब यह सवाल पूछा गया था, तो जावास्क्रिप्ट काफी विकसित हो गया है। अन्य सभी उत्तर अब अप्रचलित या अत्यधिक जटिल हैं। यहाँ सबसे अच्छा अभ्यास है:

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फ़ंक्शन को रोक देता है

दो नई जावास्क्रिप्ट सुविधाओं ने इस "नींद" फ़ंक्शन को लिखने में मदद की:

अनुकूलता

कुछ अजीब कारण आप नोड से अधिक उम्र के 7 (जो पहुँच गया है का उपयोग कर रहे हैं के लिए जीवन के अंत ), या पुराने ब्राउज़र को लक्षित कर रहे, async/ awaitअभी भी के माध्यम से इस्तेमाल किया जा सकता कोलाहल (मिलेगी कि एक उपकरण transpile सादे पुराने जावास्क्रिप्ट में जावास्क्रिप्ट + नई सुविधाओं) transform-async-to-generatorप्लगइन के साथ ।


5
यहाँ बढ़िया सामान। मुझे आश्चर्य है, कि जेएस "स्लीप" मोड को कॉल करने के बाद आधुनिक ब्राउज़र "सक्रिय" / "निष्क्रिय" राज्यों के साथ यह कैसे प्रभावित या संबंधित करता है? क्या ब्राउज़र सामान्य जेएस के लिए उम्मीद के मुताबिक नींद को अवरुद्ध कर सकता है, बाद में याद करने के लिए जब "सक्रिय" हो जाता है, या क्या इसका एक अलग व्यवहार है?
आंद्रे कैनिल्हो

18
इसके लिए वर्तमान ब्राउज़र समर्थन क्या है? मैं पिछले समाधानों को "अप्रचलित" नहीं मानूंगा, जब तक कि यह समाधान विशाल बहुमत के ब्राउज़रों या कम से कम सभी सामान्य लोगों द्वारा समर्थित न हो। इसके विपरीत, मैं इस समाधान को दिलचस्प लेकिन अनुपयोगी / अव्यवहारिक मानता हूँ जब तक कि इसका व्यापक समर्थन न हो।
एल्विन थॉम्पसन

74
यह "वास्तविक नींद" नहीं है और प्रश्न का उत्तर नहीं देता है। जिस व्यक्ति ने पूछा है उसने स्टैकओवरफ्लो के बीच एक स्पष्ट अंतर किया है । पूछताछ / 758688/sleep -in- javascript और उसका प्रश्न वास्तविक नींद में किसी अन्य कोड को निष्पादित नहीं किया जा सकता है (जब तक कि अन्य धागे में)। यह उत्तर अन्य प्रश्न के लिए अच्छा है।
17

4
@jacroe - ट्रांसपिलर एरो फ़ंक्शंस के साथ-साथ एसिंक्स / वेट को भी हैंडल करता है (जिससे आईई को उल्टी से वैसे भी खून आ जाएगा)
जैरोन्डा एक्स

11
@niry जावास्क्रिप्ट, एक एकल-थ्रेडेड भाषा होने के नाते, "वास्तविक" नींद के लिए अच्छी तरह से अनुकूल नहीं है, क्योंकि यह यूआई के समान धागे पर चलता है और गैर-जिम्मेदार वेब पेजों का कारण होगा।
पैट्रिक रॉबर्ट्स

849

( 2016 के लिए अद्यतन जवाब देखें )

मुझे लगता है कि कार्रवाई करना, इंतजार करना, फिर दूसरी कार्रवाई करना पूरी तरह से उचित है। यदि आप बहु-थ्रेडेड भाषाओं में लिखने के लिए उपयोग किए जाते हैं, तो संभवत: आपके थ्रेड के जागने तक आपको समय की एक निर्धारित राशि के लिए निष्पादन का विचार है।

यहाँ मुद्दा यह है कि जावास्क्रिप्ट एक सिंगल-थ्रेड इवेंट-आधारित मॉडल है। एक विशिष्ट मामले में, कुछ सेकंड के लिए पूरे इंजन की प्रतीक्षा करना अच्छा हो सकता है, सामान्य तौर पर यह खराब अभ्यास है। मान लीजिए कि मैं अपने स्वयं के लेखन के दौरान आपके कार्यों का उपयोग करना चाहता था? जब मैंने आपकी विधि को बुलाया, तो मेरी विधियाँ बिल्कुल स्थिर हो गईं। यदि जावास्क्रिप्ट किसी तरह आपके फ़ंक्शन के निष्पादन संदर्भ को संरक्षित कर सकता है, तो इसे कहीं स्टोर करें, फिर इसे वापस लाएं और बाद में जारी रखें, फिर नींद आ सकती है, लेकिन यह मूल रूप से फैल रहा होगा।

इसलिए आप दूसरों के सुझाव के साथ बहुत अधिक फंस गए हैं - आपको अपने कोड को कई कार्यों में तोड़ने की आवश्यकता होगी।

आपका सवाल थोड़ा गलत विकल्प है। आपके इच्छित तरीके से सोने का कोई तरीका नहीं है, और न ही आपके द्वारा सुझाए गए समाधान का पीछा करना चाहिए।


45
यह बिल्कुल सही उत्तर नहीं है। यदि जावास्क्रिप्ट में एक नींद समारोह नहीं है, तो यह केवल इसलिए है क्योंकि ECMAScript को इसकी आवश्यकता नहीं है। यह जावास्क्रिप्ट के डिजाइन के लिए जिम्मेदार निकाय द्वारा एक डिजाइन विकल्प है। यह बनाया जा सकता था कि जावास्क्रिप्ट रन टाइम कोड की अगली पंक्ति को चलाने से पहले दिए गए समय का इंतजार करता है, लेकिन इसे चुना गया था।
डिडियर ए।

5
एक नींद को जावास्क्रिप्ट में पूरी तरह से लागू किया जा सकता है वास्तविक समय परिशुद्धता के साथ नहीं। आखिरकार यह एक इवेंट आधारित प्रणाली है। यदि async कॉल पूरी हो जाती है तो एक घटना शुरू हो जाती है। मुझे कोई कारण नहीं दिखता कि जब नींद पूरी हो जाती है तो ऐसा क्यों नहीं किया जा सकता है, जिसके बाद नींद पूरी होने तक ब्राउज़र पर नियंत्रण वापस आ जाता है, कॉलिंग फ़ंक्शन पर नियंत्रण वापस आ जाता है। और हाँ, मैं इस बात से भी सहमत हूँ कि कभी-कभी नींद लेना विशेष रूप से तब आसान होता है जब डेवलपर्स से पहले आपने डिज़ाइन को इतनी बुरी तरह से खराब कर दिया हो कि आपके पास पूरी तरह से रिफैक्टरिंग के अलावा कोई दूसरा रास्ता न हो जिसके लिए आपके पास कोई समय नहीं है
लॉरेंस

कृत्रिम निद्रावस्था का प्रयास करें, जो इस विचार का अनुसरण करता है: coolwanglu.github.io/hypnotic/web/dem2.html
Tezcat

4
जावास्क्रिप्ट को सिंगल-थ्रेडेड कहना एक मिथक है। जबकि यह तकनीकी रूप से सही हो सकता है, कार्यात्मक रूप से यह एक मल्टीथ्रेडेड लैंग गेज की तरह कार्य करता है। एक कांटा अनुकरण () तुच्छ रूप से आसान है, और यद्यपि उपज () वास्तव में लागू नहीं है, आप लॉक / सेमाफोर के लिए साझा मेमोरी का उपयोग करके बहुत करीब पहुंच सकते हैं। औसत प्रोग्रामर के लिए, इसे बहु-थ्रेडेड के रूप में माना जाता है; तकनीकी नाम केवल भाषा के डेवलपर्स के लिए मायने रखता है।
बेनुबर्ड

8
मैं सहमत हूं कि sleep()जेएस में क्यों संभव नहीं है, और यह कि ज्यादातर समय चीजें करने के बेहतर तरीके हैं। लेकिन मैं अभी भी इस बात पर विचार करूंगा कि जिस तरह से इंजन सभी चीजों को डिजाइन दोष देता है; कोई कारण नहीं है कि भाषा में sleep()एक विशिष्ट स्क्रिप्ट, पृष्ठ या फ़ंक्शन तक सीमित नहीं हो सकता है , जो इंजन सीपीयू को क्लोब किए बिना और एक पागल की तरह ऐप को फ्रीज करता है। यह 2015 है और आप पूरे वेब ब्राउज़र को क्रैश नहीं कर सकते while(1)। हमारे पास फ्लैश जैसी चीजें हैं।
बीजर

660

जावास्क्रिप्ट में, मैं हर फ़ंक्शन को फिर से लिखता हूं ताकि यह जल्द से जल्द समाप्त हो सके। आप ब्राउज़र को वापस नियंत्रण में रखना चाहते हैं ताकि यह आपके DOM में बदलाव कर सके।

हर बार जब मैं अपने कार्य के बीच में एक नींद चाहता था, मैंने एक का उपयोग करने के लिए मना कर दिया setTimeout()

संपादित करें

बदनाम नींद, या देरी, किसी भी भाषा के भीतर कार्य बहुत बहस है। कुछ कहेंगे कि किसी दिए गए कार्यक्षमता में आग लगाने के लिए हमेशा एक संकेत या कॉलबैक होना चाहिए, दूसरों का तर्क होगा कि कभी-कभी विलंब का एक मनमाना क्षण उपयोगी होता है। मैं कहता हूं कि प्रत्येक अपने स्वयं के और एक नियम इस उद्योग में कभी भी कुछ भी तय नहीं कर सकता है।

एक नींद समारोह लिखना सरल है और जावास्क्रिप्ट वादों के साथ और भी अधिक उपयोगी बनाया गया है:

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

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

190
बंद होने के तरीके से। function foobar(el) { setTimeout(function() { foobar_cont(el); }, 5000); }
अराजकता

68
ठीक है, और क्या होगा यदि कोड वेब पेज में उपयोग करने का इरादा नहीं है?
यूजेनियो मिरो

10
@ EugenioMiró यदि कोड का उपयोग किसी वेबपेज में करने का इरादा नहीं है, तो होस्ट के ऑब्जेक्ट मॉडल को स्लीप विधि लागू करें। - मुझे लगता है कि सवाल डोम की ओर बढ़ा है जो वेब पेजों पर चलने वाली जावास्क्रिप्ट के संपर्क में है।
BrainSlugs83

31
@ नोसेरेडना हाँ, हम समझते हैं कि कैसे एसिंक्स कॉल करना है, यह हमें सोने में मदद नहीं करता है ()। मैं चाहता हूं कि मेरी कॉल एक निश्चित क्रम में हो, और डेटा को एक निश्चित क्रम में वापस किया जाए। मैं एक लूप के लिए 5 स्तर गहरा हूं। मैं निष्पादन निष्पादित करना चाहता हूं। एक सच्ची नींद की विधि "ब्राउज़र को धीमा" नहीं करेगी, नींद वाले हाथ ब्राउज़र पर वापस नियंत्रण करते हैं और किसी भी अन्य धागे जो सीपीयू समय चाहते हैं जबकि यह अभी भी अवरुद्ध है।
BrainSlugs83

382
यह सवाल का जवाब नहीं है।
टीएमएस

302

केवल डिबग / देव के लिए , मैं इसे पोस्ट करता हूं अगर यह किसी के लिए उपयोगी है

दिलचस्प सामान, फायरबग (और शायद अन्य जेएस कंसोल) में, प्रवेश करने के बाद कुछ भी नहीं होता है, केवल नींद की अवधि निर्दिष्ट होने के बाद (...)

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 !"); }

36
यह कोई उत्तर नहीं है। यह प्रश्न में कोड के समान ही है, थोड़ा कम छोड़कर।
jab

16
व्यस्त प्रतीक्षा, वास्तव में? जेएस में? सेकंड के लिए? अगर मैं ऐसा करने वाली वेबसाइट को पकड़ता हूं, तो उसे ब्लॉक कर दिया जाएगा।
mafu

34
@mafu यही कारण है कि यह कहता है only for debug/dev... rolleyes
xDaizu

11
कभी नहीं। यह CPU को उस कोर पर 100% हिट करने के लिए बना देगा जिसे वह निष्पादित करता है और इसे ब्लॉक करेगा।
नोएगो

3
यह एक कमांड-लाइन जावास्क्रिप्ट एप्लिकेशन के भीतर, और शायद सोने का एकमात्र तरीका उपयोगी है, क्योंकि async / प्रतीक्षा उपयोगी नहीं है।

177

मैं अन्य पोस्टरों से सहमत हूं, एक व्यस्त नींद सिर्फ एक बुरा विचार है।

हालांकि, सेटटाइमआउट निष्पादन को रोक नहीं पाता है, यह समय समाप्त होने के तुरंत बाद फ़ंक्शन की अगली पंक्ति को निष्पादित करता है, टाइमआउट समाप्त होने के बाद नहीं, ताकि एक ही कार्य पूरा न हो जिससे नींद पूरी हो।

इसे करने का तरीका भागों से पहले और बाद में अपने कार्य को तोड़ना है।

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)

संपादित करें

यह विधि आपके द्वारा तय किए गए समय तक कोड की पंक्तियों को निष्पादित नहीं करने के उद्देश्य को प्राप्त करती है, जबकि अभी भी क्लाइंट पीसी पर नियंत्रण वापस लौटाने के लिए जो कुछ भी कतारबद्ध है उसे निष्पादित करने के लिए।

आगे संपादित करें

जैसा कि टिप्पणियों में बताया गया है यह बिल्कुल पाश में काम नहीं करेगा। आप इसे लूप में काम करने के लिए कुछ फैंसी (बदसूरत) हैकिंग कर सकते हैं, लेकिन सामान्य तौर पर यह सिर्फ विनाशकारी स्पेगेटी कोड के लिए ही होगा।


12
हाँ। जहां यह मुश्किल हो जाता है जब आपके पास एक लूप, या एक नेस्टेड लूप भी होता है। आपको छोरों के लिए अपना त्याग करना होगा और इसके बजाय काउंटर करना होगा।
नोसरेडना

ट्च। मेरा मतलब है, यह अभी भी संभव होगा, लेकिन उस मामले में बदसूरत और हैकिश। तुम भी कुछ स्थिर बूलियन राज्य चर का उपयोग कर सकते हैं, लेकिन यह भी बहुत hackish है।
डेविनबी

2
-1 इसके लिए। फिर, यह सवाल का जवाब नहीं देता है। यह "एक फ़ंक्शन को अतुल्यकालिक रूप से कैसे निष्पादित करें" जैसे प्रश्न के लिए अधिक उत्तर है, जो "कोड निष्पादन को कैसे अवरुद्ध करें" से बहुत अलग है।
दीपक जीएम

6
@ नोस्डन्ना नहीं, आप एक बंद का उपयोग करेंगे। उदाहरण के लिए: function foo(index) { setTimeout(function() { foo_continue(index); }, 10000); }और for(var X = 0; X < 3;X++) { foo(X); }- X का मान पारित किया गया है foo, जो तब नाम के तहत पुन: उपयोग किया जाता है indexजब foo_continueअंततः कहा जाता है।
इज़्काता

2
@Alexander बेशक, यह करता है, क्योंकि सेटटाइमआउट () के बिंदु को ब्राउज़र को कोड को समान रूप से चलाकर लॉक करने से रोकना है। सेटटाइमआउट संस्करण में console.log()अंदर रखो foo_continue()और आपको एक ही परिणाम मिलता है।
इजाकाता

132

$ 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 का उपयोग कैसे किया जाता है।


3
अच्छी तरह से सब कुछ नहीं: setInterval मतदान के बेहतर प्रभाव को दर्शाता है।
annakata

3
जावास्क्रिप्ट इंजन में कोड का वह टुकड़ा वापस नहीं आएगा ।
डेनिज डोगन

10
जब तक आपको नींद को समकालिक होने की आवश्यकता नहीं होती है, उस स्थिति में यह पूरी तरह से वैध प्रश्न है।
आरोन दुफौर

36
मुझे लगता है कि हम में से कई लोग भूल रहे हैं कि जावास्क्रिप्ट एक ब्राउज़र-केवल भाषा नहीं है। यह दोस्त एक नोड कमांड लाइन उपयोगिता का निर्माण कर सकता है, जिसे सेटटाइमआउट के साथ आने वाले सभी चर स्कोपिंग मुद्दों से निपटने की आवश्यकता के बिना एक संक्षिप्त ठहराव की आवश्यकता होती है।
फिल लनासा

3
@PhilLaNasa: यदि सिंटैक्टिक क्लोज़र अभी भी एक को डरा रहा है, तो एक को गंभीरता से नीचे झुकना होगा और नोड 101 के माध्यम से काम करना होगा।
chaos

113

मुझे पता है कि यह एक पुराना सवाल है, लेकिन अगर (मेरी तरह) आप राइनो के साथ जावास्क्रिप्ट का उपयोग कर रहे हैं, तो आप उपयोग कर सकते हैं ...

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

4
क्या यह जावा के लिए एक कॉल है?
केन शार्प

14
यह जावा नहीं जावास्क्रिप्ट है
रूसो

18
@ रूसो अलेक्सांद्र गलत। यह राइनो का उपयोग करते हुए जावास्क्रिप्ट है (उस समय, यह इन दिनों
नैशोर्न

71

यदि आप jQuery का उपयोग कर रहे हैं, तो किसी ने वास्तव में एक "देरी" प्लगइन बनाया है जो सेटटाइमआउट के लिए एक आवरण से अधिक कुछ नहीं है:

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

4
यह एक बुरा समाधान नहीं है। संदर्भ और श्रृंखलाबद्धता रखता है।
Nosredna

39
JQuery 1.4 के रूप में, jQuery .delay()का हिस्सा है (हालांकि उपरोक्त कार्यान्वयन से अलग शब्दार्थ के साथ)। api.jquery.com/delay
मैट बॉल

7
इस सवाल का क्या कमी थी निश्चित रूप से एक jQuery का जवाब था । तो खुशी से हम मिल गए!
xDaizu

1
यदि आपको दो स्वतंत्र कॉल के बीच देरी की आवश्यकता है, तो हाँ। यदि आपको एक लूप धीमा करने के लिए देरी की आवश्यकता है, तो नहीं।
WGroleau

46

मैंने नींद के समाधान के लिए भी खोज की है (उत्पादन कोड के लिए नहीं, केवल देव / परीक्षणों के लिए) और इस लेख को पाया:

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

... और यहां क्लाइंट-साइड समाधान के साथ एक और लिंक है: http://www.devcheater.com/

इसके अलावा, जब आप कॉल कर रहे हैं alert(), तो आपका कोड भी रोक दिया जाएगा, जबकि अलर्ट दिखाया गया है - अलर्ट प्रदर्शित नहीं करने का एक तरीका खोजने की आवश्यकता है लेकिन समान प्रभाव प्राप्त करें। :)


35
मैं मानता हूं, बहुत सारे लोग कह रहे हैं, "नहीं, उत्पादन कोड में ऐसा मत करो!" हाँ, उम, मैं नहीं करना चाहता। मैं इसे थ्रोअवे टेस्ट कोड में करना चाहता हूं, और इसके परिणामस्वरूप मैं एक सुरुचिपूर्ण समाधान बनाने में बहुत समय खर्च नहीं करना चाहता।
user435779

31

यहाँ एक सरल समाधान का उपयोग कर एक तुल्यकालिक XMLHttpRequest है:

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

नींद की सामग्री।

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

अब इसे कॉल करें: नींद (5);


5
@ लुक्कड़, setTimeout()अगर यह काम करता है, तो उपयोग करें , लेकिन अगर ऐसा करने का मतलब है कि कॉलबैक की 1000 लाइनों को हटाना, तो यह मजाक की तरह नहीं लग सकता है।
पगडियारियो

11
अद्वितीय दृष्टिकोण, हालांकि दुर्भाग्य से गैर-एसिंक्स XMLHttpRequests को हटा दिया गया है और भविष्य में हटा दिया जाएगा। जो कि मज़ेदार है, क्योंकि यह तथ्य है जिसने मुझे इस सवाल की ओर अग्रसर किया है।
बीजर

यह वास्तव में एक बहुत अच्छा विचार है IMO। हालांकि मुझे नहीं लगता कि स्लीप एपीआई (रिक्वेस्ट यूआरएल) सार्वजनिक होनी चाहिए क्योंकि इसका दुरुपयोग हो सकता है।
वाहिद अमीरी

@ भविष्य की हमेशा केवल भविष्य के बारे में सोच भविष्य के असत्य पर जीने का मतलब है :-)
user1742529

अच्छा है लेकिन क्या आप जानते हैं कि कुछ समय इंटरनेट धीमा है या वेबसाइट पिंग का समय अधिक है क्योंकि यह तर्क समय से अधिक समय के लिए स्क्रिप्ट सोएगा। जैसे यदि आप उपयोग करते हैं sleep(300)और वेबसाइट को प्रतिक्रिया के लिए 150 ms का समय लगता है तो जावास्क्रिप्ट कोड 450ms के लिए सो जाएगा। और यदि इंटरनेट कनेक्शन ब्राउज़र द्वारा खो जाता है तो यह केवल 0ms के लिए काम करेगा। तो यह बेहतर समाधान नहीं है
एच चौहान

30

हेयर यू गो। जैसा कि कोड कहता है, एक बुरा देव नहीं है और वेबसाइटों पर इसका उपयोग करें। यह एक विकास उपयोगिता कार्य है।

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

17
ओपी के पास मूल रूप से वही बात है।
एंड्रयू बार्बर

5
अधिक सटीक होने के लिए, यह वही है जो ओपी ने एक वैकल्पिक के लिए पूछा था।
WGroleau

समाधान अच्छा नहीं है, लेकिन कुछ स्थानों पर async/awaitयह दुर्भाग्य से उत्तरदायी नहीं है, और हमें इसे अनिवार्य रूप से उपयोग करना होगा।
नबी काज

21

मुझे व्यक्तिगत रूप से सरल पसंद है:

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

फिर:

sleep(2); // Sleeps for 2 seconds

P5js में स्क्रिप्ट बनाते समय नकली लोड समय बनाने के लिए मैं इसका हर समय उपयोग कर रहा हूं


3
मैं इसे मुख्य प्रश्न के सबसे अनुकूलित संस्करण के रूप में देखता हूं: यह लूप के अंदर कोई गणित नहीं करता है, बस एक सादा तुलना। थओ को पढ़ना थोड़ा मुश्किल है।
हेजेज

4
कभी मत करो। क्या यह कार्य करते समय आपने CPU उपयोग की जाँच की है? यदि आप इसके लिए पर्याप्त समय देते हैं तो यह 100% के करीब होना चाहिए।
Noego

2
@ हेजेज: यह देखते हुए कि एक निश्चित मात्रा में दीवार घड़ी के लिए लूप चलने वाला है, चाहे जो भी हो, ऐसा लगता है कि लूप को अनुकूलित करना बिंदु के बगल में है।
शैडो रेंजर

@noego ऐसा कैसे? मैंने अभी-अभी नोड 10 में परीक्षण किया है, मेरे पास कोई सीपीयू उपयोग परिवर्तन नहीं है
मेलमॉस

@melMass यह फ़ंक्शन केवल CPU को 100% व्यस्त रखकर n सेकंड के लिए नोड थ्रेड को ब्लॉक करता है। यह "समाधान" उन दो कारणों (अवरुद्ध + सीपीयू हत्यारा) के लिए एक बहुत बुरा विचार है। प्रतीक्षा करना गैर-अवरुद्ध होना है, इसलिए अतुल्यकालिक है।
जेरेमी थाइल

20

प्रथम:

एक फ़ंक्शन को परिभाषित करें जिसे आप इस तरह निष्पादित करना चाहते हैं:

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

फिर सेटटाइम पद्धति के साथ इसके निष्पादन को शेड्यूल करें:

setTimeout(alertWorld,1000)

दो बातों पर ध्यान दें

  • दूसरा तर्क मिलिस सेकंड में है
  • पहले तर्क के रूप में, आपको कोष्ठक के बिना, फ़ंक्शन का सिर्फ नाम (संदर्भ) पास करना होगा

18

चीजों को बेहतर बनाने के लिए बेहतर समाधान जैसा कि ज्यादातर लोग चाहते हैं कि एक अनाम फ़ंक्शन का उपयोग करें:

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

यह संभवत: निकटतम है जो आपको कुछ ऐसा मिलेगा जो आप चाहते हैं।

ध्यान दें, यदि आपको कई नींद की आवश्यकता है तो यह जल्दी में बदसूरत हो सकता है और आपको वास्तव में अपने डिजाइन पर पुनर्विचार करने की आवश्यकता हो सकती है।


यह वह है जो डेस्कटॉप ब्राउज़र और पुराने मोबाइल फोन पर मेरे लिए काम करता है। मैंने जिन अन्य लोगों की कोशिश की, वे सभी पर काम नहीं किए।
माइक

18

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

सुनिश्चित करें कि आपका कॉलिंग फ़ंक्शन async है

सत्यापित और ठीक काम


आखिरकार। एक और केवल उत्तर।
जेरेमी थाइल

10

ब्राउज़रों के लिए, मैं मानता हूं कि setTimeout और setInterval जाने का रास्ता है।

लेकिन सर्वर-साइड कोड के लिए, इसे एक अवरुद्ध फ़ंक्शन की आवश्यकता हो सकती है (उदाहरण के लिए, इसलिए आप प्रभावी रूप से थ्रेड सिंक्रोनाइज़ेशन कर सकते हैं)।

यदि आप नोड.जेएस और उल्का का उपयोग कर रहे हैं, तो आप फाइबर में सेटटाइमआउट का उपयोग करने की सीमाओं में भाग सकते हैं। यहाँ सर्वर-साइड स्लीप के लिए कोड है।

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


Server may require a blocking function... मैं नहीं देखता कि बलपूर्वक नोड के एकमात्र धागे को कैसे
रोका जाए

10

मैं अन्य अतुल्यकालिक कार्यों के साथ कोड संगति के लिए एक वादा में setTimeOut को एन्क्रिप्ट करूंगा: फिडल में डेमो

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

इस तरह इस्तेमाल किया:

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

सिंटैक्स को याद रखना आसान है यदि आप वादे का उपयोग करते थे।


4
यह सेटटाइमआउट (फ़ंक्शन () {/ * कुछ करें * /}, 2000) का उपयोग करने से बेहतर क्यों है?;
JSideris

10

2019 Atomics.wait का उपयोग करके अपडेट करें

नोड 9.3 या उच्चतर में काम करना चाहिए।

मुझे Node.js में एक बहुत सटीक टाइमर की आवश्यकता थी और यह उसके लिए बहुत अच्छा काम करता है। हालाँकि ऐसा लगता है कि ब्राउज़रों में बेहद सीमित समर्थन है।

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

कुछ 10 सेकंड के टाइमर बेंचमार्क दौड़े।

सेटटाइमआउट के साथ मुझे 7000 माइक्रोसेकंड तक की त्रुटि मिलती है। (7ms)

एटमिक्स के साथ मेरी त्रुटि 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){}
%>

मेरी राय में स्वीकार किए गए समाधान से बेहतर है जिसे कॉल में async / प्रतीक्षा के बिना एक साधारण फ़ंक्शन के रूप में लागू नहीं किया जा सकता है।
GroovyDotCom

हाँ, जब तक आप जानते हैं कि यह अवरुद्ध है और यह आमतौर पर एक अच्छी बात नहीं है
कापियानहूक

बहुत अच्छा है, लेकिन तथ्य यह है कि यह केवल क्रोम और फ़ायरफ़ॉक्स में वास्तव में समर्थित है, यह वेब पर उपयोग के लिए बहुत व्यवहार्य नहीं बनाता है। (नवंबर 2019)
JGreatorex

9

यहां अधिकांश उत्तर गुमराह करने वाले या बहुत कम पुराने हैं। कोई कारण नहीं है कि जावास्क्रिप्ट को थ्रेडेड होना चाहिए, और वास्तव में यह नहीं है। आज सभी मुख्यधारा के ब्राउज़र श्रमिकों का समर्थन करते हैं, इससे पहले यह मामला राइनो और नोड्स जेएस जैसे अन्य जावास्क्रिप्ट रनटाइम्स का समर्थन करता था।

'जावास्क्रिप्ट सिंगल थ्रेडेड' एक मान्य उत्तर नहीं है। उदाहरण के लिए, एक कार्यकर्ता के भीतर एक नींद समारोह चलाने के लिए 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);

नींद की यह नकल एक सच्चे नींद समारोह से अलग है क्योंकि यह धागे को अवरुद्ध नहीं करता है। यह जावास्क्रिप्ट के वर्तमान सेटटाइमआउट फ़ंक्शन के शीर्ष पर बस चीनी है। यह कार्यक्षमता प्रकार टास्क.जेएस में लागू किया गया है और फ़ायरफ़ॉक्स में आज काम करना चाहिए।


श्रमिकों को IE में लागू नहीं किया गया है, कम से कम संस्करण 10 के माध्यम से। जो वर्तमान में बड़ी मात्रा में उपयोगकर्ताओं का प्रतिनिधित्व करता है।
बीजर

सच है, और तब भी sleepकई श्रमिकों का उपयोग करके इसे लागू करना व्यावहारिक नहीं है । यदि Node.js जनरेटर फ़ंक्शंस का उपयोग पहले से ही लागू है और वर्णित के रूप में उपयोग किया जा सकता है। मुख्यधारा के ब्राउज़रों ने आज तक सभी जेनरेटर लागू नहीं किए हैं।
गेब्रियल रैटनर

8

मैंने जावास्क्रिप्ट नींद / प्रतीक्षा पर काफी कुछ वेबपेज खोजे / गुगले किये हैं ... और कोई उत्तर नहीं है यदि आप "RUN, DELAY, RUN" के लिए जावास्क्रिप्ट चाहते हैं ... तो ज्यादातर लोगों को क्या मिला, "RUN, RUN (बेकार) सामान), RUN "या" RUN, RUN + विलंबित RUN "...।

इसलिए मैंने कुछ बर्गर खाए और सोच रहा था :: यहाँ एक समाधान है जो काम करता है ... लेकिन आपको अपने रनिंग कोड्स को काटना होगा ... ::: हाँ, मुझे पता है, यह सिर्फ रिफैक्टरिंग पढ़ना आसान है। । फिर भी...

//......................................... //उदाहरण 1:

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

// .............. उदाहरण 4:

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

5
ठीक है, यह सेटटाइमपुत के साथ काम करता है, लेकिन यह देखना मुश्किल है कि क्या हो रहा है। स्वयं setTimeout का उपयोग करना इससे आसान है।
नौगटुर

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

यह वास्तविक प्रश्न के समान है। ज्यादा नहीं यह असली जवाब है।
ईएमएल

2
एक अच्छा समाधान नहीं है - सेलेनियम के जावास्क्रिप्ट में इस का उपयोग करते हुए मेरे क्रोम ब्राउज़र को 2104 मैकबुक प्रो पर लगभग 50% समय लटका दिया जाता है।
एमरी

7

किसी भी निर्भरता के बिना सबसे छोटा समाधान:

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

यह IE11 में काम नहीं करता है। हमें एरो फंक्शन के लिए सिंटैक्स त्रुटि मिलती है।
डीडीएफपी

@ जावा-डीके का उपयोगawait new Promise(function(resolve) { setTimeout(resolve, 5000); });
k06a

6

आप जावास्क्रिप्ट में ऐसा नहीं कर सकते हैं, या, बल्कि, आपको नहीं करना चाहिए। एक नींद या थोड़ी देर के लूप चलाने से उपयोगकर्ता के ब्राउज़र को लूप होने तक लटका दिया जाएगा।

एक टाइमर का उपयोग करें, जैसा कि आपके द्वारा निर्दिष्ट लिंक में है।


6

एक परिदृश्य जहां आप सेट टाइमआउट () का उपयोग करने के बजाय एक नींद () फ़ंक्शन चाहते हो सकते हैं, यदि आपके पास एक उपयोगकर्ता क्लिक का एक फ़ंक्शन है जो अंततः एक नया यानी पॉपअप विंडो खोल रहा है और आपने कुछ प्रसंस्करण शुरू किया है जिसके लिए एक छोटी अवधि की आवश्यकता होती है पॉपअप प्रदर्शित होने से पहले पूरा करने के लिए। खुली खिड़की को बंद करने का मतलब है कि यह आमतौर पर ब्राउज़र द्वारा अवरुद्ध हो जाता है।


6

मैं एक नींद समारोह के उद्देश्य को समझ सकता हूं यदि आपको तुल्यकालिक निष्पादन से निपटना है। सेटइंटरवल और सेटटाइमआउट फ़ंक्शंस एक समानांतर निष्पादन थ्रेड बनाते हैं जो निष्पादन अनुक्रम को मुख्य प्रोग्राम में वापस कर देता है, जो अप्रभावी है यदि आपको किसी दिए गए परिणाम के लिए इंतजार करना पड़ता है। बेशक कोई भी घटनाओं और हैंडलर का उपयोग कर सकता है, लेकिन कुछ मामलों में ऐसा नहीं है।


6

मेरे दोनों चूतड़ों को जोड़ना। मुझे परीक्षण उद्देश्यों के लिए एक व्यस्त-प्रतीक्षा की आवश्यकता थी। मैं कोड को विभाजित नहीं करना चाहता था क्योंकि यह बहुत काम होगा, इसलिए मेरे लिए यह एक सरल काम था।

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

मुझे ऐसा करने में कोई कमी नहीं दिख रही है और इसने मेरे लिए चाल चली।


जिसे संकलित किया जा सकता है।
विक्टर सेहर

कृपया इसे इस तरह न करें। यह एक ब्लॉकिंग स्लीप कॉल है, जिसका अर्थ है कि कोई अन्य जावास्क्रिप्ट नहीं चल सकता है जबकि आपका कोड JS थ्रेड को हॉगिंग कर रहा है।
स्टीव मिडगले

5
@SteveMidgley "कोई अन्य जावास्क्रिप्ट [चलाने में सक्षम] जब आपका कोड JS थ्रेड को हॉग कर रहा हो" तो मुझे ऐसा प्रतीत होता है कि ओपी ¯_ (ツ) _ / ¯ करना चाहता है या नहीं
drigoangelo

1
मैंने अभी कुछ परीक्षण किए हैं और ऐसा प्रतीत होता है कि एक खाली लूप भी ब्राउज़र और सीपीयू (केवल जावास्क्रिप्ट) को अवरुद्ध नहीं करेगा। और forलूप का उपयोग करना लगभग हमेशा तुरंत निष्पादित होगा, भले ही अधिकतम मूल्य के लिए i, और यहां तक ​​कि जटिल गणित कोड के अंदर रखा गया हो। इसलिए जब तक आप केवल कुछ मिलीसेकंड की प्रतीक्षा नहीं कर रहे हैं, तब भी लगता है कि जेएस में इनायत से सोने का कोई तरीका नहीं है।
बीजर

1 मिलियन बहुत बड़ा है। मेरे लिए पर्याप्त 10k
व्लाद

6

यह जावा की नींद विधि का उपयोग करके किया जा सकता है। मैंने इसे FF और IE में परीक्षण किया है और यह कंप्यूटर को लॉक नहीं करता है, संसाधनों को चबाता है, या अंतहीन सर्वर हिट करता है। मेरे लिए एक स्वच्छ समाधान की तरह लगता है।

सबसे पहले आपको जावा को पेज पर लोड करना होगा और इसके तरीके उपलब्ध करवाने होंगे। ऐसा करने के लिए, मैंने यह किया:

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

फिर, आपको अपने जेएस में दर्द रहित ठहराव चाहिए,

java.lang.Thread.sleep(xxx)

जहां xxx मिलीसेकंड में समय है। मेरे मामले में (औचित्य के अनुसार), यह एक बहुत छोटी कंपनी में बैक-एंड ऑर्डर की पूर्ति का हिस्सा था और मुझे एक चालान प्रिंट करने की आवश्यकता थी जिसे सर्वर से लोड किया जाना था। मैंने इसे चालान में लोड करके (एक वेबपेज के रूप में) iFrame में किया और फिर iFrame को प्रिंट किया। बेशक, मुझे प्रिंट होने से पहले पेज को पूरी तरह से लोड होने तक इंतजार करना था, इसलिए जेएस को रोकना पड़ा। मैंने इनवॉइस पृष्ठ (iFrame में) को ऑनडैड घटना के साथ मूल पृष्ठ पर छिपे हुए प्रपत्र फ़ील्ड को बदलकर पूरा किया। और चालान को प्रिंट करने के लिए मूल पृष्ठ पर कोड इस तरह दिखता है (स्पष्टता के लिए अप्रासंगिक भागों में कटौती):

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।


12
जब लेखक साधारण चीज को प्राप्त करना चाहता था, तब काफी राक्षसी आत्मीयता महसूस करता है।
xaralis

2
यह जावा Applets पर निर्भर करता है जो कि पदावनत है।
वाहिद अमीरी

6

बहुत सारे उत्तर सीधे सवाल का जवाब नहीं देते हैं, और न ही यह ...

यहाँ मेरे दो सेंट (या फ़ंक्शंस) हैं:

आप कम से कम भद्दा कार्यों चाहते हैं setTimeoutऔर setInterval, आप उन्हें कार्यों में लपेट कर सकते हैं कि सिर्फ बहस के क्रम को उल्टा करने के लिए और उन्हें अच्छा नाम दे:

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

कॉफीस्क्रिप्ट संस्करण:

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

अब यह आसानी से "एन मिलीसेकंड के बाद, ..." (या "हर एन मिलीसेकंड, ...") के रूप में आसानी से पढ़ता है


5

लूप द्वारा निष्पादित किए जा रहे कॉल के सेट को स्पेस देने की इच्छा के विशिष्ट मामले के लिए, आप प्रोटोटाइप के साथ नीचे दिए गए कोड की तरह कुछ का उपयोग कर सकते हैं। प्रोटोटाइप के बिना, आप सेटटाइमआउट के साथ देरी फ़ंक्शन को स्थानापन्न कर सकते हैं।

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

5

यदि आप नोड्स पर हैं, तो आप फाइबर पर एक नज़र डाल सकते हैं - नोड के लिए एक देशी सी एक्सटेंशन, एक थोड़े-बहु-थ्रेडिंग सिमुलेशन।

यह आपको 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)
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.