JavaScript

const name = "Carlos";
const age = 28;
const score = 95;

const player = {
  name,
  age,
  score,
  greet() {
    return `${this.name} (${this.age}) scored ${this.score}`;
  },
  get rank() {
    return this.score >= 90 ? "Gold" : "Silver";
  }
};

const { name: playerName, rank, greet } = player;

console.log(`${playerName} | ${rank} | ${greet.call(player)}`);

function createUser(
  name,
  role = "viewer",
  permissions = [role],
  metadata = { createdBy: name, level: permissions.length }
) {
  return { name, role, permissions, metadata };
}

const user1 = createUser("Carlos");
const user2 = createUser("Diana", "admin", ["read", "write", "delete"]);
const user3 = createUser("Eve", "editor", undefined, { createdBy: "system", level: 99 });

console.log(user1.role, user1.permissions, user1.metadata.level);
console.log(user2.metadata.createdBy, user2.permissions.length);
console.log(user3.permissions[0], user3.metadata.level);

function Vehicle(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
  this.speed = 0;
}

Vehicle.prototype.accelerate = function (amount) {
  this.speed += amount;
  return this;
};

Vehicle.prototype.describe = function () {
  return `${this.year} ${this.make} ${this.model} going ${this.speed}km/h`;
};

function ElectricVehicle(make, model, year, range) {
  Vehicle.call(this, make, model, year);
  this.range = range;
}

ElectricVehicle.prototype = Object.create(Vehicle.prototype);
ElectricVehicle.prototype.constructor = ElectricVehicle;

ElectricVehicle.prototype.describe = function () {
  return Vehicle.prototype.describe.call(this) + ` | Range: ${this.range}km`;
};

const car = new ElectricVehicle("Tesla", "Model 3", 2023, 500);
car.accelerate(60).accelerate(40);

console.log(car.describe());
console.log(car instanceof ElectricVehicle);
console.log(car instanceof Vehicle);
console.log(car.constructor === ElectricVehicle);

const str = "  Hello, World!  ";

const result = str
  .trim()
  .split(", ")
  .map((word, i) => {
    if (i % 2 === 0) return word.toUpperCase();
    return word.toLowerCase().replace("!", "@");
  })
  .reverse()
  .join(" | ");

console.log(result);

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

const p1 = delay(300, "alpha");
const p2 = Promise.reject("network error");
const p3 = delay(100, "gamma");
const p4 = Promise.reject("timeout");

Promise.allSettled([p1, p2, p3, p4]).then(results => {
  const summary = results.map(r =>
    r.status === "fulfilled"
      ? `ok:${r.value}`
      : `fail:${r.reason}`
  );
  console.log(summary.join(" | "));
});

function* range(start, end) {
  while (start < end) {
    yield start++;
  }
}

function* evens(iter) {
  for (const val of iter) {
    if (val % 2 === 0) yield val;
  }
}

function* take(n, iter) {
  let count = 0;
  for (const val of iter) {
    if (count++ >= n) return;
    yield val;
  }
}

function* pipeline() {
  yield* take(3, evens(range(1, 20)));
  yield* take(2, range(10, 15));
}

const result = [...pipeline()];
console.log(result);

const handler = {
  get(target, prop, receiver) {
    if (prop in target) {
      return Reflect.get(target, prop, receiver) * 2;
    }
    return `Missing: ${prop}`;
  },
  set(target, prop, value) {
    if (typeof value !== "number") {
      throw new TypeError("Only numbers allowed");
    }
    return Reflect.set(target, prop, Math.abs(value));
  },
};

const store = new Proxy({ gold: 10, silver: 5 }, handler);

store.bronze = -42;

console.log(store.gold);
console.log(store.bronze);
console.log(store.platinum);

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

const language = "javascript";
const year = 2015;
const feature = "templates";

const output = highlight`Language: ${language}, introduced in ${year}, feature: ${feature}!`;
console.log(output);