Привет! Сегодня обсудим TypeScript и поймем нужно ли его учить. TypeScript — это не просто хайп, а инструмент, который делает разработку проще.

Что такое TypeScript?
TypeScript — это надстройка над JavaScript, которая добавляет статическую типизацию. Код на TS компилируется в обычный JS, но с кучей бонусов для разработчика.

Зачем использовать TypeScript?
1. Типы помогают ловить ошибки ещё на этапе написания кода. Например, если вы случайно передадите строку вместо числа, TS сразу укажет на проблему.

 function add(a: number, b: number): number {
  return a + b;
}
add("2", 3); // TS не даст передать строку вместо числа

2. TS делает код понятнее: типы и интерфейсы — как документация, которая всегда под рукой.

3. В больших приложениях TS спасает от хаоса. Он помогает управлять сложной логикой и предотвращает ошибки при рефакторинге.

4. Редакторы кода с TS подсказывают методы, свойства и типы.

5. Любой JS-код — это валидный TS-код. Можно добавлять типы постепенно, не переписывая проект с нуля.

Когда точно надо использовать TS?
— В проектах с большим количеством разработчиков.
— Когда нужно поддерживать сложную бизнес-логику.

Стоит ли учить TS в 2025?
Однозначно да! TypeScript — стандарт в индустрии. Плюс, знание TS жирный плюс на собеседовании.

#typescript #JavaScript

Привет! Сегодня разберёмся в разнице между extends и implements.

Что такое extends?
Ключевое слово extends используется, когда один класс наследует другой. Это значит, что он получает все свойства и методы родительского класса и может их переопределить или дополнить.

class Animal {
  move() {
    console.log('Moving');
  }
}

class Dog extends Animal {
  bark() {
    console.log('Woof!');
  }
}

const dog = new Dog();
dog.move(); // Moving
dog.bark(); // Woof!

Класс Dog получил доступ ко всем методам Animal.

Используем extends, когда:
— хотим переиспользовать код
— строим иерархию классов
— нужно расширить поведение базового класса


Что делает implements?
implements используется, когда класс реализует интерфейс. Интерфейс — это просто контракт, набор правил, которые класс должен соблюдать. Он не содержит никакой логики.

interface Flyable {
  fly(): void;
}

class Bird implements Flyable {
  fly() {
    console.log('Flying');
  }
}

Если в классе Bird не будет метода fly, TS сразу покажет ошибку — потому что мы обязались его реализовать.

Используем implements, когда:
— хотим задать чёткие правила, что должен уметь класс
— пишем код в стиле “контрактов”
— делаем архитектуру более предсказуемой


#typescript #JavaScript

Продолжаем разбираться с промисами. Сегодня разберем Promise.race.

Что такое Promise.race?
Promise.race - это метод, который принимает массив промисов и возвращает новый промис, который завершается или отклоняется так же, как самый быстрый промис в массиве. То есть, как только один из промисов завершается (успешно или с ошибкой), Promise.race сразу возвращает его результат, игнорируя остальные.

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

async function getFastestData() {
  try {
    const api1 = fetch('https://api1.example.com/data');
    const api2 = fetch('https://api2.example.com/data');
    const api3 = fetch('https://api3.example.com/data');

    const winner = await Promise.race([api1, api2, api3]);
    console.log('Самый быстрый API:', await winner.json());
  } catch (error) {
    console.error('Ошибка:', error);
  }
}

Здесь Promise.race дождётся первого ответа от любого API. Если один из запросов завершится с ошибкой раньше остальных, Promise.race сразу перейдёт в состояние ошибки.

Когда использовать?
Например, вы отправляете запросы на несколько зеркал API, и вам нужен самый быстрый ответ.

Важно
Promise.race не отменяет остальные промисы. Даже если один промис завершился, остальные продолжают выполняться в фоне.


В одном из следующих постов разберём интересную задачу, которая встречается на некоторых собеседованиях, но не все находят её решение.

#JavaScript

Продолжаем серию постов про SOLID. Сегодня разберём третью букву — L, которая расшифровывается как Liskov Substitution Principle или принцип подстановки Лисков.

О чём этот принцип?
Принцип гласит:

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

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

Пример плохого подхода
Рассмотрим пример с платёжными системами:

class Payment {
  process(amount) {
    return `Обработка платежа на ${amount} рублей`;
  }
}

class CreditCardPayment extends Payment {
  process(amount) {
    return `Оплата ${amount} рублей картой`;
  }
}

class CashPayment extends Payment {
  process(amount) {
    throw new Error("Оплата наличными онлайн не поддерживается!");
  }
}

// Использование
function makePayment(payment, amount) {
  console.log(payment.process(amount));
}

const creditCard = new CreditCardPayment();
const cash = new CashPayment();

makePayment(creditCard, 100); // "Оплата 100 рублей картой"
makePayment(cash, 100);       // Ошибка: Оплата наличными онлайн не поддерживается!

Здесь CashPayment нарушает принцип, потому что не может выполнить метод process, который ожидается от базового класса Payment. Это ломает логику функции makePayment.

Как улучшить?
Разделим поведение, чтобы подклассы соответствовали ожиданиям:

class Payment {
  process(amount) {
    throw new Error("Метод должен быть переопределён");
  }
}

class OnlinePayment extends Payment {
  process(amount) {
    return `Онлайн-оплата на ${amount} рублей`;
  }
}

class CreditCardPayment extends OnlinePayment {
  process(amount) {
    return `Онлайн-оплата картой на ${amount} рублей`;
  }
}

class OfflinePayment extends Payment {
  process(amount) {
    return `Офлайн-оплата на ${amount} рублей`;
  }
}

class CashPayment extends OfflinePayment {
  process(amount) {
    return `Оплата наличными в кассе на ${amount} рублей`;
  }
}

// Использование
function makePayment(payment, amount) {
  console.log(payment.process(amount));
}

const creditCard = new CreditCardPayment();
const cash = new CashPayment();

makePayment(creditCard, 100); // "Онлайн-оплата картой на 100 рублей"
makePayment(cash, 100);       // "Оплата наличными в кассе на 100 рублей"

Теперь CashPayment не обязан поддерживать онлайн-платежи, а CreditCardPayment реализует оба метода. Это делает код предсказуемым и безопасным.

Что это даёт?
— Подклассы не ломают логику, заданную базовым классом.
— Легче добавлять новые подклассы без риска ошибок.
— Разделение ответственности упрощает поддержку.
— Нарушения контракта базового класса исключены.


Совет
При создании наследования проверяйте: "Может ли подкласс заменить базовый без сюрпризов?". Если нет, подумайте о разделении классов или используйте композицию.

#BestPractices #JavaScript

Бывают ситуации, когда нужно развернуть вложенный массив. Некоторые начинают писать reduce и вручную перебирать вложенность. В JS есть готовое решение — метод flat().

Что делает?
Метод flat() разворачивает вложенные массивы на указанную глубину, создавая новый массив.

Примеры

const arr = [1, [2, 3], [4, [5]]];
console.log(arr.flat()); // [1, 2, 3, 4, [5]]

По умолчанию разворачивает массив на 1 уровень вложенности. Но можно указать нужную глубину или даже развернуть массив полностью.

Если массив имеет несколько уровней вложенности, можно указать, на сколько уровней его развернуть:

const arr = [1, [2, 3], [4, [5, [6]]]];
console.log(arr.flat(2)); // [1, 2, 3, 4, 5, [6]]

Здесь flat(2) развернул массив на два уровня.

Если неизвестно количество уровней вложенности в массиве, то подойдет Infinity:

const arr = [1, [2, [3, [4, [5]]]]];
console.log(arr.flat(Infinity)); // [1, 2, 3, 4, 5]

Основные моменты
1. flat() не изменяет исходный массив, а возвращает новый.
2. Без аргумента разворачивает только на один уровень.

#JavaScript

Привет! Начнем неделю с разбора интересного метода padStart.

Метод padStart добавляет в начало строки указанные символы (пробелы по умолчанию), пока строка не достигнет заданной длины.

Синтаксис:

string.padStart(targetLength, padString)

1. targetLength: желаемая длина строки после дополнения.
2. padString: символы, которыми дополняется строка (по умолчанию — пробел).

Как это работает?
Если длина исходной строки меньше targetLength, метод добавляет padString в начало, пока строка не станет нужной длины. Если строка уже длиннее или равна targetLength, она остаётся без изменений.

Примеры использования
1. Форматирование чисел с ведущими нулями

const num = '42';
console.log(num.padStart(5, '0')); // "00042"

2. Форматирование даты

const day = '7';
const month = '3';
console.log(day.padStart(2, '0')); // "07"
console.log(month.padStart(2, '0')); // "03"
// Получаем: "03.07"

Основные моменты:
1. Если padString длиннее, чем нужно, он обрезается до необходимой длины.
2. Если targetLength меньше длины строки, метод возвращает строку без изменений.
3. padStart возвращает новую строку.

Поддержка браузерами: canIUse

#JavaScript

Продолжаем разбирать SOLID. Сегодня буква I — Interface Segregation Principle (принцип разделения интерфейсов).

О чём этот принцип?
Клиенты не должны зависеть от методов, которые они не используют. Интерфейсы должны быть узкими и заточенными под конкретную задачу.

Если проще — интерфейсы и контракты классов должны быть узкими и содержать только те методы, которые действительно нужны конкретному клиенту.
Иначе классам придётся реализовывать ненужные методы или выбрасывать исключения.


Пример плохого подхода

interface Device {
  print(doc: string): void;
  scan(doc: string): void;
  fax(doc: string): void;
}

class SimplePrinter implements Device {
  print(doc: string): void {
    console.log(`Печатаю: ${doc}`);
  }
  scan(doc: string): void {
    throw new Error('Не поддерживает сканирование');
  }
  fax(doc: string): void {
    throw new Error('Не поддерживает факс');
  }
}

SimplePrinter вынужден наследовать методы scan и fax, которые ему не нужны, что нарушает принцип.

Как улучшить?
Разделим интерфейсы на специфичные:

interface Printable {
  print(doc: string): void;
}
interface Scannable {
  scan(doc: string): void;
}
interface Faxable {
  fax(doc: string): void;
}

class SimplePrinter implements Printable {
  print(doc: string): void {
    console.log(`Печатаю: ${doc}`);
  }
}

Теперь каждый класс реализует только то, что нужно.

Что это даёт?
— Код чище и проще для поддержки
— Меньше шансов вызвать неподдерживаемый метод
— Легче расширять систему

Дробите интерфейсы на небольшие части, чтобы классы не наследовали ненужные методы.

#BestPractices #JavaScript #typescript

Привет! Обычно для группировки я использую groupBy из Lodash, но в самом JavaScript тоже есть встроенные методы:
1. Object.groupBy
2. Map.groupBy

Пример данных с которыми будем дальше работать:

const users = [
  { name: "Аня", age: 25, city: "Москва" },
  { name: "Иван", age: 30, city: "Москва" },
  { name: "Оля", age: 22, city: "Казань" },
  { name: "Петя", age: 30, city: "Казань" },
];

Object.groupBy:

const byCity = Object.groupBy(users, user => user.city);
console.log(byCity);
// {
//   "Москва": [ { name: "Аня", age: 25 }, { name: "Иван", age: 30 } ],
//   "Казань": [ { name: "Оля", age: 22 }, { name: "Петя", age: 30 } ]
// }

Map.groupBy:

const byAge = Map.groupBy(users, user => user.age);
console.log(byAge);
// Map(3) {
//   25 => [ { name: "Аня", age: 25 } ],
//   30 => [ { name: "Иван", age: 30 }, { name: "Петя", age: 30 } ],
//   22 => [ { name: "Оля", age: 22 } ]
// }

Разница
1. Object.groupBy - возвращает объект, ключи всегда строки.
2. Map.groupBy - возвращает Map, где ключи могут быть любыми.

Встроенные методы — классная альтернатива без зависимостей, но Lodash остаётся для меня удобным и универсальным инструментом)

#JavaScript

В проектах часто встречается рендер через логический оператор И:

{condition && <div>Component</div>}

Если condition истинно, то отрендерится компонент. Если же условие ложно, то мы ничего не увидим. Причину этого мы разбирали в этом посте(клац).

А что если мы хотим вывести компонент при одном из условий?
Можно написать так:

{condition || secondCondition && <div>Component</div>}

Но тут есть какой-то подвох... Он не всегда бросается в глаза.
Из-за приоритета операторов И(&&) выполняется раньше, чем ИЛИ(||).
Поэтому этот код на самом деле работает так:

{condition || (secondCondition && <div>Component</div>)}

В результате компонент появится только тогда, когда condition ложно, а secondCondition истинно.

Чтобы логика работала правильно, достаточно добавить группировку:

{(condition || secondCondition) && <div>Component</div>}

Теперь компонент отрендерится, если хотя бы одно условие истинно.

Но на самом деле можно упростить ещё больше. Я уже писал про условный рендер в этом посте(тык). Он выглядит понятнее и не заставляет задумываться о приоритетах:

{condition || secondCondition ? <div>Component</div> : null}

Так код читается сразу и не заставляет думать лишний раз.

#BestPractices #JavaScript

Привет! Сегодня разберём метод Promise.withResolvers. Он упрощает работу с промисами, особенно когда нужно управлять их состоянием извне.

Что он делает?
Этот метод создаёт промис и возвращает объект, содержащий сам промис и функции для его разрешения или отклонения.

Синтаксис:

const { promise, resolve, reject } = Promise.withResolvers();

- promise — сам промис.
- resolve(value) — функция для успешного завершения промиса.
- reject(reason) — функция для отклонения промиса.

Теперь можно вызывать resolve(data) или reject(error) в любом месте, и промис перейдёт в соответствующее состояние.

Пример:
Допустим, вы ждёте событие от внешнего API

const { promise, resolve, reject } = Promise.withResolvers();

const ws = new WebSocket('wss://example.com');
ws.onmessage = event => resolve(event.data);
ws.onerror = error => reject(error);

promise
.then(data => console.log('Получено:', data))
.catch(error => console.error('Ошибка:', error));

Раньше писали так:

let resolve, reject;
const promise = new Promise((res, rej) => {
  resolve = res;
  reject = rej;
});

Преимущества withResolvers:
1. Упрощает создание управляемых промисов.
2. Убирает антипаттерн ручного присваивания.
3. Делает код более читаемым и безопасным.

Поддержку смотрите через Can I Use.

#JavaScript #BestPractices

Заканчиваем серии постов про SOLID! Сегодня разберём последнюю букву - D, которая расшифровывается как Dependency Inversion Principle (Принцип инверсии зависимостей).

О чём этот принцип?
Высокоуровневые модули не должны зависеть от низкоуровневых. Оба должны зависеть от абстракций. А абстракции не должны зависеть от деталей — детали зависят от абстракций.

Если проще - зависите от интерфейсов, а не от конкретных классов. Это делает код гибким и независимым от деталей реализации.

Пример плохого подхода:

class Database {
  save(data: string): void {
    console.log(`Сохранено в базе: ${data}`);
  }
}

class UserService {
  private db = new Database();

  saveUser(user: string): void {
    this.db.save(user);
  }
}

const service = new UserService();
service.saveUser("Alice"); // Сохранено в базе: Alice

UserService жёстко привязан к Database. Хотите сохранить данные в файл или API? Придётся переписывать UserService.

Как улучшить?
Введём интерфейс и передадим зависимость через конструктор:

interface Storage {
  save(data: string): void;
}

class Database implements Storage {
  save(data: string): void {
    console.log(`Сохранено в базе: ${data}`);
  }
}

class FileStorage implements Storage {
  save(data: string): void {
    console.log(`Сохранено в файл: ${data}`);
  }
}

class UserService {
  constructor(private storage: Storage) {}

  saveUser(user: string): void {
    this.storage.save(user);
  }
}

const dbService = new UserService(new Database());
dbService.saveUser("Alice"); // Сохранено в базе: Alice

const fileService = new UserService(new FileStorage());
fileService.saveUser("Bob"); // Сохранено в файл: Bob

Теперь UserService зависит от абстракции Storage.

Что это даёт?
- Легко менять реализацию (база, файл, API) без правок в сервисе.
- Подставляйте моки для тестов.
- Зависимости явные, меньше связей.


#BestPractices #JavaScript #typescript

Привет! Недавно мы разбирали нативный метод Object.groupBy, а сегодня разберём задачу с реализацией кастомного groupBy.

Задача
Дан массив объектов:

const users = [
  { name: 'Алиса', age: 21 },
  { name: 'Макс', age: 25 },
  { name: 'Ваня', age: 21 },
];

Нужно сгруппировать по возрасту:

groupBy(users, user => user.age);
// Результат:
// {
//   21: [{ name: 'Алиса', age: 21 }, { name: 'Ваня', age: 21 }],
//   25: [{ name: 'Макс', age: 25 }]
// }

Решение через reduce:

function groupBy(array, fn) {
  return array.reduce((acc, item) => {
    const key = fn(item);
    (acc[key] ||= []).push(item);
    return acc;
  }, {});
}

Как работает?
1. reduce накапливает объект acc.
2. Для каждого item вычисляем ключ через fn(item).
3. Если ключа нет в acc, создаём массив.
4. Добавляем item в этот массив.
5. Возвращаем обновлённый acc.

#JavaScript #interview