¿Por qué la concatenación de cadenas es más rápida que la combinación de matrices?

Firefox es rápido porque usa algo llamado Ropes ( Ropes: una alternativa a Strings ). Una cuerda es básicamente un DAG, donde cada Nodo es una cadena.

Así que, por ejemplo, si hicieras a = 'abc'.concat('def'), el objeto recién creado se vería así. Por supuesto, esto no es exactamente como se ve en memoria, porque todavía necesita tener un campo para el tipo de cadena, la longitud y tal vez otro.

a = {
 nodeA: 'abc',
 nodeB: 'def'
}

Y b = a.concat('123')

b = {
  nodeA: a, /* {
             nodeA: 'abc',
             nodeB: 'def'
          } */
  nodeB: '123'
}           

Así que en el caso más simple VM no tiene que hacer casi ningún trabajo. El único problema es que esto ralentiza un poco otras operaciones en la cadena resultante. También esto, por supuesto, reduce la sobrecarga de memoria.

Por otro lado, ['abc', 'def'].join('') normalmente solo asignaría memoria para diseñar la nueva cadena plana en memoria. (Tal vez esto debería ser optimizado)

Sé que este es un hilo viejo, pero su prueba es incorrecta. Estás haciendo output += myarray[i]; mientras que debería ser más como output += "" + myarray[i]; porque te has olvidado, que tienes que pegar elementos junto con algo. El código concat debería ser algo así como:

var output = myarray[0];
for (var i = 1, len = myarray.length; i<len; i++){
    output += "" + myarray[i];
}

De esa manera, está haciendo dos operaciones en lugar de una debido a pegar elementos juntos.

Array.join() es más rápido.

Los puntos de referencia allí son triviales. Concatenar los mismos tres ítems repetidamente será inlineado, los resultados probarán ser deterministas y memoizados, el manejador de basura estará simplemente tirando objetos de matriz (que serán casi nada en tamaño) y probablemente simplemente empujados y salidos de la pila debido a que no hay referencias externas y porque las cadenas nunca cambian. Estaría más impresionado si la prueba fuera un gran número de cadenas generadas aleatoriamente. Como en un concierto o dos de valor de cadena.

Array.únete a FTW!

Yo diría que con cadenas es más fácil pre-asignar un buffer más grande. Cada elemento es de solo 2 bytes (si es UNICODE), por lo que incluso si eres conservador, puedes pre-asignar un búfer bastante grande para la cadena. Con arrays cada elemento es más "complejo", porque cada elemento es un Object, por lo que una implementación conservadora preasignará espacio para menos elementos.

Si intentas añadir un for(j=0;j<1000;j++) antes de cada for verás que (en chrome) la diferencia de velocidad se hace menor. En el end todavía era 1.5 x para la concatenación de cadenas, pero más pequeño que el 2.6 que era antes.

Y al tener que copiar los elementos, un carácter Unicode es probablemente más pequeño que una referencia a un objeto JS.

Tenga en cuenta que existe la posibilidad de que muchas implementaciones de motores JS tengan una optimización para matrices de un solo tipo que harían inútil todo lo que he escrito: -)

Esta prueba muestra la penalización de usar realmente una cadena hecha con concatenación de asignación vs hecha con matriz.método de unión. Mientras que la velocidad general de asignación sigue siendo el doble de rápido en Chrome v31, pero ya no es tan grande como cuando no se utiliza la cadena resultante.

Esto depende claramente de la implementación del motor javascript. Incluso para diferentes versiones de un motor puede obtener resultados significativamente diferentes. Usted debe hacer su propio punto de referencia para verificar esto.

Yo diría que String.concat tiene un mejor rendimiento en las versiones recientes de V8. Pero para Firefox y Opera, Array.join es un ganador.

Mi conjetura es que, mientras que cada versión está llevando el costo de muchas concatenaciones, las versiones de unión están construyendo matrices además de eso.