Désactivation du message de script de longue durée dans Internet Explorer

Question

J'ai une fonction JavaScript qui contient une boucle for qui itère tant de fois.
Après avoir appelé cette fonction, le navigateur IE affiche le message suivant:

N'exécutez plus ce script?
Un script sur cette page ralentit votre navigateur Web. S'il continue à fonctionner, votre ordinateur risque de ne plus répondre.

Comment puis-je réparer cela?
est-ce que je peux quand même désactiver ce message d'IE?

Answer 1

Ce message s'affiche lorsque Internet Explorer a atteint le nombre maximum de synchrone instructions pour un morceau de code JavaScript. La valeur maximale par défaut est de 5 000 000 d'instructions, vous pouvez augmenter ce nombre sur une seule machine par la modification du registre.

Internet Explorer enregistre le nombre total d'exécution des instructions de script et réinitialise la valeur à chaque fois qu'une nouvelle exécution du script est lancé, comme un délai d'attente ou d'un gestionnaire d'événements, pour la page en cours avec le moteur de script. Internet Explorer affiche un "script de longue durée" de la boîte de dialogue lorsque cette valeur dépasse un certain seuil.

La seule façon de résoudre le problème pour tous les utilisateurs qui pourraient être de l'affichage de votre page est de casser le nombre d'itérations de la boucle effectue à l'aide de chronomètres, ou de refactoriser le code pour qu'il n'en a pas besoin, comme de nombreuses instructions.

La rupture d'une boucle avec des temps est relativement simple:

var i=0;
(function () {
    for (; i < 6000000; i++) {
        /*
            Normal processing here
        */

        // Every 100,000 iterations, take a break
        if ( i > 0 && i % 100000 == 0) {
            // Manually increment `i` because we break
            i++;
            // Set a timer for the next iteration 
            window.setTimeout(arguments.callee);
            break;
        }
    }
})();

Answer 2

Le script ne répond pas de la boîte de dialogue s'affiche lorsque javascript thread prend trop de temps, trop complet. La modification du registre pourrait fonctionner, mais vous auriez à le faire sur tous les ordinateurs client. Vous pouvez utiliser un "récursive fermeture" comme suit pour résoudre le problème. C'est juste une structure de codage dans lequel vous permet de prendre une longue course pour la boucle et la transformer en quelque chose qui ne peu de travail, et de garder une trace là où il a laissé, ce qui donne à l'explorateur, puis continuer là où il l'avait laissé jusqu'à ce que nous avons fini.

La Figure 1, Ajouter cette Classe Utilitaire RepeatingOperation à votre fichier javascript. Vous n'aurez pas besoin de modifier ce code:

RepeatingOperation = function(op, yieldEveryIteration) {

  //keeps count of how many times we have run heavytask() 
  //before we need to temporally check back with the browser.
  var count = 0;   

  this.step = function() {

    //Each time we run heavytask(), increment the count. When count
    //is bigger than the yieldEveryIteration limit, pass control back 
    //to browser and instruct the browser to immediately call op() so
    //we can pick up where we left off.  Repeat until we are done.
    if (++count >= yieldEveryIteration) {
      count = 0;

      //pass control back to the browser, and in 1 millisecond, 
      //have the browser call the op() function.  
      setTimeout(function() { op(); }, 1, [])

      //The following return statement halts this thread, it gives 
      //the browser a sigh of relief, your long-running javascript
      //loop has ended (even though technically we havn't yet).
      //The browser decides there is no need to alarm the user of
      //an unresponsive javascript process.
      return;
      }
    op();
  };
};

La Figure 2, Le code suivant représente votre code qui est à l'origine de la "arrêter l'exécution de ce script de dialogue", parce que ça prend autant de temps pour terminer:

process10000HeavyTasks = function() {
  var len = 10000;  
  for (var i = len - 1; i >= 0; i--) {
    heavytask();   //heavytask() can be run about 20  times before
                   //an 'unresponsive script' dialog appears.
                   //If heavytask() is run more than 20 times in one
                   //javascript thread, the browser informs the user that
                   //an unresponsive script needs to be dealt with.  

                   //This is where we need to terminate this long running
                   //thread, instruct the browser not to panic on an unresponsive
                   //script, and tell it to call us right back to pick up
                   //where we left off.
  }
}

Figure 3. Le code suivant est le correctif de la problématique de code dans la Figure 2. Avis de la boucle for est remplacé par un appel récursif à la fermeture qui repasse le contrôle du navigateur toutes les 10 itérations de heavytask()

process10000HeavyTasks = function() {

  var global_i = 10000; //initialize your 'for loop stepper' (i) here.

  var repeater = new this.RepeatingOperation(function() {

    heavytask();

    if (--global_i >= 0){     //Your for loop conditional goes here.
      repeater.step();        //while we still have items to process,
                              //run the next iteration of the loop.
    }
    else {
       alert("we are done");  //when this line runs, the for loop is complete.
    }
  }, 10);                   //10 means process 10 heavytask(), then
                            //yield back to the browser, and have the
                            //browser call us right back.

  repeater.step();          //this command kicks off the recursive closure.

};

Adapté à partir de cette source:

http://www.picnet.com.au/blogs/Guido/post/2010/03/04/How-to-prevent-Stop-running-this-script-message-in-browsers

Answer 3

Je ne peux pas commenter sur les réponses précédentes, puisque je n'ai pas essayé. Cependant je sais que la stratégie suivante fonctionne pour moi. Il est un peu moins élégant, mais fait le travail. Il ne nécessite pas de casser le code en morceaux comme certaines autres approches semblent le faire. Dans mon cas, ce n'était pas une option, parce que mon code a des appels récursifs à la logique qui a été bouclée; c'est à dire, il n'y avait aucun moyen de le hop dehors de la boucle, puis être en mesure de reprendre, d'une certaine façon en utilisant les variables globales pour préserver l'état actuel puisque ces variables globales pourraient être modifiées par des références dans l'un des prochains recursed appel. J'ai donc besoin d'un straight-forward manière à ne pas constituer une chance pour le code à compromettre les données de l'état de l'intégrité.

En supposant que la "arrêter le script?" dialogue est à venir au cours d'une boucle for() executuion après un nombre d'itérations (dans mon cas, environ 8-10), et de déconner avec le registre n'est pas une option, voici la correction (pour moi, de toute façon):

var anarray = [];
var array_member = null;
var counter = 0; // Could also be initialized to the max desired value you want, if
                 // planning on counting downward.

function func_a()
{
 // some code
 // optionally, set 'counter' to some desired value.
 ...
 anarray = { populate array with objects to be processed that would have been
             processed by a for() }
 // 'anarry' is going to be reduced in size iteratively.  Therefore, if you need
 //  to maintain an orig. copy of it, create one, something like 'anarraycopy'.
 //  If you need only a shallow copy, use 'anarraycopy = anarray.slice(0);'
 //  A deep copy, depending on what kind of objects you have in the array, may be
 //  necessary.  The strategy for a deep copy will vary and is not discussed here.
 //  If you need merely to record the array's orig. size, set a local or
 //  global var equal to 'anarray.length;', depending on your needs.
 // - or -
 // plan to use 'counter' as if it was 'i' in a for(), as in
 // for(i=0; i < x; i++ {...}

   ...

   // Using 50 for example only.  Could be 100, etc. Good practice is to pick something
   // other than 0 due to Javascript engine processing; a 0 value is all but useless
   // since it takes time for Javascript to do anything. 50 seems to be good value to
   // use. It could be though that what value to use does  depend on how much time it
   // takes the code in func_c() to execute, so some profiling and knowing what the 
   // most likely deployed user base is going to be using might help. At the same 
   // time, this may make no difference.  Not entirely sure myself.  Also, 
   // using "'func_b()'" instead of just "func_b()" is critical.  I've found that the
   // callback will not occur unless you have the function in single-quotes.

   setTimeout('func_b()', 50);

  //  No more code after this.  function func_a() is now done.  It's important not to
  //  put any more code in after this point since setTimeout() does not act like
  //  Thread.sleep() in Java.  Processing just continues, and that is the problem
  //  you're trying to get around.

} // func_a()


function func_b()
{
 if( anarray.length == 0 )
 {
   // possibly do something here, relevant to your purposes
   return;
 }
//  -or- 
if( counter == x ) // 'x' is some value you want to go to.  It'll likely either
                   // be 0 (when counting down) or the max desired value you
                   // have for x if counting upward.
{
  // possibly do something here, relevant to your purposes
  return;
}

array_member = anarray[0];
anarray.splice(0,1); // Reduces 'anarray' by one member, the one at anarray[0].
                     // The one that was at anarray[1] is now at
                     // anarray[0] so will be used at the next iteration of func_b().

func_c();

setTimeout('func_b()', 50);

} // func_b()


function func_c()
{
  counter++; // If not using 'anarray'.  Possibly you would use
             // 'counter--' if you set 'counter' to the highest value
             // desired and are working your way backwards.

  // Here is where you have the code that would have been executed
  // in the for() loop.  Breaking out of it or doing a 'continue'
  // equivalent can be done with using 'return;' or canceling 
  // processing entirely can be done by setting a global var
  // to indicate the process is cancelled, then doing a 'return;', as in
  // 'bCancelOut = true; return;'.  Then in func_b() you would be evaluating
  // bCancelOut at the top to see if it was true.  If so, you'd just exit from
  // func_b() with a 'return;'

} // func_c()