Durante o trabalho, você geralmente encontra o problema de concatenar 2 ou mais cordas em uma corda. Geralmente, existem três maneiras de lidar com esse tipo de problema em JS. Aqui está a lista deles, um por um, e faça uma comparação específica de seu desempenho.
O primeiro método usa o conector "+" para conectar a string a ser conectada:
str = "a"; str+= "b";
Não há dúvida de que esse método é o mais conveniente e rápido. Se você conectar apenas menos de 100 strings, é recomendável usar esse método.
O segundo método usa uma matriz como intermediária para conectar a string com a junção:
var arr = new Array (); arr.push (a); arr.push (b); var str = arr.join ("");O site da W3SCOOL apresenta que esse método consome menos recursos que o primeiro e é mais rápido. Mais tarde, verificaremos se esse é o caso por meio de experimentos.
O terceiro método usa propriedades de objeto para conectar strings
function stringConnect () {this._str_ = new Array ();} stringConnect.prototype.append = function (a) {this._str_.push (a);} stringConnect.prototype.tostring = function () {return this._str_.Join (); mystr.append ("A"); var str = mystr.toString ();Use o código a seguir para comparar o desempenho dos três métodos e ajustar o número de seqüências de seqüências de conexão alterando o valor de C:
var str = ""; var d1, d2; var c = 5000; // número de conexão Strings // -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- mystr.append ("A"); } str = mystr.toString (); d2 = new Date (); console.log (d2.gettime ()-d1.gettime ()); // ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Date (); console.log (d2.gettime ()-d1.gettime ()); // -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Ajustei C como igual a 5000, 50000, 500000 e 50000000, respectivamente. Cada valor foi medido 10 vezes, respectivamente, e o resultado final foi o seguinte:
c = 5000
Tempo médio em milissegundos
O terceiro tipo 3 2 2 3 1 2 2 1 1 1 1 1.8
O segundo tipo 1 3 0 3 1 3 4 1 4 2 2.2
O primeiro tipo 0 0 0 0 0 0 1 1 1 1 0,5
C = 50000
O terceiro tipo 22 12 9 14 12 13 13 13 10 17 13,5
O segundo tipo 8 13 12 8 11 11 8 9 8 9 9,7
O primeiro tipo 7 12 5 11 10 10 13 16 12 10.6
C = 500000
O terceiro tipo 104 70 74 69 76 77 69 102 73 73 78,7
O segundo tipo 78 100 99 99 100 98 96 71 94 97 93.2
O primeiro tipo 90 87 83 85 85 83 84 83 88 86 85,4
C = 5000000
O terceiro tipo 651 871 465 444 1012 436 787 449 432 444 599.1
O segundo tipo 568 842 593 747 417 747 719 549 573 563 631.8
O primeiro tipo 516 279 616 161 466 416 201 495 510 515 417,5
Ao contar 5000000, os parâmetros aleatórios são adicionados à barra de endereços, o que deve evitar o impacto do cache. A julgar pelos resultados, o primeiro método não consome mais do que os outros dois métodos, e é ainda mais vantajoso, o que é obviamente inconsistente com as instruções no manual.
Sistema de teste: Win 7 Flagship
Navegador: Chrome 52.0.2739.0 m
O artigo acima discute brevemente os três métodos de conexão de string e comparações de desempenho no JS são todo o conteúdo que compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.