Durante el desarrollo del script, una cadena grande a menudo se combina y se empalma en una cadena grande para la salida de acuerdo con una determinada regla. Por ejemplo, al escribir controles de script, la salida de etiquetas HTML que controlan la apariencia de todo el control. Por ejemplo, al analizar dinámicamente las etiquetas HTML después de obtener el valor posterior del lado del servidor en AJAX, no discutiré la aplicación específica de las cadenas de empalme aquí. Solo quiero discutir la eficiencia del empalme aquí.
Cuando escribimos código, usamos el operador " +=", s += string; Esta es la forma más familiar de escribir. Me pregunto si lo has notado. Cuando la capacidad de cadena combinada es decenas de k o incluso cientos de k, el script es muy lento para ejecutar y la tasa de uso de la CPU es muy alta, por ejemplo:
La copia del código es la siguiente:
var str = "01234567891123456789212345678931234567894123456789";
str+= "51234567896123456789712345678981234567899123456789/n";
resultado var = "";
para (var i = 0; i <2000; i ++) resultado+= str;
En solo un paso, la cadena de resultados generada es de 200k, que toma 1.1 segundos (esto está relacionado con la configuración de la computadora), y el pico de la CPU es del 100%. (Hice más bucles para ver el efecto de manera más intuitiva). Se puede imaginar que solo un paso de operación me llevó más de un segundo, y junto con el tiempo dedicado a otros códigos, el tiempo de ejecución de todo el bloque de script sería insoportable. Entonces, ¿hay una solución de optimización? ¿Hay alguna otra forma? Por supuesto, hay una respuesta, de lo contrario, no tengo sentido escribir este artículo.
Una forma más rápida es usar una matriz. Al dispersar bucles, no es para empalmarlo en una determinada cadena, sino poner la cadena en una matriz, y finalmente usar el array.Join ("") para obtener la cadena de resultados. Ejemplo de código:
La copia del código es la siguiente:
var str = "01234567891123456789212345678931234567894123456789";
str+= "51234567896123456789712345678981234567899123456789/n";
VAR result = "", a = new Array ();
para (var i = 0; i <2000; i ++) a [i] = str;
resultado = A.Join (""); a = nulo;
Puede probar y 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. Es decir, combinando una cadena de 200k, el consumo de tiempo de los dos modos es de aproximadamente dos órdenes de magnitud. ¿qué significa eso? Esto significa que este último ha terminado su trabajo y ha regresado del almuerzo, mientras que el primero todavía está trabajando como una coolie. Escribiré una página de prueba. Puede copiar el siguiente código y guardarlo como un archivo HTM y abrirlo en la página web para probar la diferencia de eficiencia entre los dos. De todos modos, estoy probando el primero que tarda medio minuto en completarse, y el segundo que toma 0.07 segundos (10,000 bucles).
La copia del código es la siguiente:
<Body>
Número de tiempos de empalme de cadena <input id = "totle" value = "1000" size = "5" maxLength = "5">
<input type = "button" value = "String Spliting Method" onClick = "Method1 ()">
<input type = "button" valor = "método de unión de asignación de matriz" onClick = "método2 ()"> <br>
<div id = "método1"> </div>
<div id = "método2"> </div>
<Textarea id = "show"> </extarea>
<Script language = "javaScript">
<!-
// La longitud de esta cadena que se está empalmando es 100 bytes Autor: Meizz
var str = "01234567891123456789212345678931234567894123456789";
str+= "51234567896123456789712345678981234567899123456789/n";
// Método 1
Método de función1 ()
{
resultado var = "";
var totle = parseInt (document.getElementById ("totle"). valor);
var n = nueva fecha (). gettime ();
para (var i = 0; i <totle; i ++)
{
resultado += str;
}
document.getElementById ("show"). valor = resultado;
var s = "Método de empalme de cadena: la cadena grande empalmada es larga"+ resultado.length+ "byte,"+
"Tiempo dividido" + (nueva fecha (). GetTime ()-N) + "MilliseConds!";
document.getElementById ("método1"). innerhtml = s;
}
// Método 2
Método de función2 ()
{
resultado var = "";
var totle = parseInt (document.getElementById ("totle"). valor);
var n = nueva fecha (). gettime ();
var a = nueva matriz ();
para (var i = 0; i <totle; i ++)
{
a [i] = str;
}
resultado = A.Join (""); a = nulo;
document.getElementById ("show"). valor = resultado;
var s = "Método de unión de asignación de matriz: la cadena grande empalmada es larga" + resultado.length + "byte", +
"Tiempo dividido" + (nueva fecha (). GetTime ()-N) + "MilliseConds!";
document.getElementById ("método2"). innerhtml = s;
}
//->
</script>
Finalmente, diré algunas palabras más. ¿Todas las unidas de empalme de cadena usarán en el futuro? Esto depende de sus necesidades reales. No es necesario usar el método de matriz para combinaciones ordinarias de varios o bytes de nivel K, porque también se consumen variables de matriz de apertura. Si hay más de unas pocas combinaciones de cuerdas K, significa que la matriz es eficiente.
Es decir, 6.0:
Método de empalme de cadena: la cadena grande empalmada tiene 1010,000 bytes de largo, ¡y el empalme toma 22,089 milisegundos!
Método de unión de asignación de matriz: la cadena grande empalmada tiene 1010,000 bytes de largo, ¡y se necesitan 218 milisegundos para empalmar!
Firefox 1.0:
Método de empalme de cadena: la cadena grande empalmada tiene 1010,000 bytes de largo, ¡y el empalme toma 1044 milisegundos!
Método de unión de asignación de matriz: la cadena grande empalmada tiene 1010,000 bytes de largo, ¡y el empalme toma 1044 milisegundos!
Mozilla 1.7:
Método de empalme de cadena: la cadena grande empalmada tiene 1010,000 bytes de largo, ¡y el empalme toma 1045 milisegundos!
Método de unión de asignación de matriz: la cadena grande empalmada tiene 1010,000 bytes de largo, ¡y el empalme toma 1044 milisegundos!
Netscape 7.0:
Método de empalme de cadena: la cadena grande empalmada tiene 1010,000 bytes de largo, ¡y el empalme toma 10,273 milisegundos!
Método de unión de asignación de matriz: la cadena grande empalmada tiene 1010,000 bytes de largo, ¡y se necesitan 1138 milisegundos para empalmar!
Opera 7.54:
Método de empalme de cadena: la cadena grande empalmada tiene 1010,000 bytes de largo, ¡y el empalme toma 6968 milisegundos!
Método de unión de asignación de matriz: la cadena grande empalmada tiene 1010,000 bytes de largo, ¡y el empalme toma 6922 milisegundos!
Los resultados de la prueba de 10,000 ciclos muestran que la eficiencia puede mejorarse en gran medida en IE y Netscape, mientras que en Firefox Mozilla Opera, los dos métodos llevan casi el mismo tiempo. Estos datos pueden ser suficientes para determinar que el método de unión de matriz es mejor que el empalme de cadena tradicional.