Classes and errors all 3 written

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12const plain = { a: 1 };

console.log(Object.getPrototypeOf(plain) === Object.prototype);
console.log(Object.hasOwn(plain, "a"), Object.hasOwn(plain, "toString"));
console.log(typeof plain.toString, "<- found on the prototype, not on plain");

const bare = Object.create(null);    // an object with no prototype at all
console.log(typeof bare.toString);

check("a plain object inherits from Object.prototype", Object.getPrototypeOf(plain), Object.prototype);
check("toString is inherited, not its own", Object.hasOwn(plain, "toString"), false);
check("Object.create(null) inherits nothing", typeof bare.toString, "undefined");

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15const animal = {
  describe() {
    return `${this.name} says ${this.sound}`;
  },
};

const dog = Object.create(animal);    // dog's prototype is animal
dog.name = "Rex";
dog.sound = "woof";

console.log(dog.describe());
console.log(Object.keys(dog), "<- describe is not dog's own property");

check("the method was found on the prototype", dog.describe(), "Rex says woof");
check("the prototype is animal", Object.getPrototypeOf(dog) === animal, true);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25class Account {
  owner;               // a field: every instance gets its own
  balance = 0;

  constructor(owner, opening = 0) {
    this.owner = owner;
    this.balance = opening;
  }

  deposit(amount) {    // a method: shared by every instance, via the prototype
    this.balance += amount;
    return this.balance;
  }
}

const a = new Account("Ada", 100);
const b = new Account("Alan");
a.deposit(50);

console.log(a, b);
console.log(a.deposit === b.deposit, Object.hasOwn(a, "deposit"));

check("each instance has its own balance", [a.balance, b.balance], [150, 0]);
check("but they share one deposit function", a.deposit === b.deposit, true);
check("which lives on the prototype", Object.getPrototypeOf(a) === Account.prototype, true);

example.mjs

1
2
3
4
5
6class Account {}

console.log(typeof Account);
console.log(Account.prototype.constructor === Account);

check("a class is a function underneath", typeof Account, "function");

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26class Account {
  #balance = 0;

  deposit(amount) {
    if (amount <= 0) throw new RangeError("deposit must be positive");
    this.#balance += amount;
  }

  get balance() {
    return this.#balance;
  }

  static isAccount(value) {
    return #balance in value;
  }
}

const acct = new Account();
acct.deposit(25);

console.log(acct.balance, Object.keys(acct));
console.log(Account.isAccount(acct), Account.isAccount({ balance: 5 }));

check("the balance is readable through the getter", acct.balance, 25);
check("but #balance is not an ordinary property", Object.keys(acct), []);
check("#field in obj tells a real Account from a lookalike", Account.isAccount({ balance: 5 }), false);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28class Shape {
  constructor(name) {
    this.name = name;
  }
  area() {
    return 0;
  }
  describe() {
    return `${this.name} with area ${this.area().toFixed(2)}`;
  }
}

class Circle extends Shape {
  constructor(radius) {
    super("circle");         // must run before this is used
    this.radius = radius;
  }
  area() {                   // overrides Shape's version
    return Math.PI * this.radius ** 2;
  }
}

const c = new Circle(2);
console.log(c.describe());
console.log(c instanceof Circle, c instanceof Shape);

check("describe (from Shape) called area (from Circle)", c.describe(), "circle with area 12.57");
check("a Circle is also a Shape", c instanceof Shape, true);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18function withdraw(balance, amount) {
  if (amount > balance) {
    throw new Error(`cannot withdraw ${amount} from a balance of ${balance}`);
  }
  return balance - amount;
}

let outcome;
try {
  outcome = withdraw(50, 80);
  console.log("this line is skipped");
} catch (err) {
  outcome = `refused: ${err.message}`;
}

console.log(outcome);

check("throw jumped straight to catch", outcome, "refused: cannot withdraw 80 from a balance of 50");

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18const log = [];

function readConfig(shouldFail) {
  log.push("open");
  try {
    if (shouldFail) throw new Error("bad config");
    return "config";
  } finally {
    log.push("close");      // runs whether try returned or threw
  }
}

readConfig(false);
try { readConfig(true); } catch {}

console.log(log);

check("finally ran after a return and after a throw", log, ["open", "close", "open", "close"]);

example.mjs

1
2
3
4
5
6
7
8
9
10
11function surprising() {
  try {
    throw new Error("this error disappears");
  } finally {
    return "finally won";      // a return here overrides everything
  }
}

console.log(surprising());

check("a return in finally swallowed the error", surprising(), "finally won");

example.mjs

1
2
3
4
5function loadUser(id) {
  throw "user not found";          // a bare string
}

loadUser(7);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12let caught;
try {
  throw new Error("user not found");
} catch (err) {
  caught = err;
}

console.log(caught instanceof Error, Error.isError(caught), Error.isError("user not found"));
console.log(caught.stack.split("\n")[1].trim());

check("an Error knows where it was made", caught.stack.includes("example.mjs:3"), true);
check("Error.isError tells a real error from a string", Error.isError("oops"), false);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34class NotFoundError extends Error {
  constructor(what, options) {
    super(`${what} was not found`, options);
    this.name = "NotFoundError";   // so the name prints correctly
    this.status = 404;
  }
}

class ValidationError extends Error {
  constructor(field, problem) {
    super(`${field}: ${problem}`);
    this.name = "ValidationError";
    this.field = field;
    this.status = 400;
  }
}

function respond(fn) {
  try {
    return { status: 200, body: fn() };
  } catch (err) {
    if (err instanceof NotFoundError || err instanceof ValidationError) {
      return { status: err.status, body: err.message };
    }
    throw err;                      // anything else is a real bug: let it through
  }
}

console.log(respond(() => "ok"));
console.log(respond(() => { throw new NotFoundError("order 42"); }));
console.log(respond(() => { throw new ValidationError("email", "must contain @"); }));

check("not found becomes a 404", respond(() => { throw new NotFoundError("x"); }).status, 404);
check("invalid input becomes a 400", respond(() => { throw new ValidationError("e", "bad"); }).status, 400);

example.mjs

1
2
3
4
5
6
7
8
9
10
11const problems = [
  new Error("name is required"),
  new Error("email must contain @"),
];

const err = new AggregateError(problems, "the form has 2 problems");

console.log(err.name, "-", err.message);
for (const p of err.errors) console.log("  -", p.message);

check("AggregateError holds a list of errors", err.errors.length, 2);

example.mjs

1
2
3
4
5
6
7
8
9
10const colours = ["red", "green"];

// This is what "for (const c of colours)" does underneath:
const iterator = colours[Symbol.iterator]();
console.log(iterator.next());
console.log(iterator.next());
console.log(iterator.next());

check("each next() hands back one value", ["red", "green"][Symbol.iterator]().next(), { value: "red", done: false });
check("and says done when there are no more", iterator.next(), { value: undefined, done: true });

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25class Range {
  constructor(from, to) {
    this.from = from;
    this.to = to;
  }

  [Symbol.iterator]() {
    let current = this.from;
    const last = this.to;
    return {
      next() {
        if (current > last) return { value: undefined, done: true };
        return { value: current++, done: false };
      },
    };
  }
}

const seen = [];
for (const n of new Range(3, 6)) seen.push(n);

console.log(seen, [...new Range(1, 3)], Math.max(...new Range(1, 10)));

check("for...of used the protocol", seen, [3, 4, 5, 6]);
check("and so do spread and Math.max", Math.max(...new Range(1, 10)), 10);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28function* range(from, to) {
  for (let n = from; n <= to; n++) {
    yield n;
  }
}

const steps = [];
function* traced() {
  steps.push("started");
  yield "a";
  steps.push("resumed after a");
  yield "b";
  steps.push("finished");
}

const it = traced();
steps.push("created");
it.next();
steps.push("took a");
it.next();
it.next();

console.log([...range(3, 6)]);
console.log(steps);

check("a generator is iterable", [...range(3, 6)], [3, 4, 5, 6]);
check("its body runs only as values are asked for",
      steps, ["created", "started", "took a", "resumed after a", "finished"]);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22let produced = 0;
function* naturals() {
  let n = 1;
  while (true) {                 // never ends -- and that is fine
    produced++;
    yield n++;
  }
}

function* take(iterable, count) {
  if (count <= 0) return;
  for (const value of iterable) {
    yield value;
    if (--count === 0) return;
  }
}

const firstFive = [...take(naturals(), 5)];
console.log(firstFive, "computed:", produced);

check("the first five naturals", firstFive, [1, 2, 3, 4, 5]);
check("and only five values were ever computed", produced, 5);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21let looked = 0;
function* naturals() {
  let n = 1;
  while (true) {
    looked++;
    yield n++;
  }
}

console.log("has iterator helpers:", typeof Iterator.prototype.map === "function");

const firstSquaresOverFifty = naturals()
  .map((n) => n * n)
  .filter((sq) => sq > 50)
  .take(3)
  .toArray();

console.log(firstSquaresOverFifty, "numbers looked at:", looked);

check("map, filter and take on an iterator", firstSquaresOverFifty, [64, 81, 100]);
check("and lazily: it stopped at 10", looked, 10);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13const stock = new Map([["apples", 3], ["pears", 0]]);

for (const [fruit, count] of stock) {
  console.log(fruit, count);
}

const [first] = stock;              // destructuring pulls one value from the iterator
const [a, b] = "hi";               // strings are iterable too

console.log(first, a, b);

check("iterating a Map gives [key, value] pairs", first, ["apples", 3]);
check("destructuring a string takes characters", [a, b], ["h", "i"]);