Todo el mundo sigue diciendo que uno de los problemas de JavaScript es usar +[ ejemplo ] para la concatenación de cadenas. Algunos dicen que el problema no está usando +, es coerción de tipo [ver los comentarios del ejemplo anterior]. Pero los lenguajes fuertemente tipados usan + para los tipos de concatenación y coerción sin ningún problema. Por ejemplo, en C #:

int number = 1;
MyObject obj = new MyObject();

var result = "Hello" + number + obj;
// is equivalent to
string result = "hello" + number.ToString() + obj.ToString();

Entonces, ¿por qué la concatenación de cadenas en JavaScript es un problema tan grande?

Considere esta pieza de código JavaScript:

var a = 10;
var b = 20;
console.log('result is ' + a + b);

Esto registrará

el resultado es 1020

Lo más probable es que no sea lo que se pretendía, y puede ser un error difícil de rastrear.

Cuando dice "malo", ¿quiere decir "incorrecto" o "lento"? El argumento sobre el uso de los operadores matemáticos para hacer la concatenación de cadenas es sin duda un argumento "incorrecto", pero también hay un argumento para afirmar que el uso de +hacer una gran cantidad de concatenación de cadenas puede ser muy lento.

No estamos hablando de "Hello" + numbercuando hablamos de rendimiento, estamos hablando de construir una cadena relativamente grande al agregarla repetidamente en un bucle.

var combined = "";
for (var i = 0; i < 1000000; i++) {
    combined = combined + "hello ";
}

En JavaScript (y C # para el caso) las cadenas son inmutables. Nunca se pueden cambiar, solo se pueden reemplazar con otras cadenas. Probablemente sepa que combined + "hello "no modifica directamente la combinedvariable: la operación crea una nueva cadena que es el resultado de concatenar las dos cadenas juntas, pero luego debe asignar esa nueva cadena a la combinedvariable si desea que se cambie.

Entonces, lo que está haciendo este bucle es crear un millón de objetos de cadena diferentes y tirar 999,999 de ellos. Crear tantas cadenas que crecen continuamente en tamaño no es rápido, y ahora el recolector de basura tiene mucho trabajo que hacer para limpiar después de esto.

C # tiene exactamente el mismo problema, que la clase StringBuilder resuelve en ese entorno . En JavaScript, obtendrá un rendimiento mucho mejor al construir una matriz de todas las cadenas que desea concatenar, y luego unirlas una vez al final, en lugar de un millón de veces en el bucle:

var parts = [];
for (var i = 0; i < 1000000; i++) {
    parts.push("hello");
}
var combined = parts.join(" ");

No está mal usar + tanto para la suma como para la concatenación, siempre y cuando solo pueda agregar números y concatenar cadenas. Sin embargo, Javascript convertirá automáticamente entre números y cadenas según sea necesario, por lo que tiene:

3 * 5 => 15
"3" * "5" => 15
2 + " fish" => "2 fish"
"3" + "5" => "35"  // hmmm...

Quizás más simple, sobrecargar "+" en presencia de conversión automática de tipo rompe la asociatividad esperada del operador +:

("x" + 1) + 3 != "x" + (1 + 3)

El problema típico que surge para la concatenación de cadenas gira en torno a algunos problemas:

1. el +símbolo se sobrecarga
2. errores simples
3. programadores siendo perezosos

# 1

El primer y principal problema con el uso +para la concatenación y adición de cadenas es que está usando +para la concatenación y adición de cadenas .

si tiene variables ay b, y establece c = a + b, existe una ambigüedad que depende de los tipos de ay b. Esta ambigüedad lo obliga a tomar medidas adicionales para mitigar el problema:

Concat de cuerda:

c = '' + a + b;

Adición:

c = parseFloat(a) + parseFloat(b);

Esto me lleva al segundo punto

# 2

Es muy fácil convertir accidentalmente una variable en una cadena sin darse cuenta. También es fácil olvidar que su entrada viene como una cadena:

a = prompt('Pick a number');
b = prompt('Pick a second number');
alert( a + b );

Producirá resultados poco intuitivos porque el indicador devuelve el valor de cadena de la entrada.

# 3

Necesitar escribir parseFloato Number()cada vez que quiero hacer una suma es tedioso y molesto. Me considero lo suficientemente inteligente como para recordar no estropear mis tipos dinámicos, pero eso no significa que nunca haya estropeado mis tipos dinámicos . La verdad del asunto es que soy demasiado vago para escribir parseFloato Number()cada vez que hago una suma, porque hago mucha suma.

¿Solución?

No todos los idiomas se usan +para la concatenación de cadenas. PHP utiliza .para concatenar cadenas, lo que ayuda a distinguir entre cuándo desea agregar números y cuándo desea unir cadenas.

Cualquier símbolo podría usarse para concatenar cadenas, pero la mayoría ya se usa, y es mejor evitar la duplicación. Si me saliera con la mía, probablemente usaría _para unir cadenas y no permitir los _nombres de variables.