JavaScript

'use strict';

function getValue() {
  return this.value;
}

const obj = { value: 42, getValue };
const fn = obj.getValue;

try {
  fn();
} catch (err) {
  console.log(err.constructor.name, typeof this);
}

const a = 5 & 3;
const b = 5 | 2;
const c = ~5;
const d = 1 << 31;
const e = -1 >>> 28;
const f = 5 ^ 5;
console.log(a, b, c, d, e, f);

let i = 0;
const key = () => `k${i++}`;
const obj = {
  [key()]: i,
  [key()]: i,
  [key()]: i,
};
console.log(Object.keys(obj).join(','), obj.k0, obj.k1, obj.k2);

const nums = [1, 2, 3, 4, 5];
const result = nums
  .filter(n => n % 2 !== 0)
  .map(n => n ** 2)
  .reduce((acc, n) => acc + n, 0);

const arr = [10, , 20, undefined, 30];
const mapped = arr.map(x => x * 2);

console.log(result, mapped);

let count = 0;
const inc = () => (count += 1, count);
const a = 0 || inc();
const b = null ?? inc();
const c = a && inc();
const d = b?.toString() || inc();
console.log(a, b, c, d, count);

const a = [] + [];
const b = [] + {};
const c = {} + [];
const d = 1 + "1" - 1;
console.log(a, b, c, d);

function Timer() {
  this.seconds = 0;
  this.tick = () => { this.seconds++; };
  this.tickRegular = function () { this.seconds++; };
}

const t = new Timer();
const { tick, tickRegular } = t;
tick();

let regularResult;
try {
  tickRegular();
  regularResult = 'no error';
} catch (e) {
  regularResult = e instanceof TypeError;
}

console.log(t.seconds, regularResult);

const base = {
  get value() {
    return this._value ?? 'default';
  },
  set value(v) {
    this._value = v;
  }
};

const derived = Object.create(base);
derived.value = 'hello';

const another = Object.create(base);

console.log(derived.value, another.value, derived.hasOwnProperty('_value'));

class Base {
  #value = 0;
  get value() { return this.#value; }
  set value(v) { this.#value = v * 2; }
}
class Derived extends Base {
  get value() { return super.value + 1; }
  set value(v) { super.value = v + 10; }
}
const d = new Derived();
d.value = 5;
console.log(d.value, d.value = 100, d.value);