Как решаешь проблему когда не существует метода для задачи?

Решение проблем без готовых методов

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

Мой процесс (10+ лет опыта)

Шаг 1: Разбей задачу на подзадачи

Если нет готового решения - декомпозируй проблему:

// Задача: Найти все уникальные пары пользователей которые обменивались сообщениями

// Неправильно: "Как это сделать в JavaScript?"
// Правильно: Разбей на части

// 1. Получить все сообщения
// 2. Для каждого сообщения создать пару (от, к)
// 3. Нормализовать пары (сортировать aby их уникальность)
// 4. Удалить дубликаты
// 5. Вернуть результат

function getUniquePairs(messages) {
  const pairs = new Set();
  
  messages.forEach(msg => {
    // Создаем пару и нормализуем (чтобы А-Б = Б-А)
    const [a, b] = [msg.from, msg.to].sort();
    const pair = `${a}|${b}`;
    pairs.add(pair);
  });
  
  return Array.from(pairs).map(pair => pair.split('|'));
}

Шаг 2: Проверь встроенные методы/API

Осмотри базовые возможности языка/фреймворка:

// Задача: Сделать задержку перед действием

// Вариант 1: Встроенная функция - setTimeout
setTimeout(() => {
  console.log('Выполнено через 1 секунду');
}, 1000);

// Вариант 2: Promise (встроено в JS)
const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
await delay(1000);
console.log('Выполнено');

// Вариант 3: Async/await (встроено)
async function doSomething() {
  await new Promise(r => setTimeout(r, 1000));
  console.log('Выполнено');
}

Шаг 3: Поищи готовую библиотеку

// Задача: Отправить HTTP запрос

// Встроено в браузер - Fetch API
const response = await fetch('/api/users');
const data = await response.json();

// Если нужно больше функций - используй axios
import axios from 'axios';
const { data } = await axios.get('/api/users');

// Но сначала используй встроенное!

Шаг 4: Реализуй свое решение

Если не существует - напиши сам с нуля:

// Задача: Форматировать дату в специальном формате
// Есть встроенный Intl.DateTimeFormat, но он не поддерживает все случаи

// Решение: Напиши свою функцию
function formatDate(date, format) {
  const map = {
    'YYYY': date.getFullYear(),
    'MM': String(date.getMonth() + 1).padStart(2, '0'),
    'DD': String(date.getDate()).padStart(2, '0'),
    'HH': String(date.getHours()).padStart(2, '0'),
    'mm': String(date.getMinutes()).padStart(2, '0'),
  };
  
  return format.replace(/YYYY|MM|DD|HH|mm/g, match => map[match]);
}

// Использование
formatDate(new Date(), 'DD.MM.YYYY'); // "25.03.2024"

Примеры из реальной практики

Пример 1: Дебаунсирование (Debounce)

Требование: вызвать функцию только через N времени после того как она перестанет вызываться.

// Задача: User печатает, не хочешь отправлять каждый символ на сервер

// Решение: Debounce функция
function debounce(func, delay) {
  let timeoutId;
  
  return function(...args) {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => {
      func.apply(this, args);
    }, delay);
  };
}

// Использование
const handleSearch = debounce((query) => {
  console.log('Ищу:', query);
  // API запрос
}, 500);

input.addEventListener('input', (e) => handleSearch(e.target.value));
// API запрос отправится только через 500ms после последнего ввода

Пример 2: Throttle (Ограничение частоты)

Требование: вызвать функцию максимум N раз в секунду.

// Задача: During scroll не хочешь вызывать обработчик 60+ раз

function throttle(func, limit) {
  let inThrottle;
  
  return function(...args) {
    if (!inThrottle) {
      func.apply(this, args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
}

// Использование
const handleScroll = throttle(() => {
  console.log('Scroll обработан');
  // Expensive операция
}, 100);

window.addEventListener('scroll', handleScroll);
// Будет вызвана максимум 10 раз в секунду (каждые 100ms)

Пример 3: Кэширование результатов (Memoization)

Требование: не пересчитывать одинаковые результаты.

// Задача: Функция вычисления факториала (дорогая операция)

function memoize(func) {
  const cache = new Map();
  
  return function(...args) {
    const key = JSON.stringify(args);
    
    if (cache.has(key)) {
      console.log('Из кэша');
      return cache.get(key);
    }
    
    const result = func.apply(this, args);
    cache.set(key, result);
    return result;
  };
}

const factorial = (n) => n <= 1 ? 1 : n * factorial(n - 1);
const memoFactorial = memoize(factorial);

console.log(memoFactorial(5)); // Вычислено: 120
console.log(memoFactorial(5)); // Из кэша: 120

Пример 4: Deep Clone объекта

Требование: глубокое копирование объекта со всеми вложенностями.

// Задача: Скопировать объект с массивами и объектами внутри

function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') {
    return obj; // Примитивные типы
  }
  
  if (obj instanceof Date) {
    return new Date(obj.getTime());
  }
  
  if (obj instanceof Array) {
    return obj.map(item => deepClone(item));
  }
  
  if (obj instanceof Object) {
    const cloned = {};
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        cloned[key] = deepClone(obj[key]);
      }
    }
    return cloned;
  }
}

// Использование
const original = { a: 1, b: { c: 2 }, d: [1, 2, 3] };
const cloned = deepClone(original);
cloned.b.c = 999; // original.b.c остается 2

Пример 5: Event Emitter

Требование: публиковать события и подписываться на них (Observer Pattern).

// Задача: Компоненты должны общаться через события

class EventEmitter {
  constructor() {
    this.events = {};
  }
  
  on(eventName, callback) {
    if (!this.events[eventName]) {
      this.events[eventName] = [];
    }
    this.events[eventName].push(callback);
  }
  
  off(eventName, callback) {
    if (this.events[eventName]) {
      this.events[eventName] = this.events[eventName].filter(cb => cb !== callback);
    }
  }
  
  emit(eventName, data) {
    if (this.events[eventName]) {
      this.events[eventName].forEach(callback => callback(data));
    }
  }
}

// Использование
const emitter = new EventEmitter();

emitter.on('userLogin', (user) => {
  console.log(`${user.name} вошел в систему`);
});

emitter.emit('userLogin', { name: 'John' }); // "John вошел в систему"

Методология разработки

1. Начни с простейшего решения

// Задача: Сумма всех чисел в массиве

// Простое решение
const sum = (arr) => {
  let total = 0;
  for (let num of arr) {
    total += num;
  }
  return total;
};

// Потом можно оптимизировать
const sum = (arr) => arr.reduce((a, b) => a + b, 0);

2. Напиши тесты ДО решения (TDD)

// Сначала тесты
test('getUniquePairs should return unique pairs', () => {
  const messages = [
    { from: 'A', to: 'B' },
    { from: 'B', to: 'A' },
    { from: 'B', to: 'C' },
  ];
  
  const result = getUniquePairs(messages);
  expect(result).toHaveLength(2); // A-B и B-C
});

// Потом реализация
function getUniquePairs(messages) {
  const pairs = new Set();
  messages.forEach(msg => {
    const [a, b] = [msg.from, msg.to].sort();
    pairs.add(`${a}|${b}`);
  });
  return Array.from(pairs).map(p => p.split('|'));
}

3. Ищи паттерны и абстракции

// Много похожих задач часто решаются одним паттерном

// Паттерн: Функция которая оборачивает другую функцию
function retry(fn, maxAttempts = 3) {
  return async (...args) => {
    for (let i = 0; i < maxAttempts; i++) {
      try {
        return await fn(...args);
      } catch (err) {
        if (i === maxAttempts - 1) throw err;
      }
    }
  };
}

// Используется везде
const fetchWithRetry = retry(() => fetch('/api/data'));
await fetchWithRetry();

Частые решения

Вывод

Процесс решения проблем без готовых методов:

1. Разбей задачу на части
2. Проверь встроенные методы (обычно 90% решений есть)
3. Поищи библиотеку (если много логики)
4. Реализуй свое решение (просто и понятно)
5. Напиши тесты
6. Оптимизируй если нужно

Главное: не паниковать. Любую задачу можно разбить на простые части, а каждую часть решить базовыми средствами языка.