A eficiência do JavaScript no loop de arrays de grande capacidade é insatisfatória. Certa vez, fiz uma comparação. Em comparação com os arrays VBS, a velocidade do loop do array VBS é aproximadamente uma ordem de magnitude mais rápida que a do JS ( http://community.csdn.net /Expert/TopicView. asp?id=4313487 ). Não prestamos muita atenção à eficiência dos arrays JS na programação geral: você não pode nem dizer a eficiência de um array com apenas algumas dezenas de elementos, mas o número de nós é grande, como milhares ou dezenas de milhares de nós. Se uma grande quantidade de loops de array for usada, a questão da eficiência se torna a principal questão a ser considerada. A recuperação de matrizes de grande capacidade geralmente tem as seguintes aplicações: correspondência rápida ao selecionar caixas de combinação, consultas em árvore, classificação ou recuperação de tabelas, etc.
Deixe-me fazer um teste. Primeiro, crio um array de grande capacidade:
<SCRIPT LANGUAGE="JavaScript">
var n = 100000; //A capacidade máxima do array
var a = new Array();
para(var i=0; i<n; i++)
{
a[i] = Math.random() +"";
}
</SCRIPT>
Desta forma, criei um array de caracteres com comprimento de 100.000 e, em seguida, recuperei a string começando com 0,9999 e armazenei-a em outro array.
<SCRIPT LANGUAGE="JavaScript">
var n = 100000; //A capacidade máxima do array
var a = new Array();
para(var i=0; i<n; i++)
{
a[i] = Math.random() +"";
}
var começar = new Date().getTime();
var b = new Array();
para(var i=0; i<n; i++)
{
if(a[i].indexOf("0,9999")==0)
{
b[b.comprimento] = a[i];
}
}
document.write("Comprimento da matriz: "+ n);
document.write("<br>O método de loop tradicional leva tempo" + (new Date().getTime() - start)
+" milissegundos! Resultados da recuperação: <strong title='"+ b.join(" ")
+"'>Registros "+ b.length +" recuperados!</strong>");
</SCRIPT>
Esta etapa da operação aqui leva cerca de 2.800 milissegundos. Para explicar, o loop aqui é muito simples. Há apenas um julgamento if e uma operação de atribuição. levará mais tempo. Será um aumento de ordem de grandeza. Então, existem boas soluções de otimização para esse problema? A resposta é claro que sim, caso contrário tudo o que eu diria neste post seria um desperdício de palavras. Mas já não podemos usar o nosso pensamento tradicional para optimizar este problema, porque não podemos encontrar uma forma melhor de escrever no pensamento tradicional.
A solução é: primeiro junte() o array em uma string grande e, em seguida, use expressões regulares para combinar e recuperar a string grande. Este método pode ser considerado minha originalidade pessoal. Eu inventei um truque tortuoso durante o processo de escrever árvores, mas a eficiência não é ruim. Já discuti a eficiência de join() ( http://blog.csdn.net/meizz/archive/2005/12/14/552260.aspx JavaScript Speed: The Efficiency of Combining and Splicing Strings). Este plano de otimização requer um certo nível de habilidades de expressão regular.
<input id="count" value="50000" size="7" maxlength="6">
<input type="button" value="Array Hua inicial" onclick="txt.innerHTML = array_init()"><br>
<input type="button" value="Loop tradicional" onclick="txt.innerHTML += method_for()">
<input type="button" value="Correspondência regular" onclick="txt.innerHTML += method_regexp()">
<div id="txt"></div>
<SCRIPT LANGUAGE="JavaScript">
var txt = document.getElementById("txt");
var a = new Array();
função array_init();
{
var n = parseInt(document.getElementById("contagem").valor);
a.comprimento = 0;
para(var i=0; i<n; i++)
{
a[i] = Math.random() +"";
}
retornar "comprimento da matriz: "+ n;
}
função método_for()
{
var n = a.comprimento;
var começar = new Date().getTime();
var b = new Array();
para(var i=0; i<n; i++)
{
if(a[i].indexOf("0,9999")==0)
{
b[b.comprimento] = a[i];
}
}
return ("<br>O método de loop tradicional leva tempo" + (new Date().getTime() - start)
+" milissegundos! Resultados da recuperação: <strong title='"+ b.join(" ")
+"'>Registros "+ b.length +" recuperados!</strong>");
}
função método_regexp()
{
var começar = new Date().getTime();
var b = new Array();
var s = a.join("x0f");
var r = new RegExp().compile("0\.9999\d+", "g");
b = s.match(r);
return ("<br>O método de correspondência regular leva tempo" + (new Date().getTime() - início)
+" milissegundos! Resultados da recuperação: <strong title='"+ b.join(" ")
+"'>Registros "+ b.length +" recuperados!</strong>");
}
</SCRIPT>
Você pode testá-lo para ver qual é a diferença de eficiência entre os dois métodos acima! O código está morto, as pessoas estão vivas. Se você mudar seu pensamento ou modelo, a eficiência será muito diferente.
Levei muito tempo para inventar esse truque e estou realmente relutante em compartilhá-lo. Agora vou usá-lo para parabenizar a todos pelo início do novo ano de 2006.