Méthode personnalisée en js pour implémenter le sommeil pendant quelques secondes_javascript techniques

Il n'y a pas de méthode sleep intégrée dans js. Si vous voulez dormir, vous devez définir vous-même une méthode

function sleep(numberMillis) { 
var now = new Date(); 
var exitTime = now.getTime() + numberMillis; 
while (true) { 
now = new Date(); 
if (now.getTime() > exitTime) 
return; 
} 
}

Ce qui suit est un supplément :

En plus de Narrative JS, jwacs (Javascript With Advanced Continuation Support) s'engage également à étendre la syntaxe JavaScript pour éviter d'écrire des fonctions de rappel gênantes pour les appels asynchrones. Sleep implémenté à l'aide de jwacs, le code est le suivant :

Copier le code Le code est le suivant :

fonction sommeil (msec) {
var k = function_continuation;
setTimeout(function() { reprendre k <- mesc; }, msec);
suspendre ;
>

Cette syntaxe est encore plus effrayante, et c'est aussi un nom de méthode de thread qui n'est pas recommandé en Java. Franchement, je préfère Narrative JS.

Comme Narrative JS, jwacs doit également être précompilé et le précompilateur est écrit en langage LISP. Il s'agit également actuellement d'une version Alpha. Pour plus d'introduction et de comparaison entre les deux, veuillez vous référer au nouvel article sur SitePoint : Éliminer les rappels Javascript asynchrones par prétraitement

Lors de l'écriture de scripts JavaScript complexes, il est parfois nécessaire que le script se bloque pendant une période de temps spécifiée, similaire à l'effet obtenu par Thread.sleep en Java ou la commande sleep dans les scripts sh.

Comme nous le savons tous, JavaScript ne fournit pas de fonctions de contrôle de thread similaires à Java. Bien qu'il existe deux méthodes, setTimeout et setInterval, qui peuvent effectuer un certain contrôle d'exécution du timing, elles ne peuvent pas répondre à toutes les exigences. Depuis longtemps, beaucoup de gens se demandent comment implémenter sleep/pause/wait en JavaScript, et il existe effectivement des solutions merdiques :

Le plus simple et le pire est d'écrire une boucle, le code peut être le suivant :

Copier le code Le code est le suivant :

fonction sommeil (numéroMillis) {
var maintenant = new Date();
var exitTime = now.getTime() numberMillis;
tandis que (vrai) {
        maintenant = nouvelle date();
Si (now.getTime() > exitTime)
             revenir ;
>
>

Le code ci-dessus ne provoque pas réellement la mise en veille de l'interpréteur de script, mais a pour effet secondaire de mettre rapidement le processeur sous une charge élevée. Le navigateur peut même rester en animation suspendue pendant cette période.

Deuxièmement, il y a des gens intelligents qui utilisent l'implémentation spéciale de la boîte de dialogue d'IE pour trouver une issue. Le code peut être le suivant :

.

Copier le code Le code est le suivant :

fonction sleep(timeout) {
window.showModalDialog("javascript:document.writeln('<script>window.setTimeout(function () { window.close(); }, " timeout ");</script>');");
}window.alert("avant de dormir...");
dormir(2000);
window.alert("après avoir dormi...");

Inutile de dire que l'inconvénient est qu'il n'est pris en charge que par IE (IE7 ne peut pas atteindre son objectif en raison de restrictions de sécurité).

En plus de ce qui précède, il existe également des idées astucieuses telles que l'utilisation d'Applet ou l'appel de WScript.Sleep() de Windows Script Host. Ce sont tous des expédients de dernier recours.

Enfin, des personnes plus intelligentes ont développé ce qui pourrait être la meilleure solution. Examinons d'abord le code :

Copier le code Le code est le suivant :

fonction sommeil (millis) {
var notifier = NjsRuntime.createNotifier();
setTimeout(notifier, millis);
Notifier.wait->();
>

Oui, voir une syntaxe comme ->() est aussi choquant pour moi que de simplement voir la fonction $() de Prototype. Cependant, ce script signalera une erreur de syntaxe directement dans le navigateur. En effet, ils doivent être précompilés en JavaScript reconnu par le navigateur client. Le script compilé est le suivant :

Copier le code Le code est le suivant :

function sleep(millis){
var njf1 = njen(this,arguments,"millis");
nj:while(1) {
try{switch(njf1.cp) {
case 0:njf1._notifier=NjsRuntime.createNotifier();
setTimeout(njf1._notifier,njf1._millis);
njf1.cp = 1;
njf1._notifier.wait(njf1);
return;
case 1:break nj;
}} catch(ex) {
if(!njf1.except(ex,1))
return;
}}
njf1.pf();
}

我看不懂，也不想去看懂了。这些工作全部会由 Narrative JavaScript ———— 一个提供异步阻塞功能的JS扩展帮我们实现。我们只需要编写之前那个怪异的 ->() 语法， 然后通过后台预先静态编译或者前台动态编译后执行就可以实现 sleep 的效果。
Narrative JavaScript 宣称可以让你从头昏眼花的回调函数中解脱出来，编写清晰的Long Running Tasks。目前还是 alpha 的版本，在 Example 页面上有一个移动的按钮的范例。首页上也提供了源码下载。以我薄弱的基础知识，我只能勉强的看出代码中模拟了状态机的实现，希望有精通算法的朋友能为我们解析。
最后，还是我一直以来的观点： 除非很必要，否则请保持JavaScript的简单。在JavaScript 能提供原生的线程支持之前，或许我们可以改变设计以避免异步阻塞的应用。

有bug的曲折实现

<script type"text/javascript">
/*Javascript中暂停功能的实现
Javascript本身没有暂停功能（sleep不能使用）同时 vbscript也不能使用doEvents，故编写此函数实现此功能。
javascript作为弱对象语言，一个函数也可以作为一个对象使用。
比如：

[code]
function Test(){
 alert("hellow");
 this.NextStep=function(){
 alert("NextStep");
 }
}
我们可以这样调用 var myTest=new Test();myTest.NextStep();
我们做暂停的时候可以吧一个函数分为两部分，暂停操作前的不变，把要在暂停后执行的代码放在this.NextStep中。
为了控制暂停和继续，我们需要编写两个函数来分别实现暂停和继续功能。
暂停函数如下：
*/
function Pause(obj,iMinSecond){
 if (window.eventList==null) window.eventList=new Array();
 var ind=-1;
 for (var i=0;i<window.eventList.length;i++){
 if (window.eventList[i]==null) {
  window.eventList[i]=obj;
  ind=i;
  break;
 }
 }
 
 if (ind==-1){
 ind=window.eventList.length;
 window.eventList[ind]=obj;
 }
 setTimeout("GoOn(" + ind + ")",1000);
}
/*
该函数把要暂停的函数放到数组window.eventList里，同时通过setTimeout来调用继续函数。
继续函数如下：
*/

function GoOn(ind){
 var obj=window.eventList[ind];
 window.eventList[ind]=null;
 if (obj.NextStep) obj.NextStep();
 else obj();
}
/*
该函数调用被暂停的函数的NextStep方法，如果没有这个方法则重新调用该函数。
函数编写完毕，我们可以作如下册是：
*/
function Test(){
 alert("hellow");
 Pause(this,1000);//调用暂停函数
 this.NextStep=function(){
 alert("NextStep");
 }
}
</script>