Как примитив преобразовать в другой тип данных?

Как примитив преобразовать в другой тип данных?

Типы данных в JavaScript

Примитивы: string, number, boolean, null, undefined, Symbol, BigInt

Преобразование строк и чисел

// === СТРОКА -> ЧИСЛО ===

// Способ 1: parseInt (целое число, автоматически игнорирует нецифры)
parseInt('42'); // 42
parseInt('42.99'); // 42 (обрезает)
parseInt('0xFF'); // 255 (шестнадцатеричная)
parseInt('101', 2); // 5 (двоичная система)

// Способ 2: parseFloat (с десятичной частью)
parseFloat('3.14'); // 3.14
parseFloat('3.14abc'); // 3.14

// Способ 3: Number() (переводит весь строк)
Number('42'); // 42
Number('3.14'); // 3.14
Number(''); // 0 (пустая строка -> 0)
Number('hello'); // NaN (не число)
Number(true); // 1
Number(false); // 0

// Способ 4: Унарный плюс (самый быстрый)
+'42'; // 42
+'3.14'; // 3.14
+true; // 1
+false; // 0

// === ЧИСЛО -> СТРОКА ===

// Способ 1: toString()
(42).toString(); // '42'
(3.14).toString(); // '3.14'
(255).toString(16); // 'ff' (шестнадцатеричная)
(5).toString(2); // '101' (двоичная)

// Способ 2: String()
String(42); // '42'
String(true); // 'true'
String(null); // 'null'
String(undefined); // 'undefined'

// Способ 3: Шаблонные строки (template literals)
`${42}`; // '42'
`Price: ${3.14}`; // 'Price: 3.14'

// Способ 4: Конкатенация со строкой
42 + ''; // '42'
3.14 + 'px'; // '3.14px'

// === ЧИСЛО -> СТРОКА С ФОРМАТИРОВАНИЕМ ===
const num = 3.14159;

num.toFixed(2); // '3.14' (фиксированное количество десятичных)
num.toPrecision(3); // '3.14' (всего 3 значащих цифры)
num.toExponential(2); // '3.14e+0' (научная нотация)

// Локализованное число
(1234.5).toLocaleString('ru-RU'); // '1 234,5'
(1234.5).toLocaleString('en-US'); // '1,234.5'

Преобразование в boolean

// === ЛЮБОЙ ТИП -> BOOLEAN ===

// Способ 1: Boolean()
Boolean(1); // true
Boolean(0); // false
Boolean(''); // false
Boolean('hello'); // true
Boolean(null); // false
Boolean(undefined); // false
Boolean([]); // true (массив - объект, объекты всегда true)
Boolean({}); // true

// Способ 2: Двойное отрицание (!!)
!!'hello'; // true
!!0; // false
!!null; // false

// Способ 3: Логический оператор OR (||)
0 || 'default'; // 'default'
null || 'default'; // 'default'
'value' || 'default'; // 'value'

// Способ 4: Nullish coalescing (??)
null ?? 'default'; // 'default'
undefined ?? 'default'; // 'default'
0 ?? 'default'; // 0 (потому что 0 - не null/undefined)
'' ?? 'default'; // '' (потому что '' - не null/undefined)

// === FALSY vs TRUTHY VALUES ===
const falsy = [0, '', false, null, undefined, NaN];
const truthy = [1, 'text', true, [], {}, -1];

falsy.forEach(val => console.log(Boolean(val))); // всё false
truthy.forEach(val => console.log(Boolean(val))); // всё true

Преобразование объектов и массивов

// === ОБЪЕКТ -> СТРОКА ===

const obj = { name: 'John', age: 30 };

// Способ 1: JSON.stringify()
JSON.stringify(obj); // '{"name":"John","age":30}'
JSON.stringify(obj, null, 2); // с отступами

// Способ 2: toString() (плохой результат)
obj.toString(); // '[object Object]'

// === МАССИВ -> СТРОКА ===

const arr = [1, 2, 3];

arr.toString(); // '1,2,3'
arr.join('-'); // '1-2-3'
JSON.stringify(arr); // '[1,2,3]'

// === СТРОКА -> МАССИВ ===

'hello'.split(''); // ['h','e','l','l','o']
'a,b,c'.split(','); // ['a','b','c']
Array.from('hello'); // ['h','e','l','l','o']
[...'hello']; // ['h','e','l','l','o']

// === СТРОКА -> ОБЪЕКТ ===

// JSON.parse() (обратно JSON.stringify)
JSON.parse('{"name":"John","age":30}'); // { name: 'John', age: 30 }

// URLSearchParams для query строк
const params = new URLSearchParams('name=John&age=30');
Object.fromEntries(params); // { name: 'John', age: '30' }

// === OBJETO -> МАССИВ ===

const user = { name: 'John', age: 30 };

Object.keys(user); // ['name', 'age']
Object.values(user); // ['John', 30]
Object.entries(user); // [['name', 'John'], ['age', 30]]

Типы данных Date

// === NUMBER -> DATE ===

// Способ 1: new Date(timestamp в миллисекундах)
new Date(1609459200000); // 2021-01-01T00:00:00.000Z

// Способ 2: new Date(строка)
new Date('2021-01-01'); // 2021-01-01T00:00:00.000Z

// === DATE -> NUMBER (миллисекунды с 1970) ===

const date = new Date('2021-01-01');
date.getTime(); // 1609459200000
date.valueOf(); // 1609459200000
+date; // 1609459200000

// === DATE -> STRING ===

date.toString(); // 'Fri Jan 01 2021 00:00:00 GMT+0000'
date.toISOString(); // '2021-01-01T00:00:00.000Z'
date.toLocaleDateString(); // '1/1/2021'
date.toLocaleDateString('ru-RU'); // '1.1.2021'

Типобезопасное преобразование

// === ФУНКЦИИ-КОНВЕРТЕРЫ С ПРОВЕРКОЙ ===

function safeToNumber(value) {
  const num = Number(value);
  if (isNaN(num)) {
    throw new Error(`Cannot convert "${value}" to number`);
  }
  return num;
}

function safeParseInt(value, radix = 10) {
  const parsed = parseInt(value, radix);
  if (isNaN(parsed)) {
    throw new Error(`Cannot parse "${value}" as integer`);
  }
  return parsed;
}

function safeToBoolean(value) {
  if (value === null || value === undefined) return false;
  if (typeof value === 'boolean') return value;
  if (typeof value === 'string') return value.toLowerCase() === 'true';
  return Boolean(value);
}

// === TypeScript: Строгая типизация ===

interface Convertible {
  toNumber(): number;
  toString(): string;
  toBoolean(): boolean;
}

class Value implements Convertible {
  constructor(private value: any) {}

  toNumber(): number {
    const num = Number(this.value);
    if (isNaN(num)) throw new Error('Invalid number');
    return num;
  }

  toString(): string {
    return String(this.value);
  }

  toBoolean(): boolean {
    return Boolean(this.value);
  }
}

const val = new Value('42');
console.log(val.toNumber()); // 42
console.log(val.toString()); // '42'
console.log(val.toBoolean()); // true