Строка - это примитивный или ссылочный тип данных

Строки: примитивный или ссылочный тип?

Ответ: Строки — примитивный тип данных, но с оговоркой. В JavaScript есть два способа работы со строками, и это создаёт путаницу.

Примитивные строки vs объекты String

// Примитивная строка (примитивный тип)
const str1 = "Hello";
console.log(typeof str1); // "string"

// Строка-объект (ссылочный тип) — обычно создаётся автоматически
const str2 = new String("Hello");
console.log(typeof str2); // "object"

// Для сравнения:
console.log(str1 === "Hello");  // true
console.log(str2 === "Hello");  // false (разные объекты)
console.log(str2 == "Hello");   // true (приведение типов)

Почему строка кажется ссылочным типом?

Хотя строка — примитивный тип, JavaScript предоставляет методы на строках. Это работает благодаря механизму автобоксинга (autoboxing):

const str = "Hello";

// Когда вызываешь метод на примитивной строке:
console.log(str.toUpperCase()); // "HELLO"

// Браузер делает это за кулисами:
// 1. Создаёт временный объект String: new String("Hello")
// 2. Вызывает метод на этом объекте
// 3. Удаляет временный объект

// Эквивалент:
const temp = new String(str);
console.log(temp.toUpperCase()); // "HELLO"
// temp удаляется

Доказательство, что строка — примитив

1. Сравнение по значению:

const a = "hello";
const b = "hello";

console.log(a === b); // true — сравниваются значения

// Объекты же сравниваются по ссылке:
const obj1 = {name: "hello"};
const obj2 = {name: "hello"};

console.log(obj1 === obj2); // false — разные объекты
console.log(obj1.name === obj2.name); // true — значения совпадают

2. Невозможно изменить:

const str = "hello";

// Попытка изменить символ
str[0] = "H";
console.log(str); // "hello" — не изменилась!

// Это работает благодаря тому, что строка примитивна и иммутабельна

3. Передача по значению:

let str = "original";

function modifyString(s) {
  s = "modified"; // создаёт новую переменную s
  return s;
}

const result = modifyString(str);
console.log(str);    // "original" — не изменилась
console.log(result); // "modified"

// Сравните с объектом:
let obj = {value: "original"};

function modifyObject(o) {
  o.value = "modified"; // изменяет существующий объект
}

modifyObject(obj);
console.log(obj.value); // "modified" — изменилась!

Примитивный тип строки в JavaScript

Примитивные типы:

• string — "hello"
• number — 42
• boolean — true
• undefined
• null
• symbol — Symbol(id)
• bigint — 123n

Ссылочные типы (объекты):

• Object — {}
• Array — []
• Function — function() {}
• Date — new Date()
• String (объект) — new String("hello")
• И другие конструкторы

Где хранится примитивная строка?

// Примитивная строка хранится в Stack (стеке)
const str = "hello"; // Stack: переменная str → значение "hello"

// Объект хранится в Heap (куче), в Stack только ссылка
const obj = {name: "Alice"}; // Stack: переменная obj → Heap адрес
                             // Heap: {name: "Alice"}

Таблица сравнения

Практические примеры

Пример 1: Когда это имеет значение

const str1 = "hello";
const str2 = new String("hello");

// В условии
if (str1) console.log("str1 is truthy"); // выводит
if (str2) console.log("str2 is truthy"); // выводит (объект всегда truthy!)

// str2 truthy, потому что это объект, а объекты всегда truthy
if (!new String("")) console.log("empty string object is truthy!"); // выводит!

Пример 2: Работа с методами

const str = "hello world";

// Все эти методы работают благодаря автобоксингу
console.log(str.length);           // 11
console.log(str.toUpperCase());    // "HELLO WORLD"
console.log(str.substring(0, 5));  // "hello"
console.log(str.split(" "));       // ["hello", "world"]

// Браузер создаёт временный объект String для каждого вызова

Пример 3: Немутабельность

const str = "hello";

// Эти операции создают новые строки
const upper = str.toUpperCase(); // новая строка
const replaced = str.replace("l", "L"); // новая строка
const concatenated = str + " world"; // новая строка

console.log(str); // "hello" — оригинальная не изменилась

Почему JavaScript имеет и примитивы, и объекты?

// Примитивы — быстро и просто
const a = "hello";
const b = "hello";
console.log(a === b); // true, быстрая проверка

// Но нужны методы — поэтому есть объекты и автобоксинг
console.log(a.length); // работает благодаря временному объекту

// В специальных случаях можно создать явный объект
const strObj = new String("hello");
// Но это редко используется

Резюме

Ответ на интервью:

"Строка — это примитивный тип данных в JavaScript. Она хранится как значение, сравнивается по значению, и является неизменяемой. Хотя строка может иметь методы (как length, toUpperCase() и т.д.), это работает благодаря автобоксингу — браузер автоматически создаёт временный объект String, вызывает метод, а затем удаляет объект.

В отличие от этого, если явно создать new String(hello), это будет ссылочный тип — объект. Но в практическом коде всегда используются примитивные строки."

Краткая таблица примитивов JavaScript:

• 7 примитивных типов: string, number, boolean, undefined, null, symbol, bigint
• Всё остальное — объекты (включая Array, Function, Date и т.д.)