නින්දේ () ජාවාස්ක්‍රිප්ට් අනුවාදය කුමක්ද?


2351

sleepපහත දැක්වෙන pausecompශ්‍රිතයට වඩා ( මෙතැනින් ගත් ) ජාවාස්ක්‍රිප්ට් හි ඉංජිනේරුවෙකු කිරීමට වඩා හොඳ ක්‍රමයක් තිබේද?

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

මෙය ජාවාස්ක්‍රිප්ට් හි නින්දේ අනුපිටපතක් නොවේ - ක්‍රියාවන් අතර ප්‍රමාදය ; මට අවශ්‍ය වන්නේ ශ්‍රිතයක් මධ්‍යයේ සැබෑ නින්දක් මිස කේතයක් ක්‍රියාත්මක වීමට පෙර ප්‍රමාදයක් නොවේ.


4
එය ටික වේලාවකින් සැකසිය යුතුය, මම setTimeout භාවිතා කරන්නේ නම්, කාලයත් සමඟම වැඩිපුර setTimeouts සැකසීමට හා පෝලිම් ගැසීමට හැකි වන අතර එය අවසානයේදී එකවර ක්‍රියාත්මක වන අතර ඔවුන් අතර මඳක් එකඟතාවයක් ඇති කර ගනී
fmsf

161
මෙය භයානක විසඳුමකි - ඔබ කිසිවක් නොකර සිටියදී සැකසුම් චක්‍ර හපනු ඇත.
17 න් 26

12
නින්දක් සඳහා ඇති එකම අරමුණ ඡන්ද විමසීම හෝ ඇමතුමක් ලබා ගැනීම සඳහා බලා සිටීමයි - setInterval සහ setTimeout යන දෙකම මීට වඩා හොඳය.
annakata

1
ජාවාස්ක්‍රිප්ට් හි අඛණ්ඩ සම්මත ශෛලිය සමඟ ඔබට අවශ්‍ය දේ කළ හැකිය. මෙම ලිපිය
ඔග්නියන් ඩිමිට්‍රොව්

Answers:


2605

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 console, හෝ Runkit).
  2. awaitවත්මන් asyncශ්‍රිතය විරාමයක් පමණි

මෙම "නින්ද" ශ්‍රිතය ලිවීමට නව ජාවාස්ක්‍රිප්ට් විශේෂාංග දෙකක් උපකාරී විය:

අනුකූලතාව

ඔබ 7 (ළඟා කර ඇති වඩා පැරණි node එකක් මතම ඊට අදාල භාවිතා කරන්නේ අමුතු හේතුවක් නම් ජීවිතයේ අවසන් ), හෝ පැරණි බ්රව්සර ඉලක්ක කරන්නේ, async/ awaitතවමත් අනුසාරයෙන්ද භාවිතා කල හැක බාබෙල් (බව මෙවලමක් transpile සරල පැරණි JavaScript බවට JavaScript + නව අංග) , transform-async-to-generatorප්ලගිනය සමඟ .


5
නියම දේවල් මෙතන. ජේඑස් “නින්ද” ප්‍රකාරය ඇමතීමෙන් පසු මෙය නවීන බ්‍රව්සර් “සක්‍රීය” / “අක්‍රීය” තත්වයන්ට බලපාන්නේ කෙසේද? සාමාන්‍ය ජේඑස් සඳහා අපේක්ෂා කළ පරිදි බ්‍රව්සරයට නින්ද අවහිර කළ හැකිද, පසුව "ක්‍රියාකාරී" වූ විට නැවත මතක් කිරීම හෝ වෙනත් හැසිරීමක් තිබේද?
ඇන්ඩ්‍රේ කැනිල්හෝ

18
මේ සඳහා වත්මන් බ්‍රව්සර් සහාය කුමක්ද? මෙම විසඳුමට අතිමහත් බහුතරයක් බ්‍රව්සර් හෝ අවම වශයෙන් පොදු විසඳුම් සියල්ලම සහාය දෙන තුරු පෙර විසඳුම් “යල්පැන ඇති” යැයි මම නොසිතමි. ඊට පටහැනිව, මෙම විසඳුම පුළුල් සහයෝගයක් ලැබෙන තුරු සිත්ගන්නාසුළු නමුත් භාවිතා කළ නොහැකි / ප්‍රායෝගික නොවන බව මම සලකමි.
ඇල්වින් තොම්සන්

76
මෙය "සැබෑ නින්ද" නොවන අතර ප්‍රශ්නයට පිළිතුරු සපයන්නේ නැත. ඇසූ පුද්ගලයා stackoverflow.com/questions/758688/sleep-in-javascript සහ ඔහුගේ ප්‍රශ්නය අතර පැහැදිලි වෙනසක් කළේය. සැබෑ නින්දේ දී වෙනත් කේතයක් ක්‍රියාත්මක කළ නොහැක (වෙනත් ත්‍රෙඩ් එකක හැර). මෙම පිළිතුර අනෙක් ප්‍රශ්නයට හොඳයි.
niry

11
ireniry JavaScript, තනි නූල් භාෂාවක් වීම, “සැබෑ” නින්දට නොගැලපේ, මන්ද එය UI හා සමාන නූල් මත ධාවනය වන අතර ප්‍රතිචාර නොදක්වන වෙබ් පිටු ඇති කරයි.
පැට්‍රික් රොබට්ස්

5
At පැට්‍රික් රොබට්ස්, මම එකඟයි. කෙසේ වෙතත්, එය ඉතා පැහැදිලිව ප්‍රශ්නය විය .
niry

849

( 2016 සඳහා යාවත්කාලීන කළ පිළිතුර බලන්න )

මම හිතන්නේ ක්‍රියාවක් කිරීමට, බලා සිටීමට, පසුව තවත් ක්‍රියාවක් කිරීමට අවශ්‍ය වීම සාධාරණයි. ඔබ බහු-නූල් භාෂාවලින් ලිවීමට පුරුදු වී සිටින්නේ නම්, ඔබේ නූල් අවදි වන තෙක් නිශ්චිත කාලයක් සඳහා ක්‍රියාත්මක කිරීමේ අදහස ඔබට තිබිය හැකිය.

මෙහි ඇති ගැටළුව වන්නේ ජාවාස්ක්‍රිප්ට් යනු තනි නූල් සිදුවීම් පාදක කරගත් ආකෘතියකි. විශේෂිත අවස්ථාවකදී, මුළු එන්ජිම තත්පර කිහිපයක් රැඳී සිටීම සතුටක් විය හැකිය, පොදුවේ එය නරක පුරුද්දකි. මගේම දෑ ලිවීමේදී ඔබේ කාර්යයන් භාවිතා කිරීමට මට අවශ්‍ය යැයි සිතමු? මම ඔබේ ක්‍රමයට කතා කළ විට, මගේ ක්‍රම සියල්ලම කැටි වී යනු ඇත. ජාවාස්ක්‍රිප්ටයට කෙසේ හෝ ඔබේ ක්‍රියාකාරීත්වයේ සන්දර්භය ආරක්ෂා කර ගත හැකි නම්, එය කොහේ හෝ ගබඩා කර, පසුව එය නැවත ගෙනැවිත් පසුව ඉදිරියට ගෙන යා හැකි නම්, නින්ද සිදුවිය හැකිය, නමුත් එය මූලික වශයෙන් නූල් කිරීමකි.

එබැවින් ඔබ අනෙක් අය යෝජනා කර ඇති දේ සමඟ බොහෝ සෙයින් හිර වී ඇත - ඔබට ඔබේ කේතය බහුවිධ කාර්යයන් වලට බෙදීමට අවශ්‍ය වනු ඇත.

ඔබේ ප්‍රශ්නය ටිකක් වැරදි තේරීමක්. ඔබට අවශ්‍ය ආකාරයට නිදා ගැනීමට ක්‍රමයක් නැත, ඔබ යෝජනා කරන විසඳුම අනුගමනය නොකළ යුතුය.


45
මෙය කිසිසේත්ම නිවැරදි පිළිතුරක් නොවේ. ජාවාස්ක්‍රිප්ටයට නින්දේ ක්‍රියාකාරිත්වයක් නොමැති නම්, එය සිදුවන්නේ ECMAScript ට එය අවශ්‍ය නොවන බැවිනි. එය ජාවාස්ක්‍රිප්ට් නිර්මාණය සඳහා වගකිව යුතු ශරීරය විසින් තෝරාගත් තේරීමකි. ජාවාස්ක්‍රිප්ට් ධාවන කාලය ඊළඟ කේත පේළිය ධාවනය කිරීමට පෙර යම් කාලයක් බලා සිටින බව සිතිය හැකි නමුත් එය තෝරා නොගන්නා ලදි.
ඩිඩියර් ඒ.

5
ජාවාස්ක්‍රිප්ට් තුළ නින්දක් පරිපූර්ණ ලෙස ක්‍රියාත්මක කළ හැකි වුවද එය තත්‍ය කාලීන නිරවද්‍යතාවයකින් නොවේ. සියල්ලට පසු එය සිදුවීම් පදනම් කරගත් පද්ධතියකි. අසින්ක් ඇමතුම් සම්පුර්ණ වුවහොත් සිදුවීමක් අවුලුවන. නින්ද () නිකුත් කිරීමෙන් පසු නින්ද අවසන් වන තුරු බ්‍රව්සරයට පාලනය ලබා දී ඇමතුම් ශ්‍රිතයට නැවත පාලනයක් ලබා දෙන විට එය කළ නොහැකි වීමට හේතුවක් මට නොපෙනේ. ඔව්, සමහර විට නිදාගැනීම පහසු බව මම එකඟ වෙමි, විශේෂයෙන් ඔබ නිර්මාණකරුවන්ට පෙර නපුරු ලෙස හැසිරවීමට පෙර ඔබට කාලය නොමැති සම්පූර්ණයෙන්ම ප්‍රතිනිර්මාණය කිරීම හැර වෙනත් මාර්ගයක් නොමැත
ලෝරන්ස්

මෙම අදහස අනුගමනය කරන මෝහනය
Tezcat

4
ජාවාස්ක්‍රිප්ට් තනි නූල් ලෙස හැඳින්වීම මිථ්‍යාවකි. එය තාක්‍ෂණිකව නිවැරදි විය හැකි නමුත් ක්‍රියාකාරීව එය බහු තෙරපුම් භාෂාවක් ලෙස ක්‍රියා කරයි. දෙබලක () අනුකරණය කිරීම සුළුපටු පහසුය, අස්වැන්න () සැබවින්ම ක්‍රියාත්මක කළ නොහැකි වුවද, හවුල් මතකය අගුළු දැමීම / සෙමෆෝර් කිරීම මඟින් ඔබට සමීප විය හැකිය. සාමාන්‍ය ක්‍රමලේඛකයා සඳහා, එය බහු-නූල් ලෙස සැලකීම අර්ථවත් කරයි; තාක්ෂණික නාමය වැදගත් වන්නේ භාෂාවේ සංවර්ධකයින්ට පමණි.
බෙනුබර්ඩ්

8
sleep()JS හි එය කළ නොහැක්කේ මන්දැයි මම එකඟ වෙමි , බොහෝ විට දේවල් කිරීමට වඩා හොඳ ක්‍රම තිබේ. නමුත් එන්ජිම සෑම දෙයක්ම සම්බන්ධ කර ඇති ආකාරය නිර්මාණ දෝෂයක් ලෙස මම තවමත් සලකමි; sleep()එන්ජිම CPU සමඟ සම්බන්ධ නොවී උමතුවක් මෙන් යෙදුම කැටි කිරීමකින් තොරව භාෂාවට නිශ්චිත ස්ක්‍රිප්ටයකට, පිටුවකට හෝ ක්‍රියාකාරීත්වයකට සීමා කළ නොහැකි වීමට හේතුවක් නැත . එය 2015 වන අතර ඔබට සම්පූර්ණ වෙබ් බ්‍රව්සරයක්ම බිඳ දැමීමට නොහැකි විය යුතුය while(1). ඒ වගේ දේවල් සඳහා අපිට ෆ්ලෑෂ් තියෙනවා.
බීජෝර්

664

ජාවාස්ක්‍රිප්ට් හි, මම සෑම කාර්යයක්ම නැවත ලියන්නේ එවිට එය හැකි ඉක්මනින් අවසන් විය හැකිය. ඔබට බ්‍රව්සරය නැවත පාලනය කර ගැනීමට අවශ්‍ය වන අතර එමඟින් ඔබේ DOM වෙනස් කළ හැකිය.

මගේ ක්‍රියාකාරිත්වය මධ්‍යයේ මට නින්දක් අවශ්‍ය වූ සෑම අවස්ථාවකම මම එය භාවිතා කිරීම ප්‍රතික්ෂේප කළෙමි setTimeout().

සංස්කරණය කරන්න

කුප්‍රකට නින්ද නොහොත් ප්‍රමාදය ඕනෑම භාෂාවක් තුළ ක්‍රියාත්මක වීම බොහෝ විවාදයට භාජනය වේ. දී ඇති ක්‍රියාකාරිත්වයට වෙඩි තැබීම සඳහා සෑම විටම සං signal ාවක් හෝ ඇමතුමක් තිබිය යුතු යැයි සමහරු කියනු ඇත, තවත් සමහරු තර්ක කරනුයේ සමහර විට අත්තනෝමතික ප්‍රමාදයක් ප්‍රයෝජනවත් වනු ඇති බවයි. මම කියන්නේ එකිනෙකාට සහ එක් රීතියකට මෙම කර්මාන්තයේ කිසි විටෙකත් කිසිවක් නියම කළ නොහැකි බවයි.

නින්දේ ශ්‍රිතයක් ලිවීම සරල වන අතර එය ජාවාස්ක්‍රිප්ට් පොරොන්දු සමඟ වඩාත් ප්‍රයෝජනවත් වේ:

// 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
Ug ඉයුජීනියෝමිරේ කේතය වෙබ් පිටුවක භාවිතා කිරීමට අදහස් නොකරන්නේ නම්, ධාරකයේ වස්තු ආකෘතිය නින්ද ක්‍රමයක් ක්‍රියාත්මක කරන්න. - වෙබ් පිටුවල ක්‍රියාත්මක වන ජාවාස්ක්‍රිප්ට් වලට නිරාවරණය වන DOM වෙත ප්‍රශ්නය යොමු වී ඇතැයි මම සිතමි.
BrainSlugs83

31
Os නොස්රෙඩ්නා ඔව්, අසින්ක් ඇමතුම් ලබා ගන්නේ කෙසේදැයි අපට වැටහෙයි, මෙය අපට නිදා ගැනීමට උදව් නොකරයි (). මගේ ඇමතුම් නිශ්චිත අනුපිළිවෙලකට ගෙන ඒමට සහ දත්ත නැවත යම් අනුපිළිවෙලකට ලබා ගැනීමට මට අවශ්‍යය. මම ලූපයක් සඳහා මට්ටම් 5 ක් ගැඹුරුයි. මට අවහිර කිරීම ක්‍රියාත්මක කිරීමට අවශ්‍යයි. සැබෑ නින්ද ක්‍රමයක් “බ්‍රව්සරය මන්දගාමී නොකරයි”, නින්ද අත් නැවත බ්‍රව්සරයට පාලනය කරයි.
BrainSlugs83

382
මෙය ප්‍රශ්නයට පිළිතුරක් නොවේ.
ටීඑම්එස්

303

නිදොස් කිරීම / dev සඳහා පමණි , එය යමෙකුට ප්‍රයෝජනවත් නම් මම මෙය පළ කරමි

සිත්ගන්නාසුලු දේවල්, ෆයර්බග් (සහ බොහෝ විට වෙනත් ජේඑස් කොන්සෝල) තුළ, ඇතුල් වීමෙන් පසු කිසිවක් සිදු නොවේ, නියම කර ඇති නින්දේ කාලයෙන් පසුව පමණි (...)

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
මෙය පිළිතුරක් නොවේ. එය තරමක් කෙටි හැර, ප්‍රශ්නයේ කේතයට හරියටම සමාන වේ.
ජබ්

16
කාර්යබහුලයි, ඇත්තටම? JS හි? තත්පර ගණනක්? මෙය සිදු කරන වෙබ් අඩවියක් මා අල්ලා ගන්නේ නම්, එය අවහිර වනු ඇත.
මාෆු

35
@mafu ඒකයි ඒක කියන්නේ only for debug/dev... rollleyes
xDaizu

12
මෙය කිසි විටෙකත් නොකරන්න. මෙමඟින් CPU එය ක්‍රියාත්මක කරන හරයට 100% ක් පහර දෙන අතර එය අවහිර කරනු ඇත.
noego

3
විධාන රේඛා ජාවාස්ක්‍රිප්ට් යෙදුමක් තුළ මෙය ප්‍රයෝජනවත් වන අතර සමහර විට නිදා ගැනීමට ඇති එකම මාර්ගය වන්නේ අසින්ක් / බලා සිටීම ප්‍රයෝජනවත් නොවන බැවිනි.
වීසීල්

177

මම අනෙක් පෝස්ටර් සමඟ එකඟ වෙමි, කාර්යබහුල නින්දක් යනු නරක අදහසකි.

කෙසේ වෙතත්, setTimeout ක්‍රියාත්මක කිරීම නොපවතින අතර, එය කල් ඉකුත්වීමෙන් පසු නොව, වේලාව කල් ඉකුත් වූ විගසම, ශ්‍රිතයේ ඊළඟ පේළිය ක්‍රියාත්මක කරයි.

එය කළ හැකි ක්‍රමය නම් කොටස් වලට පෙර සහ පසු ඔබේ ක්‍රියාකාරිත්වය බිඳ දැමීමයි.

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
ඔව්. මෙය ව්‍යාකූල වන තැන වන්නේ ඔබට ලූපයක් හෝ කැදැලි ලූපයක් ඇති විටය. ඔබ ලූප සඳහා අතහැර දමා ඒ වෙනුවට කවුන්ටර තිබිය යුතුය.
නොස්රෙඩ්නා

ස්පර්ශ කරන්න. මම කිව්වේ, එය තවමත් හැකි වනු ඇත, නමුත් එම අවස්ථාවේ දී කැත සහ හාස්‍යජනක ය. ඔබට ස්ථිතික බූලියන් රාජ්‍ය විචල්‍යයන් කිහිපයක්ද භාවිතා කළ හැකිය, නමුත් එයද ඉතා අනර්ථකාරී ය.
ඩෙවින් බී

2
-1 මේ සඳහා. නැවතත්, මෙය ප්රශ්නයට පිළිතුරු සපයන්නේ නැත. මෙය "කේත ක්‍රියාත්මක කිරීම අවහිර කරන්නේ කෙසේද" යන්නට වඩා බෙහෙවින් වෙනස් වන "ශ්‍රිතයක් අසමමුහුර්තව ක්‍රියාත්මක කරන්නේ කෙසේද" වැනි ප්‍රශ්නයකට පිළිතුරකි.
දීපක් ජීඑම්

6
Os නොස්රෙඩ්නා නැත, ඔබ වසා දැමීමක් භාවිතා කරයි. උදාහරණයක් ලෙස: function foo(index) { setTimeout(function() { foo_continue(index); }, 10000); }සහ for(var X = 0; X < 3;X++) { foo(X); }- X හි අගය සම්මත වන අතර foo, එය අවසානයේ කැඳවූ indexවිට නම යටතේ නැවත භාවිතා foo_continueවේ.
ඉස්කාටා

2
Lex ඇලෙක්සැන්ඩර් ඇත්ත වශයෙන්ම එසේ වන්නේ, setTimeout () හි ලක්ෂ්‍යය වන්නේ කේතය සමමුහුර්තව ධාවනය කිරීමෙන් බ්‍රව්සරය අගුලු දැමීම වැළැක්වීමයි. සෙට් ටයිම out ට් අනුවාදයේ console.log()ඇතුළත තබන්න, foo_continue()ඔබට එකම ප්‍රති .ලය ලැබේ.
ඉස්කාටා

133

$ 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
ජාවාස්ක්‍රිප්ට් බ්‍රව්සරයට පමණක් සීමා වූ භාෂාවක් නොවන බව අප බොහෝ දෙනෙකුට අමතක විය හැකි යැයි මම සිතමි. මෙම මචන් සෙට් ටයිම out ට් සමඟ එන සියලුම විචල්‍ය විෂය පථය සමඟ කටයුතු කිරීමට අවශ්‍ය නොවී කෙටි විරාමයක් අවශ්‍ය වන නෝඩ් විධාන රේඛා උපයෝගීතාවයක් නිර්මාණය කරයි.
ෆිල් ලනාසා

3
H ෆිල්ලානාසා: සින්ටැක්ටික් වැසීම තවමත් කෙනෙකුට බිය වන්නේ නම්, යමෙකු බරපතල ලෙස බකල් කර 101 නෝඩ් හරහා වැඩ කළ යුතුය.
අවුල්සහගත

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
මෙය ජාවාට ඇමතුමක්ද?
කෙන් ෂාප්

16
මෙය ජාවා නොවේ ජාවාස්ක්‍රිප්ට්
රූසෝ

18
Ous රූසෝ ඇලෙක්සැන්ඩ්‍රේ වැරදිය. එය රයිනෝ භාවිතා කරන ජාවාස්ක්‍රිප්ට් ය (එකල එය මේ දිනවල
නෂෝර්න් හා

71

ඔබ 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');

4
එය නරක විසඳුමක් නොවේ. සන්දර්භය සහ දාමය පවත්වා ගනී.
නොස්රෙඩ්නා

39
JQuery 1.4 වන විට, jQuery හි .delay()කොටසකි (අර්ථ නිරූපණයන් සමඟ ඉහත ක්‍රියාත්මක කිරීමට වඩා වෙනස් වේ). api.jquery.com/delay
මැට් බෝල්

7
මෙම ප්‍රශ්නයට නියත වශයෙන්ම අඩුපාඩුවක් වූයේ jQuery පිළිතුරකි . අපට එය ලැබීම ගැන සතුටුයි!
xDaizu

1
ඔබට ස්වාධීන ඇමතුම් දෙකක් අතර ප්‍රමාදයක් අවශ්‍ය නම්, ඔව්. ලූපයක් මන්දගාමී කිරීමට ඔබට ප්‍රමාදයන් අවශ්‍ය නම්, නැත.
WGroleau

46

මම නින්දේ විසඳුම ද සෙව්වෙමි (නිෂ්පාදන කේතය සඳහා නොවේ, dev / test සඳහා පමණි) සහ මෙම ලිපිය හමු විය:

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

... සහ සේවාදායක පාර්ශවීය විසඳුම් සමඟ තවත් සබැඳියක් මෙන්න: http://www.devcheater.com/

එසේම, ඔබ අමතන විට alert(), ඔබේ කේතයද විරාමයක් වනු ඇත, අනතුරු ඇඟවීම පෙන්වන අතර - අනතුරු ඇඟවීම ප්‍රදර්ශනය නොකිරීමට ක්‍රමයක් සොයා ගත යුතු නමුත් එකම බලපෑමක් ලබා ගත යුතුය. :)


35
මම එකඟ වෙමි, බොහෝ දෙනෙක් පවසන්නේ "නැත, නිෂ්පාදන කේතයෙන් මෙය නොකරන්න!" ඔව්, මට අවශ්‍ය නැහැ. විසි කිරීමේ පරීක්ෂණ කේතයෙන් මට එය කිරීමට අවශ්‍ය වන අතර, එහි ප්‍රති a ලයක් ලෙස අලංකාර විසඳුමක් සෑදීම සඳහා වැඩි කාලයක් ගත කිරීමට මට අවශ්‍ය නැත.
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);
}

sleep.php හි අන්තර්ගතය:

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

දැන් එය සමඟ අමතන්න: නින්ද (5);


5
@lukad, setTimeout()එය ක්‍රියාත්මක වන්නේ නම් භාවිතා කරන්න , නමුත් එසේ කිරීමෙන් අදහස් කරන්නේ ඇමතුම් 1000 ක් මුදා හැරීම විහිළුවක් සේ පෙනෙන්නට පටන් ගැනීමයි.
pguardiario

11
අද්විතීය ප්‍රවේශය, අවාසනාවකට මෙන් අසමමුහුර්ත නොවන XMLHttpRequests ඉවත් කර ඇති අතර අනාගතයේදී එය ඉවත් කරනු ලැබේ. එය විහිළුවක්, මන්ද එම කාරණය නිසා මෙම ප්‍රශ්නයට මා මුලින් ම යොමු විය.
බීජෝර්

මෙය ඇත්ත වශයෙන්ම හොඳ අදහසක් වන IMO. නින්ද API (ඉල්ලීම් URL) අනිසි ලෙස භාවිතා කළ හැකි බැවින් එය පොදු විය යුතු යැයි මම නොසිතමි.
වහීඩ් අමිරි

E බීජෝර් සැමවිටම අනාගතය ගැන පමණක් සිතීම යනු අනාගත අක්‍රමිකතාවයෙන් ජීවත්වීමයි :-)
user1742529

හොඳයි, නමුත් ඔබ දන්නවාද යම් වේලාවක අන්තර්ජාලය මන්දගාමීද නැතිනම් වෙබ් අඩවි පිං කාලය වැඩි නම් එය තර්ක කාලයට වඩා ස්ක්‍රිප්ට් නිදා ගනීවි. හරියට ඔබ භාවිතා කරන්නේ නම් sleep(300)සහ වෙබ් අඩවිය ජාවාස්ක්‍රිප්ට් කේතයට වඩා ප්‍රතිචාර දැක්වීම සඳහා එම්එස් 150 එම්එස් 450m සඳහා නිදා ගනී. බ්‍රව්සරයෙන් අන්තර්ජාල සම්බන්ධතාවය නැති වුවහොත් එය ක්‍රියාත්මක වන්නේ 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
එය මූලික වශයෙන් OP ට සමාන දෙයකි.
ඇන්ඩ rew බාබර්

5
වඩාත් නිවැරදිව කිවහොත්, OP විසින් විකල්පයක් ඉල්ලා සිටියේ එයයි.
WGroleau

විසඳුම හොඳ නැත, නමුත් සමහර ස්ථානවල async/awaitඑය අවාසනාවකට ප්‍රතිචාර නොදක්වන අතර අපට එය අනිවාර්යයෙන් භාවිතා කළ යුතුය.
නබි KAZ

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
මෙය ප්‍රධාන ප්‍රශ්නයේ වඩාත්ම ප්‍රශස්ත අනුවාදය ලෙස මම දකිමි: එය ලූපය තුළ කිසිදු ගණිතයක් නොකරයි, සරල සංසන්දනයක් පමණි. තෝ කියවීම ටිකක් අමාරුයි.
hegez

4
කවදාවත් එහෙම කරන්න එපා. මෙම ශ්‍රිතය ක්‍රියාත්මක වන අතරතුර ඔබ CPU භාවිතය පරීක්ෂා කර තිබේද? ඔබ ඒ සඳහා ප්‍රමාණවත් කාලයක් ලබා දෙන්නේ නම් එය 100% ට ආසන්න විය යුතුය.
noego

2
ghegez: ලූපය නිශ්චිත වේලාවක් බිත්ති ඔරලෝසු වේලාවක් සඳහා ධාවනය වන බැවින් කුමක් වුවත්, ලූපය ප්‍රශස්තිකරණය කිරීම ලක්ෂ්‍යයට අමතරව බව පෙනේ.
ෂැඩෝ රේන්ජර්

කොහොමද? මම දැන් නෝඩ් 10 හි අත්හදා බැලුවෙමි, මට කිසිසේත් CPU භාවිත වෙනසක් නොමැත
melMass

@melMass මෙම ක්‍රියාව මඟින් CPU 100% කාර්යබහුල වීමෙන් තත්පර n ක් සඳහා නෝඩ් නූල් අවහිර කරයි. මෙම "විසඳුම" එම හේතු දෙක සඳහා අතිශය නරක අදහසකි (අවහිර කිරීම + CPU ler ාතකයා). බලා සිටීම අවහිර නොවන, එබැවින් අසමමුහුර්ත වේ.
ජෙරමි තිල්

20

පලමු:

ඔබට මේ ආකාරයට ක්‍රියාත්මක කිරීමට අවශ්‍ය ශ්‍රිතයක් නිර්වචනය කරන්න:

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

ඉන්පසු එය ක්‍රියාත්මක කිරීම setTimeout ක්‍රමය සමඟ උපලේඛනගත කරන්න:

setTimeout(alertWorld,1000)

කරුණු දෙකක් සටහන් කරන්න

  • දෙවන තර්කය මිලි තත්පර වලින් කාලයයි
  • පළමු තර්කයක් ලෙස වරහන් නොමැතිව, ශ්‍රිතයේ නම (යොමුව) පමණක් සම්මත කළ යුතුය

19

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

ඔබගේ ඇමතුම් කාර්යය අසමමුහුර්ත බවට වග බලා ගන්න

සත්‍යාපනය සහ හොඳින් වැඩ කිරීම


1
අවසාන. එකම සහ එකම පිළිතුර.
ජෙරමි තිල්

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

ඔබට අවශ්‍ය දේ කරන දෙයකට ඔබ ළඟම ඇති ආසන්නතම අවස්ථාව මෙය විය හැකිය.

සටහන, ඔබට බහු නින්දක් අවශ්‍ය නම් මෙය කඩිමුඩියේ කැත විය හැකි අතර ඔබේ සැලසුම ගැන නැවත සිතා බැලිය යුතුය.


ඩෙස්ක්ටොප් බ්‍රව්සර් සහ පැරණි ජංගම දුරකථනයක මා වෙනුවෙන් වැඩ කළේ මෙයයි. මම උත්සාහ කළ අනෙක් ඒවා සියල්ලම ක්‍රියාත්මක වූයේ නැත.
මයික්

10

බ්‍රව්සර් සඳහා, setTimeout සහ setInterval යන්නට මාර්ගය බව මම එකඟ වෙමි.

නමුත් සේවාදායක පාර්ශවීය කේතය සඳහා, එය අවහිර කිරීමේ ශ්‍රිතයක් අවශ්‍ය විය හැකිය (නිදසුනක් ලෙස, ඔබට thread ලදායී ලෙස නූල් සමමුහුර්තකරණය කළ හැකිය).

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


Server may require a blocking function... නෝඩ්ගේ එකම ත්‍රෙඩ් එක කොතරම් බලහත්කාරයෙන් අවහිර කර තත්පර කිහිපයක් සඳහා ඔබේ මුළු සේවාදායකයම ප්‍රතිචාර නොදැක්වීම හොඳ අදහසක්, නමුත් කුමක් වුවත්
ජෙරමි තිල්

10

දී Demo: මම අනෙකුත් අසමමිතික කර්තව්යයන් සමග කේතය, ස්ථාවර සඳහා පොරොන්දුව දී setTimeOut සාරාංශගත ඇත වීණාවක්

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

ඒ ආකාරයට භාවිතා වේ:

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

ඔබ පොරොන්දු භාවිතා කළේ නම් සින්ටැක්ස් මතක තබා ගැනීම පහසුය.


4
SetTimeout (ශ්‍රිතය () {/ * යමක් කරන්න * /}, 2000) භාවිතා කිරීමට වඩා මෙය හොඳ ඇයි?
JSideris

10

2019 Atomics.night භාවිතා කර යාවත්කාලීන කරන්න

නෝඩ් 9.3 හෝ ඊට වැඩි වැඩ කළ යුතුය.

මට Node.js හි ඉතා නිවැරදි ටයිමරයක් අවශ්‍ය වූ අතර එය ඒ සඳහා විශිෂ්ට ලෙස ක්‍රියා කරයි. කෙසේ වෙතත් බ්‍රව්සර්වල අතිශය සීමිත සහයෝගයක් ඇති බව පෙනේ.

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

තත්පර 10 ක ටයිමර් මිණුම් සලකුණු කිහිපයක් ධාවනය කරන්න.

SetTimeout සමඟ මට මයික්‍රෝ තත්පර 7000 ක් දක්වා දෝෂයක් ලැබේ. (මීටර් 7)

පරමාණුක විද්‍යාව සමඟ මගේ දෝෂය මයික්‍රෝ තත්පර 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){}
%>

මගේ මතය අනුව, පිළිගත් විසඳුමට වඩා හොඳ ඇමතුමකින් අසමමුහුර්ත නොවී / සරල කාර්යයක් ලෙස ක්‍රියාත්මක කළ නොහැක.
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);

මෙම නින්ද අනුකරණය කිරීම සැබෑ නින්දේ ක්‍රියාකාරිත්වයට වඩා වෙනස් වන්නේ එය නූල් අවහිර නොකරන බැවිනි. එය හුදෙක් javascript හි වර්තමාන setTimeout ශ්‍රිතයට ඉහළින් ඇති සීනි වේ. මෙම ක්‍රියාකාරීත්ව වර්ගය Task.js හි ක්‍රියාත්මක කර ඇති අතර එය අද ෆයර්ෆොක්ස් හි ක්‍රියාත්මක විය යුතුය.


අවම වශයෙන් 10 වන අනුවාදය හරහා කම්කරුවන් IE තුළ ක්‍රියාත්මක නොවේ. දැනට විශාල පරිශීලකයින් ප්‍රමාණයක් නියෝජනය කරයි.
බීජෝර්

sleepබහු කම්කරුවන් භාවිතා කරමින් ක්‍රියාත්මක කිරීම ප්‍රායෝගික නොවේ . Node.js භාවිතා කරන්නේ නම් උත්පාදක කාර්යයන් දැනටමත් ක්‍රියාත්මක කර ඇති අතර විස්තර කර ඇති පරිදි භාවිතා කළ හැකිය. ප්‍රධාන ධාරාවේ බ්‍රව්සර් අද වන විට සියලුම ජනක යන්ත්‍ර ක්‍රියාත්මක කර නොමැත.
ගේබ්‍රියෙල් රැටනර්

8

මම ජාවාස්ක්‍රිප්ට් නින්ද / රැඳී සිටීම පිළිබඳ වෙබ් පිටු කිහිපයක් සෙව්වා / ගූගල් කර ඇත ... තවද ඔබට ජාවාස්ක්‍රිප්ට් "RUN, DELAY, RUN" කිරීමට අවශ්‍ය නම් පිළිතුරක් නොමැත ... බොහෝ දෙනෙකුට ලැබී ඇත්තේ "RUN, RUN (නිෂ් less ලයි දේවල්), 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>

// .................................... // උදාහරණ 2:

<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
හරි, මෙය setTimeput සමඟ ක්‍රියා කරයි, නමුත් සිදුවන්නේ කුමක්දැයි බැලීමට අපහසුය. SetTimeout භාවිතා කිරීම මෙයට වඩා පහසුය.
naugtur

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 හි ක්‍රියා නොකරයි. ඊතල ක්‍රියාකාරිත්වය සඳහා අපට සින්ටැක්ස් දෝෂයක් ලැබේ.
DDphp

@ ජාවා-ඩීකේ භාවිතයawait new Promise(function(resolve) { setTimeout(resolve, 5000); });
k06a

6

ඔබට ජාවාස්ක්‍රිප්ට් හි එවැනි නින්දක් කළ නොහැක, නැතහොත්, එසේ නොකළ යුතුය. නින්දක් හෝ ටික වේලාවක් ධාවනය කිරීමෙන් පරිශීලකයාගේ බ්‍රව්සරය ලූපය සිදු වන තුරු ක්‍රියාත්මක වේ.

ඔබ සඳහන් කළ සබැඳියේ දක්වා ඇති පරිදි ටයිමරයක් භාවිතා කරන්න.


6

SetTimeout () භාවිතා කරනවාට වඩා ඔබට නින්ද () ශ්‍රිතයක් අවශ්‍ය විය හැකි එක් අවස්ථාවක් නම්, පරිශීලක ක්ලික් කිරීමකට ප්‍රතිචාර දක්වන ශ්‍රිතයක් ඔබට තිබේ නම් එය අවසානයේදී නව එනම් උත්පතන කවුළුවක් විවෘත වන අතර කෙටි කාලයක් අවශ්‍ය වන සමහර සැකසුම් ආරම්භ කර ඇත. උත්පතන දර්ශණය වීමට පෙර සම්පූර්ණ කිරීමට. විවෘත කවුළුව වසා දැමීමකට ගෙනයාම යන්නෙන් අදහස් කරන්නේ එය සාමාන්‍යයෙන් බ්‍රව්සරය විසින් අවහිර කරනු ඇති බවයි.


6

ඔබට සමමුහුර්තව ක්‍රියාත්මක කිරීම සමඟ කටයුතු කිරීමට සිදුවුවහොත් නින්දේ ක්‍රියාකාරිත්වයේ අරමුණ මට තේරුම් ගත හැකිය. SetInterval සහ setTimeout ශ්‍රිතයන් සමාන්තර ක්‍රියාත්මක කිරීමේ නූලක් නිර්මාණය කරන අතර එය ක්‍රියාත්මක කිරීමේ අනුක්‍රමය ප්‍රධාන වැඩසටහනට නැවත ලබා දෙයි, ඔබට ලබා දී ඇති ප්‍රති .ලයක් සඳහා බලා සිටීමට සිදුවුවහොත් එය අකාර්යක්ෂම වේ. ඇත්ත වශයෙන්ම යමෙකුට සිදුවීම් සහ හසුරුවන්නන් භාවිතා කළ හැකිය, නමුත් සමහර අවස්ථාවලදී අදහස් කරන්නේ එය නොවේ.


6

මගේ බිටු දෙක එකතු කිරීම. පරීක්ෂණ අරමුණු සඳහා මට කාර්යබහුල කාලයක් බලා සිටීමට අවශ්‍ය විය. කේතය බෙදීමට මට අවශ්‍ය නොවූයේ එය බොහෝ වැඩක් වනු ඇති නිසාය.

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

මෙය සිදු කිරීමේ කිසිදු අවාසියක් මා නොදකින අතර එය මට උපක්‍රමයක් විය.


එය සම්පාදනය කළ හැකිය.
වික්ටර් සේර්

කරුණාකර එය මේ ආකාරයෙන් නොකරන්න. මෙය අවහිර කරන නින්ද ඇමතුමකි, එයින් අදහස් වන්නේ ඔබේ කේතය JS නූල් රැහැන්ගත කරන අතරතුර වෙනත් ජාවාස්ක්‍රිප්ට් ධාවනය කළ නොහැකි බවයි.
ස්ටීව් මිඩ්ග්ලි

5
Te ස්ටීව්මිඩ්ග්ලි "ඔබේ කේතය ජේඑස් නූල් එක ගසාගෙන යන අතරතුර වෙනත් ජාවාස්ක්‍රිප්ට් එකක් ධාවනය කිරීමට නොහැකි වීම" මට පෙනෙන ආකාරයට OP කිරීමට අවශ්‍ය වන්නේ හරියටම ¯_ (ツ) _ / ¯
drigoangelo

1
මම දැන් පරීක්ෂණ කිහිපයක් පවත්වා ඇති අතර හිස් පුඩුවක් පවා බ්‍රව්සරය සහ CPU අවහිර කරනු ඇත (ජාවාස්ක්‍රිප්ට් පමණක් නොවේ). forඋපරිම අගය නොතකා i, සංකීර්ණ ගණිත කේතයක් ඇතුළත තබා තිබියදීත්, ලූප භාවිතා කිරීම සෑම විටම පාහේ ක්‍රියාත්මක වේ. එබැවින් ඔබ මිලි තත්පර කිහිපයක් පමණක් බලා සිටියහොත් මිස, ජේඑස් හි සුන්දර ලෙස නිදා ගැනීමට ක්‍රමයක් නොමැති බව පෙනේ.
බීජෝර්

මිලියනයක් වැඩියි. මට ප්‍රමාණවත් 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" />

එවිට, ඔබේ JS හි වේදනා රහිත විරාමයක් අවශ්‍ය විට ඔබ කළ යුත්තේ:

java.lang.Thread.sleep(xxx)

Xxx කාලය මිලි තත්පර වලින් වේ. මගේ නඩුවේදී (යුක්ති සහගත කිරීම අනුව), මෙය ඉතා කුඩා සමාගමක පසු-ඇණවුම් ඉටුකිරීමේ කොටසක් වූ අතර මට සේවාදායකයෙන් පැටවිය යුතු ඉන්වොයිසියක් මුද්‍රණය කිරීමට අවශ්‍ය විය. මම එය කළේ ඉන්වොයිසිය (වෙබ් පිටුවක් ලෙස) iFrame එකකට පටවා iFrame මුද්‍රණය කිරීමෙනි. ඇත්ත වශයෙන්ම, මුද්‍රණය කිරීමට පෙර පිටුව සම්පුර්ණයෙන්ම පටවන තුරු මට බලා සිටීමට සිදු විය, එබැවින් JS ට විරාමයක් යෙදීමට සිදුවිය. ඉන්වොයිස් පිටුව (අයිෆ්‍රේම් හි) මව් පිටුවේ සැඟවුණු පෝරම ක්ෂේත්‍රයක් ඔන්ලෝඩ් සිදුවීම සමඟ වෙනස් කිරීමෙන් මම මෙය සිදු කළෙමි. ඉන්වොයිසිය මුද්‍රණය කිරීම සඳහා මව් පිටුවේ ඇති කේතය මේ ආකාරයෙන් පෙනේ (පැහැදිලිකිරීම සඳහා අදාළ නොවන කොටස් කපා ඇත):

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
මෙය අවලංගු කරන ලද ජාවා ඇපල්ට්ස් මත රඳා පවතී.
වහීඩ් අමිරි

6

බොහෝ පිළිතුරු (කෙලින්ම) ප්‍රශ්නයට පිළිතුරු නොදෙන අතර මෙයද පිළිතුරු දෙන්නේ නැත ...

මෙන්න මගේ ශත දෙක (හෝ කාර්යයන්):

ඔබ ට වඩා අඩු clunky කාර්යයන් අවශ්ය නම් 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

ලූපයක් මඟින් ක්‍රියාත්මක වන ඇමතුම් සමූහයක් ඉවත් කිරීමට අවශ්‍ය විශේෂිත අවස්ථාව සඳහා, ඔබට පහත කේතය වැනි දෙයක් මූලාකෘති සමඟ භාවිතා කළ හැකිය. මූලාකෘතියකින් තොරව, ඔබට ප්‍රමාද ශ්‍රිතය 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)
}

5

ඔබ node.js හි සිටී නම්, ඔබට තන්තු දෙස බැලිය හැකිය - නෝඩ් වෙත ස්වදේශික සී දිගුවක්, තරමක් බහු-නූල් අනුකරණය.

එය 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');

- සහ ප්‍රති results ල:

$ 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)
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.