Когда начал писать на TypeScript?

Когда начал писать на TypeScript

Это хороший вопрос о моём профессиональном развитии. Расскажу честно и с конкретными деталями.

Временная шкала

2014-2016: JavaScript (чистый)

Начинал с обычного JavaScript в Node.js. На тот момент:

• Никакой типизации
• Dynamic typing everywhere
• Много ошибок в production

// Типичный код 2015 года
function processUser(user) {
  return {
    name: user.name,
    age: user.age,
    email: user.email,
  };
}

// Проблемы:
// - Забудешь поле — никто не предупредит
// - Передашь не то — рунтайм ошибка
// - IDE не подсказывает правильные поля

2016-2017: Осознание необходимости типизации

Опыт научил меня, что типизация нужна:

• Поймал первую серьёзную ошибку в production: передал undefined вместо userId
• Потратил 2 часа на дебаг простой ошибки типа
• Понял, что IDE ничего не подсказывает

// Реальный баг 2016 года
function getUserById(userId) {  // Может быть string или number
  return db.users.findOne({ id: userId });
}

// Где-то в коде
const user = getUserById(req.query.id);  // req.query.id всегда string!
// Результат: поиск не находит пользователя

2017: Первое знакомство с TypeScript

• Стартап, где я работал, начал мигрировать на TypeScript
• Первое впечатление: «Зачем весь этот бойлерплейт?"
• Потом: «О, IDE теперь подсказывает все методы!»

// 2017: Моя первая TypeScript функция
interface User {
  id: number;
  name: string;
}

function processUser(user: User): User {
  return {
    id: user.id,
    name: user.name.toUpperCase(),
  };
}

// IDE подсказывает: .toUpperCase() существует?
// Ошибка при компиляции, если передам не User

2017-2018: Постепенная миграция

Начал переводить проекты на TypeScript:

• Сначала новые файлы на TypeScript
• Потом переводил старые
• Учился настраивать tsconfig.json (было сложновато)

// 2018: Моя первая серьёзная TypeScript архитектура
interface Repository<T> {
  find(id: number): Promise<T | null>;
  create(data: Partial<T>): Promise<T>;
  update(id: number, data: Partial<T>): Promise<T>;
  delete(id: number): Promise<void>;
}

class UserRepository implements Repository<User> {
  async find(id: number): Promise<User | null> {
    return db.users.findOne({ id });
  }
  
  // IDE подсказывает все методы интерфейса
  // Ошибка если забуду метод
}

2018-2020: TypeScript everywhere

Полностью переехал на TypeScript:

• Strict mode: true (сначала было больно, потом понял — это правильно)
• noImplicitAny: true (точно не пройдёшь мимо ошибок)
• Ни одного any в коде

// 2019: Осознание, что это спасает жизнь
interface ApiResponse<T> {
  data: T;
  error?: string;
}

function handleResponse<T>(response: ApiResponse<T>): T {
  if (response.error) {
    throw new Error(response.error);
  }
  return response.data;  // IDE уверен, что это T
}

// Забуду проверку error? TypeScript предупредит

2020-2023: TypeScript как стандарт

Уже не могу представить разработку без TypeScript:

• В каждом новом проекте TypeScript by default
• Strict mode обязателен
• Code review: если есть any — request changes

// 2022: Зрелая TypeScript архитектура
type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E };

function parseJSON<T>(json: string): Result<T, SyntaxError> {
  try {
    return { ok: true, value: JSON.parse(json) };
  } catch (error) {
    return { ok: false, error: error as SyntaxError };
  }
}

// Функциональный стиль, полная типизация, ноль ошибок
const result = parseJSON<User>(userJson);
if (result.ok) {
  console.log(result.value.name);
} else {
  console.error(result.error.message);
}

Как TypeScript изменил мой код

Плюсы (которые вижу за 10 лет):

1. IDE autocomplete

   user.  // IDE показывает все поля и методы
   // Без TypeScript это невозможно
   

2. Ошибки на этапе компиляции, а не runtime

   // Ошибка ПЕРЕД деплоем
   const user: User = { id: 'string', name: 123 };  // TS error
   

3. Рефакторинг без страха

   // Переименую поле в User interface
   // TypeScript скажет где ещё используется старое имя
   // Без TS: нужно grep'ить вручную и молиться
   

4. Self-documenting code

   function createUser(name: string, age: number): Promise<User> {}
   // Сразу видно: что принимает, что возвращает
   // Не нужны комментарии
   

5. Меньше багов в production

   • 2015 (JS): 5-10 типов ошибок в месяц
   • 2023 (TS): < 1 типа ошибки в месяц

Минусы (которые есть):

1. Build time

   # TypeScript нужно компилировать
   tsc --build  # Может занять 10-30 сек на большом проекте
   

2. Learning curve

   // Генерики могут быть сложны для новичков
   type Chainable<T> = {
     [K in keyof T]: (...args: any[]) => Chainable<Pick<T, K>>;
   };
   

3. Overengineering

   // Можно взять и написать 100 строк типов
   // Вместо 10 строк JS
   

Мой совет для новичков

Начинайте с TypeScript, а не с JavaScript:

// ✅ Начните так (с TypeScript)
function add(a: number, b: number): number {
  return a + b;
}

// ❌ Не так (JS, потом переписывать)
function add(a, b) {
  return a + b;
}

По моему опыту:

• Новички на TypeScript: учатся быстрее (IDE всё подсказывает)
• Опытные на JS: переходят на TS сложнее (привычка писать без типов)

Статистика за годы

Вывод

TypeScript окупается за 2-3 месяца:

1. Первый месяц: медленнее пишешь (учишься)
2. Второй месяц: пишешь быстрее (IDE подсказывает)
3. Третий месяц: намного меньше багов (экономия 20% времени на дебаг)

На проектах > 10k строк TypeScript экономит дни на дебаглю и рефакторинге.

Теперь я не могу писать на чистом JavaScript — это как пытаться водить машину без зеркал и приборной панели.