Durante el proceso de desarrollo del script, a menudo se combina y empalma una cadena grande para generarla de acuerdo con una regla determinada. Por ejemplo, al escribir un control de secuencia de comandos, la salida de la etiqueta HTML que controla la apariencia de todo el control, o al analizar y crear dinámicamente etiquetas HTML después de obtener el valor de retorno del lado del servidor en AJAX, pero no discutiré la aplicación específica de empalmar cadenas aquí solo quiero discutir la eficiencia del empalme aquí.
Cuando escribimos empalme de cadenas, siempre usamos el operador "+=", s += String. Este es el método de escritura más familiar. No sé si habrás notado que la capacidad de la cadena combinada es Cuando el número es. decenas o incluso cientos de K, la ejecución del script es muy lenta y el uso de la CPU es extremadamente alto, por ejemplo:
var str = "01234567891123456789212345678931234567894123456789";
str+= "51234567896123456789712345678981234567899123456789n";
resultado var = "";
for(var i=0; i<2000; i++) result += str;
En solo un paso, la cadena de resultado es 200K, tarda 1,1 segundos (esto está relacionado con la configuración de la computadora) y el valor máximo de la CPU es 100 %. (Para ver el efecto de forma más intuitiva, hice algunos bucles más). Es concebible que tal paso de operación consuma más de un segundo de mi tiempo. Junto con el consumo de tiempo de otros códigos, el tiempo de ejecución de todo el bloque de script se vuelve insoportable. ¿Existe alguna solución de optimización? ¿Hay alguna otra manera? La respuesta es, por supuesto, sí; de lo contrario, no tendría sentido escribir este artículo.
La forma más rápida es usar una matriz. Al empalmar en un bucle, en lugar de hacerlo en una cadena, la cadena se coloca en una matriz y, finalmente, se usa array.join ("") para obtener la cadena de resultado. :
var cadena = "01234567891123456789212345678931234567894123456789";
str+= "51234567896123456789712345678981234567899123456789n";
var resultado = "", a = nueva matriz();
for(var i=0; i<2000; i++) a[i] = str;
result = a.join(""); a = null;
Puede probar el tiempo que lleva combinar una cadena del mismo tamaño. El resultado que probé aquí es: <15 milisegundos. Tenga en cuenta que su unidad es milisegundos. lo que significa que para ensamblar una cadena de 200K, el consumo de tiempo de los dos modos es de casi dos órdenes de magnitud. ¿qué significa eso? Significa que este último terminó su trabajo y regresó del almuerzo, mientras que el primero todavía está trabajando duro. Escribí una página de prueba. Puedes copiar el siguiente código, guardarlo como un archivo HTM y abrirlo en la página web para probar la diferencia de eficiencia entre los dos. De todos modos, lo que probé es que el primero tarda medio minuto en completarse. , y este último O se puede hacer en 0,07 segundos (recorrido 10.000 veces).
<cuerpo>
Número de concatenaciones de cadenas<input id="totle" value="1000" size="5" maxlength="5">
<tipo de entrada="botón" valor="método de empalme de cadenas" onclick="método1()">
<input type="button" value="Método de unión de asignación de matriz" onclick="method2()"><br>
<div id="método1"> </div>
<div id="método2"> </div>
<textarea id="mostrar" estilo="ancho: 100%; alto: 400"></textarea>
<IDIOMA DE ESCRITURA="JavaScript">
<!--
// La longitud de esta cadena empalmada es de 100 bytes autor: meizz
var cadena = "01234567891123456789212345678931234567894123456789";
str+= "51234567896123456789712345678981234567899123456789n"
;
método de función1()
{
resultado var = "";
var totle = parseInt(document.getElementById("totle").value);
var n = nueva fecha().getTime();
for(var i=0; i<totle; i++)
{
resultado += cadena;
}
document.getElementById("mostrar").valor = resultado;
var s = "Método de empalme de cadenas: la longitud de la cadena grande después del empalme"+ resultado.longitud +"bytes,"+
"El empalme lleva tiempo" + (new Date().getTime()-n) + "¡Milisegundos!";
document.getElementById("método1").innerHTML = s;
}
//Método 2
método de función2()
{
resultado var = "";
var totle = parseInt(document.getElementById("totle").value);
var n = nueva Fecha().getTime();
var a = nueva Matriz();
para(var i=0; i<totle; i++)
{
a[i] = cadena;
}
resultado = a.join(""); a=null;
document.getElementById("mostrar").valor = resultado;
var s = "Método de unión de asignación de matriz: la longitud de la cadena grande después del empalme"+ resultado.longitud +"bytes",+
"El empalme lleva tiempo" + (new Date().getTime()-n) + "¡Milisegundos!";
document.getElementById("método2").innerHTML = s;
}
//-->
</SCRIPT>
Finalmente, permítanme decir algunas palabras. ¿Se utilizará la unión de matrices para empalmar cadenas en el futuro? Esto depende de sus necesidades reales. Para combinaciones ordinarias de unos pocos bytes o de nivel K, no es necesario utilizar el método de matriz, porque abrir variables de matriz también es costoso. Si hay más de unas pocas combinaciones de cadenas K, la eficiencia de la matriz es alta.
-------------------------------------------------- ----------
Es decir, 6.0:
Método de empalme de cadenas: la cadena grande empalmada tiene 1.010.000 bytes de longitud y el empalme tarda 22.089 milisegundos.
Método de unión de asignación de matriz: la cadena grande empalmada tiene 1.010.000 bytes de longitud y el empalme tarda 218 milisegundos.
Firefox 1.0:
Método de empalme de cadenas: la cadena grande empalmada tiene 1.010.000 bytes de longitud y el empalme tarda 1.044 milisegundos.
Método de unión de asignación de matriz: la cadena grande empalmada tiene 1.010.000 bytes de longitud y el empalme tarda 1.044 milisegundos.
Mozilla 1.7:
Método de empalme de cadenas: la cadena grande empalmada tiene 1.010.000 bytes de longitud y el empalme tarda 1.045 milisegundos.
Método de unión de asignación de matriz: la cadena grande empalmada tiene 1.010.000 bytes de longitud y el empalme tarda 1.044 milisegundos.
Netscape 7.0:
Método de empalme de cadenas: la cadena grande empalmada tiene 1.010.000 bytes de longitud y el empalme tarda 10.273 milisegundos.
Método de unión de asignación de matriz: la cadena grande empalmada tiene 1.010.000 bytes de longitud y el empalme tarda 1.138 milisegundos.
Ópera 7.54:
Método de empalme de cadenas: la cadena grande empalmada tiene 1.010.000 bytes de longitud y el empalme tarda 6.968 milisegundos.
Método de unión de asignación de matriz: la cadena grande empalmada tiene 1010000 bytes de longitud y el empalme tarda 6922 milisegundos.
Los resultados de la prueba de bucle 10,000 veces muestran que la eficiencia se puede mejorar enormemente en IE y Netscape, mientras que el consumo de tiempo de los dos métodos en Firefox Mozilla Opera es básicamente similar. Estos datos son suficientes para determinar que el método de unión de matriz es mejor que el método de unión de matriz. empalme de cuerdas tradicional.