В чем разница метода + operator и concat() в JavaScript?

Оператор плюс (+) и String.concat() дают тот же результат.

плюс (+) оператор;

str1 + str2;

Метод String concat();

str1.concat(str2);

Кроме того, он написан в w3schools;

Но с JavaScript методы и свойства также доступны для примитивных значений, поскольку JavaScript обрабатывает примитивные значения как объекты при выполнении методов и свойств.

Итак, какой способ лучше использовать для комбинирования либо для использования в примитивах, либо для объектов String в JS, каковы преимущества и недостатки производительности между ними, если они есть?

var firstName = "John"      // String
var y = new String("John"); // with String Object

Вот примеры кодов, которые дают одинаковые результаты;

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>

Ответ 1

Есть и такие же, но + более понятные и, безусловно, быстрее.

Посмотрите на этот тест производительности, а также увидеть это

Настоятельно рекомендуется использовать операторы присваивания (+, + =) вместо метода concat().

Ответ 2

Нет никакой разницы в поведении между строковыми методами примитивного и строковыми методами для объекта.

Существует большая разница в производительности, поскольку в этом jsperf (возможно, до 100 раз быстрее) примитивные версии намного быстрее, что, вероятно, связано с оптимизацией интерпретатора.

Как видно из этого jsperf, основное различие в производительности вызвано var str1 = new String("Hello "); вместо var str1 = "Hello "; , Оператор + против concat() не имеет особого значения. Я предполагаю, что это потому, что интерпретатор JS оптимизирует строковый метод. Но создание фактического строкового объекта не так оптимизировано или эффективно.

Что касается спецификации ECMAScript, то в спецификации ECMAScript для + он явно говорит, что если примитивное значение левого операнда (lprim) является строкой, верните строку, которая является результатом объединения ToString(lprim) followed by ToString(rprim).

В спецификации ECMAScript для String.prototype.concat() указано: Let R be the String value consisting of the characters in the previous value of R followed by the characters of ToString(next).

Эта формулировка подразумевает, что + при заданном левом операнде в виде строки собирается .concat() правильный операнд в строку и вызвать .concat() внутри, что является именно тем, что .concat().

Очевидно, если левый операнд не является строкой, то вы бы по-другому подействовали с + поскольку он не обязательно будет рассматривать его как операцию строки вообще.

Ситуация, что может иметь значение, есть ли у вас строковый объект или примитив строки, если вы хотите добавить настраиваемое свойство к строковому объекту, тогда вам нужна форма объекта, а не примитивная форма.

Что касается того, когда использовать + и когда использовать .concat(), это выбор стиля личного кодирования. Оба достигают тех же результатов. Я лично предпочитаю использовать операторов, когда это возможно, поскольку код просто кажется более простым для чтения.

Если у вас нет особых причин для создания строкового объекта, вы должны просто использовать примитивы.

Поэтому нет причин для этого:

var str1 = String("Hello ");
var str2 = String("World!");
document.getElementById("demo").innerHTML = str1.concat(str2);

когда это работает отлично:

var str1 = "Hello ";
var str2 = "World!";
document.getElementById("demo").innerHTML = str1 + str2;

Вот пример единственного времени, когда я знаю, когда вам может понадобиться явный строковый объект:

// 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>");
}

Ответ 3

Никакая разница по функциональности, но оператор "+" быстрее, чем concat() для производительности.

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);

беритесь на идеон