Создается ли новый объект при написании строки

Природа строк в JavaScript

В JavaScript строка — это примитивный тип данных. Однако при использовании методов строк или некоторых операторов может создаваться новый объект или примитивное значение. Давайте разберем подробнее.

Прямое присваивание строкового литерала

const str1 = 'Hello';
const str2 = 'Hello';

В этом случае не создается новый объект в памяти каждый раз. Движок JavaScript использует механизм string interning (интернирование строк) для оптимизации: одинаковые строковые литералы могут ссылаться на одну и ту же область памяти.

Создание строк через конструктор String

const str3 = new String('Hello'); // Создается объект-обертка
const str4 = new String('Hello'); // Создается еще один объект
console.log(str3 === str4); // false - это разные объекты

Здесь создается новый объект типа String каждый раз при вызове new String(). Это уже не примитив, а полноценный объект-обертка.

Операции над строками

При выполнении операций, которые "изменяют" строку, всегда создается новая строка, поскольку строки в JavaScript иммутабельны (неизменяемы).

const original = 'Hello';
const modified = original + ' World'; // Создается новая строка
const upper = original.toUpperCase(); // Создается новая строка
const sliced = original.slice(1);    // Создается новая строка

console.log(original); // 'Hello' - исходная строка не изменилась

Ключевые случаи создания новых объектов/строк:

1. Конкатенация строк (+, concat()):

   const a = 'Hello';
   const b = a + ' World'; // Создается новая строка
   

2. Методы строк (toUpperCase(), slice(), replace(), и т.д.):

   const str = 'hello';
   const newStr = str.replace('h', 'H'); // Создается новая строка
   

3. Шаблонные литералы (template literals):

   const name = 'Anna';
   const greeting = `Hello, ${name}!`; // Создается новая строка
   

4. Явное создание через конструктор:

   const strObj = new String('text'); // Создается объект String
   

Особенности производительности

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

// Плохо: создается много промежуточных строк
let result = '';
for (let i = 0; i < 1000; i++) {
    result += 'data' + i; // На каждой итерации создается новая строка
}

// Лучше: использовать массив и join
const parts = [];
for (let i = 0; i < 1000; i++) {
    parts.push('data' + i);
}
const result2 = parts.join(''); // Создается только одна строка

Сравнение строк и объектов String

const strPrimitive = 'hello';
const strObject = new String('hello');

console.log(typeof strPrimitive); // 'string'
console.log(typeof strObject);    // 'object'
console.log(strPrimitive == strObject);  // true (приведение типов)
console.log(strPrimitive === strObject); // false (разные типы)

Автоматическая упаковка (boxing)

Когда вызывается метод у строкового примитива, JavaScript временно создает объект-обертку:

const str = 'hello';
const length = str.length; // Временный объект String создается и удаляется

// Эквивалентно тому, что делает движок:
const tempObj = new String(str); // Временная обертка
const len = tempObj.length;     // Получение свойства
// tempObj удаляется сборщиком мусора

Вывод

• Строковые литералы обычно не создают новых объектов благодаря интернированию строк.
• Операции "изменения" строк всегда создают новые строки из-за иммутабельности.
• Конструктор new String() всегда создает новый объект.
• Автоматическая упаковка временно создает объекты-обертки при доступе к методам и свойствам строковых примитивов.

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