numeros - join javascript
¿Cuál es la diferencia del método+operator y concat() en JavaScript? (3)
Hay bastante iguales pero + es más claro y seguro más rápido.
Mira esta prueba de rendimiento y también ve this
Se recomienda encarecidamente que se utilicen operadores de asignación (+, + =) en lugar del método concat ().
El operador más (+) y el método String.concat() dan el mismo resultado.
operador más (+) ;
str1 + str2;
Método concat () de cadena ;
str1.concat(str2);
Además, está escrito en w3schools ;
Pero con JavaScript, los métodos y las propiedades también están disponibles para los valores primitivos, porque JavaScript trata los valores primitivos como objetos al ejecutar métodos y propiedades.
Entonces, ¿cuál es la mejor forma de utilizar la combinación de los primitivos o de los objetos String en JS? ¿Cuáles son las ventajas y desventajas de rendimiento entre ellas, si las hay?
var firstName = "John" // String
var y = new String("John"); // with String Object
Aquí están los códigos de ejemplo que dan los mismos resultados;
function example1 () {
var str1 = "Hello ";
var str2 = "World!";
document.getElementById("demo1").innerHTML += str1 + str2;
}
function example2 () {
var str1 = "Hello ";
var str2 = "World!";
document.getElementById("demo2").innerHTML += str1.concat(str2);
}
function example3 () {
var str1 = String("Hello ");
var str2 = String("World!");
document.getElementById("demo3").innerHTML += str1 + str2;
}
function example4 () {
var str1 = String("Hello ");
var str2 = String("World!");
document.getElementById("demo4").innerHTML += str1.concat(str2);
}
example1();
example2();
example3();
example4();
<p id="demo1">Demo 1: </p>
<p id="demo2">Demo 2: </p>
<p id="demo3">Demo 3: </p>
<p id="demo4">Demo 4: </p>
No hay diferencia en el comportamiento entre los métodos de cadena en un primitivo y los métodos de cadena en un objeto.
Hay una gran diferencia en el rendimiento, ya que las versiones primitivas parecen ser mucho más rápidas en este jsperf (quizás tanto como 100 veces más rápido), probablemente debido a las optimizaciones del intérprete.
Como puede ver en este jsperf , la principal diferencia en el rendimiento está causada por var str1 = new String("Hello "); en lugar de var str1 = "Hello "; . El operador + contra concat() no hace mucha diferencia en absoluto. Supongo que esto se debe a que el intérprete de JS está optimizando el método de cadena. Pero, crear un objeto de cadena real no es tan optimizado o eficiente.
En cuanto a la especificación ECMAScript, en la especificación ECMAScript para + , se dice explícitamente que si el valor primitivo del operando izquierdo (lprim) es una cadena, devuelva la cadena que es el resultado de concatenar ToString(lprim) followed by ToString(rprim) .
En la especificación ECMAScript para String.prototype.concat() , dice: Let R be the String value consisting of the characters in the previous value of R followed by the characters of ToString(next).
Esta redacción implica que + cuando se le da un operando izquierdo como una cadena, va a convertir el operando derecho en una cadena y llama a .concat() internamente, que es exactamente lo que hace .concat() .
Obviamente, si el operando de la izquierda no es una cadena, entonces obtendría un comportamiento diferente con + ya que no necesariamente lo tratará como una operación de cadena en absoluto.
Una situación en la que puede marcar la diferencia si tiene un objeto de cadena o una primitiva de cadena es si desea agregar una propiedad personalizada a un objeto de cadena, entonces necesita la forma del objeto, no la forma primitiva.
En cuanto a cuándo usar + y cuándo usar .concat() , esta es una opción de estilo de codificación personal. Ambos logran los mismos resultados. Personalmente prefiero usar operadores cuando sea posible ya que el código parece más fácil de leer.
A menos que tenga una razón específica para crear un objeto de cadena, entonces generalmente debería usar primitivos.
Entonces, realmente no hay razón para hacer esto:
var str1 = String("Hello ");
var str2 = String("World!");
document.getElementById("demo").innerHTML = str1.concat(str2);
cuando esto funciona bien
var str1 = "Hello ";
var str2 = "World!";
document.getElementById("demo").innerHTML = str1 + str2;
Este es un ejemplo de la única vez que sé cuándo es posible que desee / necesite un objeto de cadena explícito:
// actual string object will retain custom property
var str1 = new String("Hello");
str1.customProp = "foo";
log(str1.customProp);
// string primitive will not retain custom property
var str2 = "Hello";
str2.customProp = "foo";
log(str2.customProp);
function log(x) {
document.write(x + "<br>");
}
No hay diferencia según la funcionalidad, pero el operador ''+'' es más rápido que concat () para el rendimiento.
var str1="hello";
var str2="world";
var str3;
var start = new Date().getTime();
for (i = 0; i < 100000; ++i) {
str3=str1+str2;
}
var end = new Date().getTime();
var time = end - start;
print(''Execution time using + operator: '' + time);
// USING CONCAT OPERATOR
start = new Date().getTime();
for (i = 0; i < 100000; ++i) {
str3=str1.concat(str2);
}
end = new Date().getTime();
time = end - start;
print(''Execution time using CONCAT operator: '' + time);