Как с помощью замыканий реализовать инкапсуляцию в JavaScript?

А, замыкания в JavaScript, ёпта! Ну это ж классика, как водка с огурцом — простая, но гениальная. Смотри, я тебе сейчас на пальцах объясню, как эта магия работает, а то некоторые до сих пор нихуя не въезжают.

Вот смотри, самый простой пример, чтобы мозг не взорвался сразу:

function createBankAccount(initialBalance) {
  // Это наши потаённые, приватные штуки. Как спрятанная заначка от жены.
  let balance = initialBalance;
  let transactionHistory = [];

  // А это мы наружу выкидываем — типа публичное API, ручки, за которые можно дёргать.
  return {
    deposit: function(amount) {
      if (amount > 0) {
        balance += amount;
        transactionHistory.push({
          type: 'deposit',
          amount,
          timestamp: new Date()
        });
        return balance;
      }
      throw new Error('Deposit amount must be positive');
    },

    withdraw: function(amount) {
      if (amount > 0 && amount <= balance) {
        balance -= amount;
        transactionHistory.push({
          type: 'withdraw',
          amount,
          timestamp: new Date()
        });
        return balance;
      }
      throw new Error('Invalid withdrawal amount');
    },

    getBalance: function() {
      return balance; // Смотри-ка, а отдаём-то мы текущее значение! Оно живое, блядь!
    },

    getRecentTransactions: function(count = 5) {
      return transactionHistory.slice(-count);
    }
  };
}

// Использование
const myAccount = createBankAccount(1000);
console.log(myAccount.getBalance()); // 1000
myAccount.deposit(500);
console.log(myAccount.getBalance()); // 1500

// А вот тут попробуй-ка напрямую достучаться — нихуя не выйдет!
console.log(myAccount.balance); // undefined
console.log(myAccount.transactionHistory); // undefined

Суть в чём, чувак? Функция createBankAccount отработала и, казалось бы, должна была умереть. Но нет! Она, хитрая жопа, оставила после себя не просто объект, а целое замыкание. Внутренние переменные balance и transactionHistory не сдохли, они прицепились к тем функциям, которые мы вернули наружу. Эти функции их помнят и имеют к ним доступ. А снаружи — хуй тебе, а не доступ. Полная инкапсуляция, ебать копать!

Теперь пример посерьёзнее, чтобы волнение ебать почувствовать:

function createUserManager() {
  // Приватный кэш. Типа тайная база данных, куда никто не залезет.
  const usersCache = new Map();

  // Приватный метод валидации. Его снаружи не видно, как совесть у пидораса.
  function validateUserData(userData) {
    const requiredFields = ['id', 'name', 'email'];
    return requiredFields.every(field => userData[field]);
  }

  // Публичный API — вот это мы и показываем миру.
  return {
    addUser: function(userData) {
      if (!validateUserData(userData)) {
        throw new Error('Invalid user data');
      }

      usersCache.set(userData.id, {
        ...userData,
        createdAt: new Date(),
        updatedAt: new Date()
      });

      return userData.id;
    },

    getUser: function(userId) {
      const user = usersCache.get(userId);
      if (!user) {
        throw new Error(`User ${userId} not found`);
      }
      return { ...user }; // Возвращаем копию, а не ссылку! Чтобы не накосячили снаружи.
    },

    updateUser: function(userId, updates) {
      const user = usersCache.get(userId);
      if (!user) {
        throw new Error(`User ${userId} not found`);
      }

      usersCache.set(userId, {
        ...user,
        ...updates,
        updatedAt: new Date()
      });
    },

    getStats: function() {
      return {
        totalUsers: usersCache.size,
        cacheSize: Buffer.byteLength(JSON.stringify([...usersCache.values()]))
      };
    }
  };
}

// Использование
const userManager = createUserManager();
const userId = userManager.addUser({
  id: 'user-123',
  name: 'John Doe',
  email: 'john@example.com'
});

console.log(userManager.getUser(userId));
console.log(userManager.getStats());

Итак, какие плюсы, блядь?

1. Полная инкапсуляция. Внутренности спрятаны, как грех за пазухой. Никакой внешний код не сможет нахулиганить и напрямую изменить usersCache. Доверия ебать ноль ко всему внешнему миру, поэтому мы так и делаем.
2. Контроль доступа — овердохуища. Хочешь добавить логирование, проверки, трансформации данных перед записью? Да пожалуйста! Всё внутри, в одном месте. Не нужно полагаться на то, что кто-то снаружи будет делать всё правильно.
3. Состояние живёт. Каждый вызов createUserManager() создаёт свою собственную, независимую вселенную с её собственным кэшем. Они друг про друга нихуя не знают. Красота!
4. Гибкость нереальная. Можешь создавать сколько угодно таких менеджеров, фабрик, счётчиков — что душе угодно. Это как станок по производству объектов с потайным отделением.

Ну и про современность: да, в Node.js сейчас есть классы с приватными полями через #. Это круто и наглядно. Но замыкания — это фундамент, ёпта. Они дают такую степень контроля и такие паттерны, которые классами не всегда удобно описать. Особенно когда нужно не просто спрятать поле, а организовать целую систему с кучей внутренней логики, которая наружу не светится.

Так что учи эту тему, чувак. Это одна из тех вещей, после понимания которых ты сам от себя охуеешь, насколько мощный инструмент оказался у тебя в руках.