JavaScript

function checkTDZ() {
  console.log(typeof undeclaredVar);

  try {
    console.log(typeof letVar);
  } catch (e) {
    console.log(`Caught: ${e.constructor.name}`);
  }

  let letVar = "initialized";

  const result = (() => {
    let x = 10;
    return function () {
      let x = x + 5;
      return x;
    };
  })();

  try {
    console.log(result());
  } catch (e) {
    console.log(`Caught: ${e.constructor.name}`);
  }
}

checkTDZ();

const curry = (fn) => {
  const arity = fn.length;
  return function curried(...args) {
    if (args.length >= arity) {
      return fn(...args);
    }
    return (...moreArgs) => curried(...args, ...moreArgs);
  };
};

const volume = (l, w, h) => l * w * h;
const curriedVolume = curry(volume);

const withLength5 = curriedVolume(5);
const withLength5Width3 = withLength5(3);

console.log(typeof withLength5);
console.log(typeof withLength5Width3);
console.log(withLength5Width3(2));
console.log(curriedVolume(4)(6)(2));

const handler = {
  get(target, prop, receiver) {
    if (prop in target) {
      return Reflect.get(target, prop, receiver) * 2;
    }
    return `${prop} not found`;
  },
  set(target, prop, value) {
    if (typeof value !== "number") {
      throw new TypeError("Only numbers allowed");
    }
    target[prop] = value + 10;
    return true;
  },
  has(target, prop) {
    return prop.startsWith("x") ? false : prop in target;
  },
};

const obj = new Proxy({ score: 5, xp: 100 }, handler);

obj.level = 3;
console.log(obj.score);
console.log(obj.level);
console.log("xp" in obj);
console.log("score" in obj);
console.log(obj.rank);

const delay = (val) => Promise.resolve(val);

async function pipeline(input) {
  const result = await delay(input)
    .then((v) => v * 2)
    .then((v) => v + 10)
    .then((v) => {
      if (v > 20) throw new Error(`Too large: ${v}`);
      return v;
    })
    .catch((e) => `Caught: ${e.message}`)
    .then((v) => (typeof v === "string" ? v.toUpperCase() : v * 3));

  return result;
}

Promise.all([pipeline(4), pipeline(8)]).then(([a, b]) => {
  console.log(a);
  console.log(b);
});

"use strict";

function createCounter() {
  let count = 0;

  return {
    increment() { count++; },
    get value() { return count; },
    reset: function() { count = 0; }
  };
}

const counter = createCounter();
counter.increment();
counter.increment();
counter.increment();

const { value, reset } = counter;
reset();

console.log(counter.value, value);

const config = {
  version: 1,
  settings: { theme: "dark", fontSize: 14 },
  tags: ["beta", "v1"],
};

Object.seal(config);
Object.freeze(config.settings);

config.version = 99;
config.newProp = "ignored";
delete config.tags;

config.settings.theme = "light";
config.settings.newKey = "ignored";

config.tags.push("v2");
config.tags[0] = "stable";

console.log(
  config.version,
  config.newProp,
  config.settings.theme,
  config.tags
);

const memoize = (fn) => {
  const cache = new Map();
  return (...args) => {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      return cache.get(key);
    }
    const result = fn(...args);
    cache.set(key, result);
    return result;
  };
};

let callCount = 0;

const expensiveMultiply = memoize((a, b) => {
  callCount++;
  return a * b;
});

console.log(expensiveMultiply(3, 4));
console.log(expensiveMultiply(3, 4));
console.log(expensiveMultiply(2, 5));
console.log(expensiveMultiply(3, 4));
console.log(`calls: ${callCount}`);

const config = {
  host: "localhost",
  port: 3000,
  db: {
    name: "mydb",
    retries: 5
  }
};

Object.freeze(config);

config.port = 9999;
config.newProp = "injected";
config.db.retries = 99;
delete config.host;

console.log(
  config.port,
  config.newProp,
  config.db.retries,
  config.host
);