Scripts in Firefox langsamer als im IE?

[Struppi]

.... Meine Frage galt auch keiner Sequenz aus meinem Skript, sondern lediglich der Frage, ob es möglich sei, dass verschiedene Browser unterschiedlich lange brauchen, umfangreiche Skripte abzuarbeiten. Ist mittlerweile auch beantwortet.

Trotzallem, sollte deine Ursachenforschung tiefer gehen. Jeder Browser hat seine Spezialitäten und ist in anderen Dingen langsamer als der Rest. Aber dein Code erweckt schon so den Eindruck der ineffizenz, dass das von dir beobachteten Verhalten evtl. auch daran liegen kann.

Öhm, das _sind_ Arrays...

Ich kann das Spiel zwar nicht und weiß daher nicht was du im einzelnen passieren soll, aber ich hab das mal umgebaut.

Die grundlegende Änderung ist deine Funktion setarray()

  
function setarray()  
{  
    rows = [  
    [ num[0],num[1],num[2],num[3],num[4],num[5],num[6],num[7],num[8] ],  
    [ num[9],num[10],num[11],num[12],num[13],num[14],num[15],num[16],num[17] ],  
    [ num[18],num[19],num[20],num[21],num[22],num[23],num[24],num[25],num[26] ],  
    [ num[27],num[28],num[29],num[30],num[31],num[32],num[33],num[34],num[35] ],  
    [ num[36],num[37],num[38],num[39],num[40],num[41],num[42],num[43],num[44] ],  
    [ num[45],num[46],num[47],num[48],num[49],num[50],num[51],num[52],num[53] ],  
    [ num[54],num[55],num[56],num[57],num[58],num[59],num[60],num[61],num[62] ],  
    [ num[63],num[64],num[65],num[66],num[67],num[68],num[69],num[70],num[71] ],  
    [ num[72],num[73],num[74],num[75],num[76],num[77],num[78],num[79],num[80] ]  
    ];  
  
    cols = [  
    [ num[0],num[9],num[18],num[27],num[36],num[45],num[54],num[63],num[72] ],  
    [ num[1],num[10],num[19],num[28],num[37],num[46],num[55],num[64],num[73] ],  
    [ num[2],num[11],num[20],num[29],num[38],num[47],num[56],num[65],num[74] ],  
    [ num[3],num[12],num[21],num[30],num[39],num[48],num[57],num[66],num[75] ],  
    [ num[4],num[13],num[22],num[31],num[40],num[49],num[58],num[67],num[76] ],  
    [ num[5],num[14],num[23],num[32],num[41],num[50],num[59],num[68],num[77] ],  
    [ num[6],num[15],num[24],num[33],num[42],num[51],num[60],num[69],num[78] ],  
    [ num[7],num[16],num[25],num[34],num[43],num[52],num[61],num[70],num[79] ],  
    [ num[8],num[17],num[26],num[35],num[44],num[53],num[62],num[71],num[80] ]  
    ];  
  
    blks = [  
    [ num[0],num[1],num[2],num[9],num[10],num[11],num[18],num[19],num[20] ],  
    [ num[3],num[4],num[5],num[12],num[13],num[14],num[21],num[22],num[23] ],  
    [ num[6],num[7],num[8],num[15],num[16],num[17],num[24],num[25],num[26] ],  
    [ num[27],num[28],num[29],num[36],num[37],num[38],num[45],num[46],num[47] ],  
    [ num[30],num[31],num[32],num[39],num[40],num[41],num[48],num[49],num[50] ],  
    [ num[33],num[34],num[35],num[42],num[43],num[44],num[51],num[52],num[53] ],  
    [ num[54],num[55],num[56],num[63],num[64],num[65],num[72],num[73],num[74] ],  
    [ num[57],num[58],num[59],num[66],num[67],num[68],num[75],num[76],num[77] ],  
    [ num[60],num[61],num[62],num[69],num[70],num[71],num[78],num[79],num[80] ]  
    ];  
}  

sieht schonmal besser aus als vorher.

Jetzt hast du ja diese Grauenhaften Abfragen
if( row1.indexOf(11) != 1 || row1.indexOf(22) != 1 || ... usw. usf.

oder auch
if( row1.length > maxnum  || row1.length < minnum ....

Diese habe ich mal umgesetzt als Protoype Funktionen für Arrays:

  
// Funktionen für die Arrays of Arrays  
  
// has_joins verknüpft die Einträge der Arrays  
// sortiert miteinander,  
// das muss aber nur einmal gemacht werden  
Array.prototype.has_joins = function()  
{  
    if(!this.joins)  
    {  
         this.joins = [];  
         for(var i = 0; i < this.length; i++)  
         this.joins[i] = this[i].sort().join('');  
    }  
};  
// find_one prüft ob ein Element des array el  
// in einem Array von this vorhanden ist  
Array.prototype.find_one = function(el)  
{  
    this.has_joins();  
    for(var i = 0; i < el.length; i++)  
         for(var j = 0; j < this.length; j++)  
             if( this.joins[j].indexOf( el[i] ) > -1) return true;  
    return false;  
};  
// min_max prüft die Anzahl der einträge in den Arrays  
// kleiner als may und größer als min sind  
Array.prototype.min_max = function(min, max)  
{  
    this.has_joins();  
    for(var i = 0; i < this.length; i++)  
    {  
        if( this.joins[i].length > max || this.joins[i].length < min) return true;  
    }  
    return false;  
};  

Dann stehen 2 neue Funktionen zu Verfügung, die die Arrays of Arrays (AoA) benutzen können.
Einmal find_one( Array ) und min_max(min, max), diese übernehmen deine ellenlangen if(....) Konstrukte.

Und da du immer nach den gleichen Werten suchst 11,22,33,44,.... hab ich hier noch ein globales Array eingeführt (find_array)

deine Funktionen calulate() und reject() sehen dann so aus:

  
var find_array = [11, 22, 33, 44, 55, 66, 77, 88, 99];  
...  
  
function calculate()  
{  
    for (i=0;i<n;i++)  
    {  
         num[i] = parseInt(Math.random()*10);  
         td[i] = "<input type=\"text\" maxLength=\"1\" value=\""+num[i]+"\" readonly>";  
         setarray();  
         if (  
         rows.find_one( find_array ) ||  
         cols.find_one( find_array ) ||  
         blks.find_one( find_array ) ||  
         num[i] == 0  
         )  
         i--;  
         }  
}  
function reject()  
{  
    setarray();  
    if (  
    rows.min_max(minnum, maxnum) ||  
    cols.min_max(minnum, maxnum) ||  
    blks.min_max(minnum, maxnum)  
    )  
    {  
    setup();  
    }  
    else  
    {  
    message="Level: "+msglevel[0];  
    show();  
    }  
}  

Das hat bei mir zumindest schon die Geschwindigkeit erheblich verbessert, aber ich muss dazu sagen, da ich das Spiel ja nicht kann, dass ich nicht 100% sicher bion, da ich es nicht testen konnte, ob dann immer noch alles so passiert wie es sollte.

Struppi.