HowProgrammingWorks - JavaScript and Node.js Programming

⭐️ IndexedDB: сравните 3 реализации близкие по функциональности, но с разными подходами - Native: чистый API indexedDB - Enterprise: обертка API indexedDB с дополнительными церемониями - Pragmatic: обертка API indexedDB с DSL без церемоний 👉 https://github.com/HowProgrammingWorks/indexedDB

Адепты AI этого еще не поняли, но программирование при помощи ассистентов, быстро начинается, хорошо продолжаться, но никогда не закончится, такие системы очень сложно довести до продакшена, а уж тем более, они не выдерживают прохождения через все этапы жизненного цикла, принятие нагрузки и оптимизацию под изменение запросов пользователей, интеграция вообще превращается в ад, ю велкам

Тупеем от LLM? Та не, мы от Stackoverflow и Search engine уже отупели, и уровень не упадет ниже, потому, что мы тренируемся находить виноватых в факапе спринтов, сремся в интернетах, в унитаз целимся и попадаем... иногда

👩‍💻 Added more paradigms and code styles: event-driven (6 styles), traits and ownership (Rust inspired) just as a concept: https://github.com/HowProgrammingWorks/Paradigms/tree/main/JavaScript

К другим парадигмам добавлены примеры с монадическими вычислениями https://github.com/HowProgrammingWorks/Paradigms/tree/main/JavaScript

Коллекция реализаций одной и той же небольшой задачи в разных парадигмах, с использованием разных приемов: паттернов, синтаксических, структурных, архитектурных конструкций (постоянно пополняется) https://github.com/HowProgrammingWorks/Paradigms

👩‍💻 Понимаете ли Вы разницу между FinilizationRegistry и Explicit resource management? Тема недели на курсе Node.js 2025: Disposable objects Примеры кода: https://github.com/HowProgrammingWorks/Disposable

🧩 10 мая в 15:00 стрим «Минимум паттернов для максимума пользы на реальном проекте с JavaScript, TypeScript, Node.js» Глубокое погружение в 5 самых полезных шаблонов для ежедневного использования: Strategy, Factory, Pool, Queue, Adapter 👉 https://patterns-js.com/w1hpna?utm_source=telegram_channel&utm_medium=t_shemsedinov&utm_campaign=stream_10_05

Кто узнает в этом коде плохие практики? Если не узнаете, и вам все ок, то смотрите в репозиторий, там список и как исправить https://github.com/HowProgrammingWorks/GoodParts/blob/main/JavaScript/1-func-bad.js

const getPrice = function(options = { convert: true }) {
  let price;
  let item = { price } = this;
  if (!Array.isArray(item)) {
    let { price } = this;
    if (typeof price == 'number') return price;
    price = this.cost;
    if (typeof price == 'number') return price;
    if (options.convert) return parseFloat(price);
  }
  [, price] = this;
  if (typeof price == 'number') return price;
  if (options.convert) price = +price;
  if (!isNaN(price)) return price;
};

👩‍💻 Это решениевместо непринятого TC39 иммутабельного объекта - иммутабельные м мутабельные записи (объекты) с оптимизацией формы - полное клонирование, модификация, клонирование с прототипным наследованием - проверка типов в рантайме, дефолтные значения полей - иммутабельные записи с экономией памяти за счет цепочек прототипов - ускорение поиска полей и оптимизации для V8, даже в сравнении с литералом объекта Тут еще нужно многое оптимизировать, но полное решение будет тут: https://github.com/metarhia/metautil/pull/298

class Record {
  static immutable(defaults) {
    return Record.#build(defaults, false);
  }

  static mutable(defaults) {
    return Record.#build(defaults, true);
  }

  static #build(defaults, isMutable) {
    const fields = Object.keys(defaults);
    const defaultValues = Object.create(null);
    for (const key of fields) {
      defaultValues[key] = defaults[key];
    }

    class Struct {
      static fields = fields;
      static defaults = defaultValues;
      static mutable = isMutable;

      static create(data = {}) {
        const obj = Object.create(null);

        for (const key of fields) {
          const base = defaultValues[key];
          const value = key in data ? data[key] : base;

          if (!Record.#sameType(base, value)) {
            const exp = Record.#typeof(base);
            const act = Record.#typeof(value);
            throw new TypeError(
              `Invalid type for "${key}": expected ${exp}, got ${act}`,
            );
          }

          obj[key] = value;
        }

        return isMutable ? Object.seal(obj) : Object.freeze(obj);
      }
    }

    return Struct;
  }

  static #typeof(value) {
    if (Array.isArray(value)) return 'array';
    if (value === null) return 'null';
    return typeof value;
  }

  static #sameType(a, b) {
    if (Array.isArray(a)) return Array.isArray(b);
    if (a === null) return b === null;
    return typeof a === typeof b;
  }

  static #validate(instance, updates) {
    for (const key of Object.keys(updates)) {
      if (!Reflect.has(instance, key)) continue;
      const current = instance[key];
      const next = updates[key];
      if (!Record.#sameType(current, next)) {
        const exp = Record.#typeof(current);
        const act = Record.#typeof(next);
        throw new TypeError(
          `Invalid type for "${key}": expected ${exp}, got ${act}`,
        );
      }
    }
  }

  static update(instance, updates) {
    if (Object.isFrozen(instance)) {
      throw new Error('Cannot mutate immutable Record');
    }
    Record.#validate(instance, updates);
    for (const key of Object.keys(updates)) {
      if (Reflect.has(instance, key)) {
        instance[key] = updates[key];
      }
    }
    return instance;
  }

  static fork(instance, updates) {
    Record.#validate(instance, updates);
    const obj = Object.create(null);
    for (const key of Object.keys(instance)) {
      obj[key] = Reflect.has(updates, key) ? updates[key] : instance[key];
    }
    return Object.isFrozen(instance) ? Object.freeze(obj) : Object.seal(obj);
  }

  static branch(instance, updates) {
    Record.#validate(instance, updates);
    const obj = Object.create(instance);
    for (const key of Object.keys(updates)) {
      Reflect.defineProperty(obj, key, {
        value: updates[key],
        writable: true,
        configurable: true,
        enumerable: true,
      });
    }
    return Object.isFrozen(instance) ? Object.freeze(obj) : Object.seal(obj);
  }
}