Как комбинировать хеш-таблицы?

Комбинирование объектов как хеш-таблиц в JavaScript

Хеш-таблицы в JavaScript реализуются через объекты и Map. Комбинирование означает объединение нескольких таблиц в одну или создание сложных структур из простых. Есть несколько способов в зависимости от случая использования.

Базовые операции с объектами

// Две хеш-таблицы
const user1 = {
  name: 'John',
  age: 30
};

const user2 = {
  email: 'john@example.com',
  role: 'admin'
};

// Способ 1: Object.assign (мутирует первый объект)
const merged1 = Object.assign({}, user1, user2);
// { name: 'John', age: 30, email: 'john@example.com', role: 'admin' }

// Способ 2: Spread operator (рекомендуется)
const merged2 = { ...user1, ...user2 };
// { name: 'John', age: 30, email: 'john@example.com', role: 'admin' }

// При конфликте ключей последний объект побеждает
const override = { ...user1, age: 25 };
// { name: 'John', age: 25 }

Глубокое объединение (deep merge)

Для вложенных объектов нужно глубокое объединение:

function deepMerge(target, source) {
  const output = Object.assign({}, target);
  
  if (isObject(target) && isObject(source)) {
    Object.keys(source).forEach(key => {
      if (isObject(source[key])) {
        if (!(key in target)) {
          Object.assign(output, { [key]: source[key] });
        } else {
          output[key] = deepMerge(target[key], source[key]);
        }
      } else {
        Object.assign(output, { [key]: source[key] });
      }
    });
  }
  
  return output;
}

function isObject(item) {
  return item && typeof item === 'object' && !Array.isArray(item);
}

// Использование
const config1 = {
  api: {
    host: 'localhost',
    port: 3000
  },
  debug: true
};

const config2 = {
  api: {
    port: 8080,
    timeout: 5000
  }
};

const merged = deepMerge(config1, config2);
// {
//   api: {
//     host: 'localhost',
//     port: 8080,
//     timeout: 5000
//   },
//   debug: true
// }

Использование Map для комплексных случаев

Map удобнее чем объекты когда нужны нестроковые ключи:

// Создание двух Map'ов
const map1 = new Map();
map1.set('user', { id: 1, name: 'John' });
map1.set('post', { id: 1, title: 'Hello' });

const map2 = new Map();
map2.set('user', { role: 'admin' });
map2.set('comment', { id: 1, text: 'Nice' });

// Комбинирование Map'ов
function mergeMaps(map1, map2) {
  const merged = new Map(map1);
  
  for (const [key, value] of map2) {
    if (merged.has(key) && typeof value === 'object') {
      // Объединить значения если оба объекты
      merged.set(key, { ...merged.get(key), ...value });
    } else {
      merged.set(key, value);
    }
  }
  
  return merged;
}

const combined = mergeMaps(map1, map2);
// Map {
//   'user' => { id: 1, name: 'John', role: 'admin' },
//   'post' => { id: 1, title: 'Hello' },
//   'comment' => { id: 1, text: 'Nice' }
// }

Использование в React состоянии

function MyComponent() {
  const [state, setState] = useState({});
  
  // Обновить часть состояния
  const updateState = (updates) => {
    setState(prevState => ({
      ...prevState,
      ...updates
    }));
  };
  
  // Обновить вложенное поле
  const updateNested = (path, value) => {
    setState(prevState => ({
      ...prevState,
      [path]: {
        ...prevState[path],
        ...value
      }
    }));
  };
  
  return (
    <div>
      <button onClick={() => updateState({ name: 'John' })}>
        Update Name
      </button>
    </div>
  );
}

Распределение конфигураций

Частый паттерн — объединение конфигураций слоев:

// Базовая конфиг
const baseConfig = {
  timeout: 5000,
  retries: 3,
  debug: false
};

// Конфиг для dev
const devConfig = {
  debug: true,
  logLevel: 'verbose'
};

// Конфиг для production
const prodConfig = {
  timeout: 30000,
  retries: 5,
  debug: false,
  logLevel: 'error'
};

// Выбрать конфиг в зависимости от окружения
const config = process.env.NODE_ENV === 'production'
  ? { ...baseConfig, ...prodConfig }
  : { ...baseConfig, ...devConfig };

Кеширование с хеш-таблицами

class Cache {
  constructor() {
    this.store = new Map();
  }
  
  // Добавить ключ-значение
  set(key, value) {
    this.store.set(key, {
      value,
      timestamp: Date.now()
    });
  }
  
  // Получить значение
  get(key) {
    const item = this.store.get(key);
    return item ? item.value : undefined;
  }
  
  // Объединить с другой таблицей
  merge(otherCache) {
    const merged = new Cache();
    
    // Скопировать текущую
    for (const [key, item] of this.store) {
      merged.set(key, item.value);
    }
    
    // Скопировать другую (перезаписыает дубликаты)
    for (const [key, item] of otherCache.store) {
      merged.set(key, item.value);
    }
    
    return merged;
  }
}

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

const cache2 = new Cache();
cache2.set('user2', { id: 2, name: 'Jane' });

const merged = cache1.merge(cache2);

Индексирование данных массивов

// Преобразовать массив в хеш-таблицу для быстрого поиска
const users = [
  { id: 1, name: 'John' },
  { id: 2, name: 'Jane' },
  { id: 3, name: 'Bob' }
];

// Способ 1: reduce
const userMap = users.reduce((map, user) => {
  return { ...map, [user.id]: user };
}, {});

// Способ 2: Object.fromEntries с Map
const userMapV2 = Object.fromEntries(
  users.map(user => [user.id, user])
);

// Быстрый поиск O(1) вместо O(n)
const user = userMap[2];  // { id: 2, name: 'Jane' }

Композиция нескольких хеш-таблиц

function composeConfig(...configs) {
  return configs.reduce((result, config) => {
    return { ...result, ...config };
  }, {});
}

const apiConfig = { baseURL: 'https://api.example.com' };
const authConfig = { token: 'abc123' };
const logConfig = { logLevel: 'info' };

const finalConfig = composeConfig(
  apiConfig,
  authConfig,
  logConfig
);
// {
//   baseURL: 'https://api.example.com',
//   token: 'abc123',
//   logLevel: 'info'
// }

Фильтрация при комбинировании

function mergeAndFilter(obj1, obj2, allowedKeys) {
  const merged = { ...obj1, ...obj2 };
  
  return Object.keys(merged)
    .filter(key => allowedKeys.includes(key))
    .reduce((result, key) => {
      result[key] = merged[key];
      return result;
    }, {});
}

const user = { name: 'John', age: 30, password: 'secret' };
const extra = { role: 'admin', email: 'john@example.com' };

const safe = mergeAndFilter(
  user,
  extra,
  ['name', 'age', 'role', 'email']  // password исключен
);
// { name: 'John', age: 30, role: 'admin', email: 'john@example.com' }

Сравнение методов

Для большинства случаев достаточно spread operator. Для сложных вложенных структур используй deepMerge или библиотеки типа lodash.merge.