JavaScript

const flags = {
  READ:    0b0001,
  WRITE:   0b0010,
  EXECUTE: 0b0100,
  DELETE:  0b1000,
};

const userPermissions  = flags.READ | flags.WRITE | flags.EXECUTE;
const adminPermissions = userPermissions | flags.DELETE;

const canDelete  = (adminPermissions & flags.DELETE)  !== 0;
const canExecute = (userPermissions  & flags.EXECUTE) !== 0;
const readOnly   = userPermissions   ^ flags.WRITE;

console.log(canDelete, canExecute, readOnly, adminPermissions >> 1);

const config = {
  db: { host: "localhost", port: 5432 },
  cache: { ttl: 300 },
};

Object.freeze(config);

config.debug = true;
config.db.port = 9999;
config.cache = { ttl: 600 };

const sealed = Object.seal({ version: "1.0", meta: { build: 42 } });

sealed.version = "2.0";
sealed.author = "devteam";
sealed.meta.build = 99;

console.log(
  config.debug,
  config.db.port,
  config.cache.ttl,
  sealed.version,
  sealed.author,
  sealed.meta.build
);

const prefix = "get";
const suffix = "Name";

const registry = {
  [`${prefix}Full${suffix}`]: function () {
    return `${this.first} ${this.last}`;
  },
  [`${prefix}Short${suffix}`]: function () {
    return this.first[0] + ". " + this.last;
  },
};

const person = {
  first: "Leonardo",
  last: "Fibonacci",
  ...registry,
};

const key = ["Full", "Short"][1];
console.log(person[`${prefix}${key}${suffix}`]());

const tag = (strings, ...values) => {
  return strings.reduce((result, str, i) => {
    const value = values[i - 1];
    const transformed =
      typeof value === "number" ? `[${value ** 2}]` : `{${value}}`;
    return result + transformed + str;
  });
};

const name = "Sofia";
const score = 4;
const level = "gold";

const output = tag`Player: ${name}, Score: ${score}, Rank: ${level}`;
console.log(output);

const delay = (ms, val) => new Promise(res => setTimeout(res, ms, val));

async function* asyncGen() {
  yield await delay(10, "alpha");
  yield await delay(10, "beta");
  yield await delay(10, "gamma");
}

async function run() {
  const results = [];

  const gen = asyncGen();
  const [first, , third] = await Promise.all([
    gen.next(),
    gen.next(),
    gen.next()
  ]);

  results.push(first.value, third.value);

  const p1 = Promise.resolve("x").then(v => v + "1");
  const p2 = Promise.reject("err").catch(e => e + "2");

  results.push(...(await Promise.all([p1, p2])));
  console.log(results);
}

run();

const str = "JavaScript is Awesome!";

const result = str
  .split(" ")
  .map((word, i) => 
    i % 2 === 0
      ? word.toUpperCase()
      : word.toLowerCase()
  )
  .join("-");

const reversed = result
  .split("")
  .reduce((acc, char) => char + acc, "");

console.log(reversed);

const createModule = (() => {
  const privateCache = new WeakMap();

  return function(name) {
    const state = { name, version: 1, active: true };
    privateCache.set(state, { accessCount: 0 });

    return {
      getInfo() {
        const meta = privateCache.get(state);
        meta.accessCount++;
        return `${state.name}@v${state.version}`;
      },
      getAccessCount() {
        return privateCache.get(state).accessCount;
      },
      upgrade() {
        state.version++;
        return this;
      }
    };
  };
})();

const mod = createModule("auth");
mod.upgrade().upgrade();
console.log(mod.getInfo());
console.log(mod.getAccessCount());