La forma más eficiente de generar una cadena realmente larga (decenas de megabytes) en JS

Question

Me resulta necesario sintetizar una secuencia ridículamente larga (como decenas de megabytes de longitud) en JavaScript. (Esto es para reducir la velocidad de una operación CSS selector de coincidencia hasta el punto en que se necesita una cantidad medible de tiempo.)

La mejor manera que he encontrado para hacer esto es

var really_long_string = (new Array(10*1024*1024)).join("x"); 

pero yo' Me pregunto si hay una manera más eficiente, una que no implique crear una matriz de decenas de megabytes primero.

Answer 1

La versión aceptada usa String.prototype.concat() que es vastly slower que utilizando el operador de concatenación de cuerda optimizado, +. MDN también recommends para evitar usarlo en el código de velocidad crítica.

He hecho three versions del código anterior para mostrar las diferencias de velocidad en un JsPerf. Convertirlo a usar solo usando concat es solo un tercio más rápido que solo usar el operador de concatenación de cuerdas (Chrome: el kilometraje puede variar). La versión editada a continuación se ejecutará dos veces más rápido en Chrome

var x = "1234567890"; 
var iterations = 14; 
for (var i = 0; i < iterations; i++) { 
    x += x+x; 
} 

Answer 2

Simplemente acumulación es mucho más rápido en Safari 5:

var x = "1234567890"; 
var iterations = 14; 
for (var i = 0; i < iterations; i++) { 
    x += x.concat(x); 
} 
alert(x.length); // 47829690 

Esencialmente, usted obtendrá x.length * 3^iterations caracteres.

Answer 3

Este es el algoritmo más eficiente para la generación de cadenas muy largas en javascript:

function stringRepeat(str, num) { 
    num = Number(num); 

    var result = ''; 
    while (true) { 
     if (num & 1) { // (1) 
      result += str; 
     } 
     num >>>= 1; // (2) 
     if (num <= 0) break; 
     str += str; 
    } 

    return result; 
} 

más información aquí: http://www.2ality.com/2014/01/efficient-string-repeat.html.

Alternativamente, en ECMA6 puede usar el método String.prototype.repeat().

Answer 4

No estoy seguro si esto es una gran aplicación, pero aquí es una función general basado en la solución de @ oligofren:

function repeat(ch, len) { 
    var result = ch; 
    var halfLength = len/2; 
    while (result.length < len) { 
    if (result.length <= halfLength) { 
     result += result; 
    } else { 
     return result + repeat(ch, len - result.length); 
    } 
    } 

    return result; 
} 

Esto supone que la concatenación de una cadena grande es más rápido que una serie de pequeñas cadenas.