Инкапсуляция и модули в JavaScript: принципы структурирования кода

function createCounter() {
// Приватная переменная
let count = 0;

return {
increment() { count++; },
decrement() { count--; },
getValue() { return count; }
};
}

const counter = createCounter();
counter.increment();
console.log(counter.getValue()); // 1
console.log(counter.count); // undefined – переменная недоступна извне

const calculator = (function() {
// Приватные переменные и функции
let result = 0;

function validateNumber(num) {
return typeof num === 'number' && !isNaN(num);
}

// Публичный интерфейс
return {
add(num) {
if (validateNumber(num)) result += num;
return this; // Для цепочки вызовов
},
subtract(num) {
if (validateNumber(num)) result -= num;
return this;
},
getResult() {
return result;
}
};
})();

calculator.add(5).subtract(2);
console.log(calculator.getResult()); // 3

class BankAccount {
// Приватное поле (поддерживается в современных браузерах)
#balance = 0;

constructor(initialBalance) {
if (initialBalance > 0) {
this.#balance = initialBalance;
}
}

deposit(amount) {
if (amount > 0) {
this.#balance += amount;
return true;
}
return false;
}

withdraw(amount) {
if (amount > 0 && this.#balance >= amount) {
this.#balance -= amount;
return true;
}
return false;
}

getBalance() {
// Возвращаем копию для предотвращения изменений
return this.#balance;
}
}

const account = new BankAccount(1000);
account.withdraw(500);
console.log(account.getBalance()); // 500
console.log(account.#balance); // SyntaxError: Private field '#balance' must be declared in an enclosing class

const _temperature = Symbol('temperature');
const _pressure = Symbol('pressure');

class WeatherStation {
constructor(temperature, pressure) {
this[_temperature] = temperature;
this[_pressure] = pressure;
}

getWeatherData() {
return {
temperature: this[_temperature],
pressure: this[_pressure]
};
}
}

const station = new WeatherStation(22, 760);
console.log(station.getWeatherData()); // { temperature: 22, pressure: 760 }
console.log(station[_temperature]); // Undefined если _temperature не доступен

// userApi.js – отвечает только за взаимодействие с API пользователей
export async function fetchUsers() {
return await fetch('/api/users').then(res => res.json());
}

export async function updateUserProfile(userId, data) {
return await fetch(`/api/users/${userId}`, {
method: 'PUT',
body: JSON.stringify(data)
}).then(res => res.json());
}

// userValidation.js – отвечает только за валидацию данных пользователя
export function validateUserData(userData) {
const errors = {};

if (!userData.name || userData.name.length < 2) {
errors.name = 'Имя должно содержать не менее 2 символов';
}

if (!userData.email || !/\S+@\S+\.\S+/.test(userData.email)) {
errors.email = 'Укажите корректный email';
}

return {
isValid: Object.keys(errors).length === 0,
errors
};
}

// validators.js – набор стратегий валидации
export const validators = {
required: value => !!value || 'Обязательное поле',
email: value => /\S+@\S+\.\S+/.test(value) || 'Некорректный email',
minLength: min => value => 
(!value || value.length >= min) || `Минимум ${min} символов`
};

// Можно расширить, добавив новые валидаторы без изменения существующих
validators.phoneNumber = value => 
/^\+?\d{10,12}$/.test(value) || 'Некорректный номер телефона';

// Вместо экспорта целого класса с множеством методов
// userManager.js
export function getUserById(id) { /* ... */ }
export function searchUsersByName(name) { /* ... */ }

// Отдельный модуль для административных функций
// userAdmin.js
export function banUser(id) { /* ... */ }
export function promoteToAdmin(id) { /* ... */ }

/src
/components
/Button
/Form
/Modal
/services
/api
/auth
/analytics
/utils
/formatters
/validators
/store
/user
/products
/cart

/src
/features
/auth
/components
/services
/store
/utils
/products
/components
/services
/store
/utils
/checkout
/components
/services
/store
/utils
/common
/components
/utils

/src
/core # Ядро системы, базовая инфраструктура
/api
/config
/store
/features # Функциональные модули
/auth
/products
/checkout
/shared # Общие компоненты и утилиты
/components
/utils
/hooks
/pages # Страницы приложения
/Home
/Profile
/Cart

// math.js
const PI = 3.14159;

function add(a, b) {
return a + b;
}

function multiply(a, b) {
return a * b;
}

// Экспорт отдельных значений
module.exports = {
PI,
add,
multiply
};

// Альтернативный вариант экспорта
// exports.PI = PI;
// exports.add = add;
// exports.multiply = multiply;

// app.js
const math = require('./math'); // Импорт всего модуля
const { PI, add } = require('./math'); // Деструктуризация при импорте

console.log(math.multiply(2, 3)); // 6
console.log(add(2, 3)); // 5
console.log(PI); // 3.14159

// math.js
export const PI = 3.14159;

export function add(a, b) {
return a + b;
}

export function multiply(a, b) {
return a * b;
}

// Альтернативный синтаксис
// const PI = 3.14159;
// function add(a, b) { return a + b; }
// function multiply(a, b) { return a * b; }
// export { PI, add, multiply };

// Экспорт по умолчанию
export default {
version: '1.0.0',
author: 'John Doe'
};

// app.js
import { PI, add } from './math.js'; // Именованный импорт
import * as math from './math.js'; // Импорт всего модуля
import metadata from './math.js'; // Импорт по умолчанию

console.log(PI); // 3.14159
console.log(add(2, 3)); // 5
console.log(math.multiply(2, 3)); // 6
console.log(metadata.version); // 1.0.0

// math.js
define(['dependency1', 'dependency2'], function(dep1, dep2) {
const PI = 3.14159;

function add(a, b) {
return a + b;
}

function multiply(a, b) {
return a * b;
}

return {
PI: PI,
add: add,
multiply: multiply
};
});

// app.js
require(['math'], function(math) {
console.log(math.add(2, 3)); // 5
});

// umdModule.js
(function(root, factory) {
if (typeof define === 'function' && define.amd) {
// AMD
define(['dependency'], factory);
} else if (typeof module === 'object' && module.exports) {
// CommonJS
module.exports = factory(require('dependency'));
} else {
// Browser globals
root.myModule = factory(root.dependency);
}
}(typeof self !== 'undefined' ? self : this, function(dependency) {
return {
// Модуль
doSomething: function() {
return 'Сделано!';
}
};
}));

// barrel file (index.js)
export { default as Button } from './Button';
export { default as Input } from './Input';
export { default as Select } from './Select';

// usage
import { Button, Input } from './components';
// Вместо 
// import Button from './components/Button';
// import Input from './components/Input';

// Модуль для работы с хранилищем
const StorageModule = (function() {
// Приватные переменные и функции
const prefix = 'app_';

function getKeyWithPrefix(key) {
return `${prefix}${key}`;
}

function isSupported() {
try {
return 'localStorage' in window && window.localStorage !== null;
} catch (e) {
return false;
}
}

// Публичный API
return {
set(key, value) {
if (!isSupported()) return false;

try {
localStorage.setItem(
getKeyWithPrefix(key),
JSON.stringify(value)
);
return true;
} catch (e) {
console.error('Storage error:', e);
return false;
}
},

get(key, defaultValue = null) {
if (!isSupported()) return defaultValue;

try {
const value = localStorage.getItem(getKeyWithPrefix(key));
return value ? JSON.parse(value) : defaultValue;
} catch (e) {
console.error('Storage error:', e);
return defaultValue;
}
},

remove(key) {
if (!isSupported()) return false;

try {
localStorage.removeItem(getKeyWithPrefix(key));
return true;
} catch (e) {
console.error('Storage error:', e);
return false;
}
},

clear() {
if (!isSupported()) return false;

try {
// Удаляем только элементы с нашим префиксом
Object.keys(localStorage)
.filter(key => key.startsWith(prefix))
.forEach(key => localStorage.removeItem(key));
return true;
} catch (e) {
console.error('Storage error:', e);
return false;
}
}
};
})();

// Использование
StorageModule.set('user', { id: 1, name: 'John' });
const user = StorageModule.get('user');

// Фабрика HTTP-клиентов
const HTTPClientFactory = {
createJSONClient(baseURL) {
const headers = {
'Content-Type': 'application/json',
'Accept': 'application/json'
};

return {
async get(url, params = {}) {
const queryString = Object.entries(params)
.map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
.join('&');
const fullURL = `${baseURL}${url}${queryString ? `?${queryString}` : ''}`;

const response = await fetch(fullURL, { headers });
return response.json();
},

async post(url, data) {
const response = await fetch(`${baseURL}${url}`, {
method: 'POST',
headers,
body: JSON.stringify(data)
});
return response.json();
}

// Другие методы...
};
},

createFormClient(baseURL) {
const headers = {
'Content-Type': 'application/x-www-form-urlencoded'
};

return {
// Реализация методов для работы с формами...
};
}
};

// Использование
const apiClient = HTTPClientFactory.createJSONClient('https://api.example.com');
apiClient.get('/users/1').then(user => console.log(user));

// Фасад для работы с API социальной сети
class SocialMediaFacade {
constructor(apiKey) {
// Инициализация сложных подсистем
this.userAPI = new UserAPIClient(apiKey);
this.postAPI = new PostAPIClient(apiKey);
this.mediaAPI = new MediaAPIClient(apiKey);
this.analyticsAPI = new AnalyticsAPIClient(apiKey);
}

// Простой унифицированный интерфейс
async sharePost(userId, content, mediaIds = []) {
try {
// Проверка прав пользователя
const user = await this.userAPI.getUserById(userId);
if (!user.canPost) {
throw new Error('User does not have permission to post');
}

// Проверка и подготовка медиа
const mediaItems = mediaIds.length 
? await this.mediaAPI.getMediaItems(mediaIds) 
: [];

// Создание поста с обработкой ошибок и повторными попытками
const post = await this.postAPI.createPost({
userId,
content,
mediaItems: mediaItems.map(m => m.id)
});

// Логирование для аналитики
this.analyticsAPI.logUserAction(userId, 'post_created', {
postId: post.id,
hasMedia: mediaItems.length > 0
});

return {
success: true,
postId: post.id,
url: `https://social.example.com/posts/${post.id}`
};
} catch (error) {
console.error('Failed to share post:', error);
return {
success: false,
error: error.message
};
}
}

// Другие простые методы для сложных операций...
}

// Использование
const socialMedia = new SocialMediaFacade('api_key_123');
socialMedia.sharePost(123, 'Hello, world!').then(result => {
if (result.success) {
console.log(`Post shared: ${result.url}`);
} else {
console.error(`Failed to share post: ${result.error}`);
}
});

// Команды для редактора текста
class TextEditor {
constructor(text = '') {
this.text = text;
this.history = [];
}

executeCommand(command) {
this.history.push(command);
command.execute(this);
}

undo() {
if (this.history.length > 0) {
const command = this.history.pop();
command.undo(this);
}
}

getText() {
return this.text;
}

setText(text) {
this.text = text;
}
}

// Базовый класс команды
class EditorCommand {
execute() {
throw new Error('Method not implemented');
}

undo() {
throw new Error('Method not implemented');
}
}

// Конкретные команды
class InsertTextCommand extends EditorCommand {
constructor(position, text) {
super();
this.position = position;
this.text = text;
}

execute(editor) {
const currentText = editor.getText();
const newText = 
currentText.slice(0, this.position) + 
this.text + 
currentText.slice(this.position);
editor.setText(newText);
}

undo(editor) {
const currentText = editor.getText();
const newText = 
currentText.slice(0, this.position) + 
currentText.slice(this.position + this.text.length);
editor.setText(newText);
}
}

class DeleteTextCommand extends EditorCommand {
constructor(position, length) {
super();
this.position = position;
this.length = length;
this.deletedText = '';
}

execute(editor) {
const currentText = editor.getText();
this.deletedText = currentText.slice(this.position, this.position + this.length);
const newText = 
currentText.slice(0, this.position) + 
currentText.slice(this.position + this.length);
editor.setText(newText);
}

undo(editor) {
const currentText = editor.getText();
const newText = 
currentText.slice(0, this.position) + 
this.deletedText + 
currentText.slice(this.position);
editor.setText(newText);
}
}

// Использование
const editor = new TextEditor('Hello');
editor.executeCommand(new InsertTextCommand(5, ', world'));
console.log(editor.getText()); // "Hello, world"
editor.executeCommand(new DeleteTextCommand(5, 7));
console.log(editor.getText()); // "Hello"
editor.undo();
console.log(editor.getText()); // "Hello, world"

// Стратегии валидации
class ValidationContext {
constructor(strategy) {
this.strategy = strategy;
}

setStrategy(strategy) {
this.strategy = strategy;
}

validate(data) {
return this.strategy.validate(data);
}
}

// Интерфейс стратегии
class ValidationStrategy {
validate(data) {
throw new Error('Method not implemented');
}
}

// Конкретные стратегии
class EmailValidator extends ValidationStrategy {
validate(email) {
const regex = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$/;
return {
isValid: regex.test(email),
message: regex.test(email) ? '' : 'Некорректный email адрес'
};
}
}

class PasswordValidator extends ValidationStrategy {
constructor(minLength = 8) {
super();
this.minLength = minLength;
}

validate(password) {
const hasUpperCase = /[A-Z]/.test(password);
const hasLowerCase = /[a-z]/.test(password);
const hasDigit = /[0-9]/.test(password);
const hasMinLength = password.length >= this.minLength;

const isValid = hasUpperCase && hasLowerCase && hasDigit && hasMinLength;

let message = '';
if (!isValid) {
message = 'Пароль должен содержать:';
if (!hasMinLength) message += `\n- не менее ${this.minLength} символов`;
if (!hasUpperCase) message += '\n- хотя бы одну заглавную букву';
if (!hasLowerCase) message += '\n- хотя бы одну строчную букву';
if (!hasDigit) message += '\n- хотя бы одну цифру';
}

return { isValid, message };
}
}

// Использование
const validator = new ValidationContext(new EmailValidator());
console.log(validator.validate('user@example.com')); // { isValid: true, message: '' }
console.log(validator.validate('invalid-email')); // { isValid: false, message: 'Некорректный email адрес' }

validator.setStrategy(new PasswordValidator(10));
console.log(validator.validate('Passw0rd123')); // { isValid: true, message: '' }
console.log(validator.validate('weak')); // { isValid: false, message: '...' }