Какие знаешь парадигмы программирования кроме ООП?

Парадигмы программирования (кроме ООП)

Парадигма — это стиль мышления и набор принципов, которые определяют как писать код. JavaScript поддерживает множество парадигм, каждая решает разные задачи.

1. Процедурное программирование

Идея: Программа состоит из процедур (функций), которые пошагово выполняют операции.

// Шаг за шагом, команда за командой
function processData(data) {
  let result = [];
  
  for (let i = 0; i < data.length; i++) {        // Шаг 1
    let processed = data[i] * 2;                   // Шаг 2
    result.push(processed);                        // Шаг 3
  }
  
  return result;
}

Особенности:

• Явное управление состоянием
• Побочные эффекты везде
• Хорошо для простых скриптов
• Сложно масштабируется

2. Функциональное программирование (FP)

Идея: Функции — это первоклассные объекты. Избегаем побочных эффектов и мутаций.

// Функциональный подход - чистые функции
const numbers = [1, 2, 3, 4, 5];

const doubled = numbers
  .map(n => n * 2)            // Трансформация
  .filter(n => n > 5)         // Фильтрация
  .reduce((sum, n) => sum + n, 0); // Агрегирование

console.log(doubled); // 24 (4*2 + 6*2 + 8*2 + 10*2)

Ключевые концепции:

// Чистые функции (pure functions)
function add(a, b) {
  return a + b; // Всегда одинаковый результат для одинаковых входов
}

// Не чистая функция
let multiplier = 2;
function multiply(n) {
  return n * multiplier; // Зависит от внешнего состояния
}

// Неизменяемость (immutability)
const original = { name: 'John', age: 30 };
const updated = { ...original, age: 31 }; // Новый объект, не мутирован

// Композиция функций
const compose = (f, g) => (x) => f(g(x));
const addOne = (x) => x + 1;
const double = (x) => x * 2;
const doubleThenAddOne = compose(addOne, double);

console.log(doubleThenAddOne(5)); // 11 (5*2 = 10, 10+1 = 11)

// Хигер-ордер функции (higher-order functions)
function makeMultiplier(factor) {
  return function(number) {
    return number * factor;
  };
}

const double = makeMultiplier(2);
const triple = makeMultiplier(3);

Преимущества:

• Легче тестировать (чистые функции)
• Легче понять (без побочных эффектов)
• Легче распараллелить

Пример в React:

// Функциональный подход - React Hooks
function Counter() {
  const [count, setCount] = useState(0);
  
  const increment = useCallback(() => {
    setCount(prev => prev + 1); // Чистая функция (prev => prev + 1)
  }, []);
  
  return <button onClick={increment}>{count}</button>;
}

3. Декларативное программирование

Идея: Описываем ЧТО мы хотим, а не КАК это делать.

// Процедурное (КАК)
const numbers = [1, 2, 3, 4, 5];
const evenNumbers = [];

for (let i = 0; i < numbers.length; i++) {
  if (numbers[i] % 2 === 0) {
    evenNumbers.push(numbers[i]);
  }
}

// Декларативное (ЧТО)
const evenNumbers = numbers.filter(n => n % 2 === 0);

// React - декларативный UI
function App() {
  return (
    <div>
      <h1>Hello</h1>
      <button>Click me</button>
    </div>
  );
}

// SQL - всегда декларативный
SELECT * FROM users WHERE age > 18 ORDER BY name;

4. Реактивное программирование

Идея: Код реагирует на изменения данных. Часто используется для асинхронных операций.

// Observables (RxJS)
import { fromEvent } from 'rxjs';
import { debounceTime, map } from 'rxjs/operators';

const searchInput = document.querySelector('input');

fromEvent(searchInput, 'input')
  .pipe(
    debounceTime(300),
    map(event => event.target.value),
    // Когда значение изменяется, всё реагирует автоматически
  )
  .subscribe(query => {
    console.log('Ищем:', query);
  });

// Vue Reactivity
const reactive = () => {
  const count = ref(0);
  
  watch(() => count.value, (newValue) => {
    console.log('Count changed to:', newValue);
  });
  
  return { count };
};

5. Логическое программирование

Идея: Описываем факты и правила, система выводит результаты.

// В JavaScript редко используется, но Prolog это делает

// Факты:
father(john, mary).
father(john, bob).
mother(susan, mary).
mother(susan, bob).

// Правила:
parent(X, Y) :- father(X, Y).
parent(X, Y) :- mother(X, Y).

// Запрос:
?- parent(john, mary).
% true

6. Событийное программирование (Event-Driven)

Идея: Программа реагирует на события (клики, загрузка, ошибки).

// DOM события
button.addEventListener('click', () => {
  console.log('Button clicked!');
});

// Custom события
const myEvent = new CustomEvent('userLoggedIn', { detail: { userId: 123 } });

document.addEventListener('userLoggedIn', (e) => {
  console.log('User logged in:', e.detail.userId);
});

document.dispatchEvent(myEvent);

// Node.js EventEmitter
const EventEmitter = require('events');
const emitter = new EventEmitter();

emitter.on('message', (text) => {
  console.log('Message:', text);
});

emitter.emit('message', 'Hello!');

7. Модульное программирование

Идея: Разделяем код на модули (части).

// CommonJS модули
module.exports = { add, subtract };
const math = require('./math');

// ES6 модули
export const add = (a, b) => a + b;
import { add } from './math.js';

// Инкапсуляция
const createCounter = () => {
  let count = 0; // Приватное состояние
  
  return {
    increment: () => count++,
    getCount: () => count
  };
};

8. Программирование с гарантиями (Contract-Based)

Идея: Функции имеют контракты (precondition, postcondition).

// Явное описание контракта
function divide(numerator, denominator) {
  // Precondition: denominator не должен быть 0
  if (denominator === 0) {
    throw new Error('Division by zero');
  }
  
  return numerator / denominator;
  // Postcondition: результат всегда число
}

Сравнение парадигм

Комбинирование парадигм

// Современный JavaScript комбинирует несколько парадигм

// React компонент = функциональное + декларативное
function UserProfile({ userId }) {
  const [user, setUser] = useState(null);
  
  // Реактивное программирование (эффект)
  useEffect(() => {
    fetch(`/api/users/${userId}`)
      .then(r => r.json())
      .then(setUser); // Реагируем на изменение userId
  }, [userId]);
  
  // Декларативный UI
  return (
    <div>
      {user && <h1>{user.name}</h1>}
    </div>
  );
}

Вывод

Нет идеальной парадигмы. JavaScript позволяет:

• Писать процедурный код (старые скрипты)
• Функциональное программирование (современные подходы)
• Декларативное (React, templates)
• Реактивное (RxJS, Vue)
• Событийное (всегда в браузере)

Лучшие практики: Комбинируй парадигмы для конкретной задачи:

• Функциональное для логики обработки данных
• Декларативное для UI
• События для взаимодействия
• Модули для организации