JavaScript: Fundamental (ES6), part 1, 137–150

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19const naira = new Intl.NumberFormat('en-NG', { style: 'currency', currency: 'NGN' });
const whole = new Intl.NumberFormat('en-NG', { style: 'currency', currency: 'NGN', maximumFractionDigits: 0 });
const american = new Intl.NumberFormat('en-US', { style: 'currency', currency: 'NGN' });
const plain = new Intl.NumberFormat('en-US');

const amount = 1234567.5;
const formatted = naira.format(amount);
const parts = naira.formatToParts(amount);
const types = parts.map((p) => p.type);
const rejoined = parts.map((p) => p.value).join('');
const groups = formatted.split(',').length - 1;
const rounded = whole.format(amount);
const hasFraction = whole.formatToParts(amount).some((p) => p.type === 'fraction');
const symbols = [naira.formatToParts(1)[0].value, american.formatToParts(1)[0].value];
const settings = naira.resolvedOptions();

console.log('naira  :', formatted, '| whole:', rounded);
console.log('parts  :', types);
console.log('same currency, other locale:', american.format(amount));

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
34
35
36
37const WIDTH = 34;
const money = (kobo) => (kobo / 100).toFixed(2);
const row = (label, value) => label.padEnd(WIDTH - value.length, '.') + value;
const centred = (text) => text.padStart(Math.floor((WIDTH + text.length) / 2)).padEnd(WIDTH);
const qty = (n) => String(n).padStart(3);

const items = [
  { name: 'Garri, 5kg', count: 2, kobo: 450000 },
  { name: 'Palm oil, 1L', count: 1, kobo: 320000 },
  { name: 'Titus sardine', count: 3, kobo: 95000 },
];

const total = items.reduce((sum, i) => sum + i.count * i.kobo, 0);
const cash = 2000000;

const receipt = [
  centred('BALOGUN STORES'),
  centred(`Receipt ${String(7).padStart(6, '0')}`),
  '='.repeat(WIDTH),
  ...items.map((i) => row(`${qty(i.count)} x ${i.name}`, money(i.count * i.kobo))),
  '-'.repeat(WIDTH),
  row('TOTAL', money(total)),
  row('CASH', money(cash)),
  row('CHANGE', money(cash - total)),
  '='.repeat(WIDTH),
];

const widths = [...new Set(receipt.map((line) => line.length))];
const overflowing = row('Imported basmati rice, 50kg sack', money(total));
const precomposed = 'Adé';
const decomposed = 'Adé';
const dots = [precomposed, decomposed, decomposed.normalize('NFC')]
  .map((s) => s.padStart(6, '.').split('.').length - 1);

console.log(receipt.join('\n'));
console.log('overflow:', overflowing.length, 'characters, not', WIDTH);
console.log('dots    :', dots);

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73const ALL = ['Ada', 'Bola', 'Chidi', 'Dele', 'Efe', 'Funke', 'Gbenga'];
const PAGE_SIZE = 3;
let requests = 0;

const fetchPage = async (cursor) => {
  requests += 1;
  const rows = ALL.slice(cursor, cursor + PAGE_SIZE);
  const nextCursor = cursor + PAGE_SIZE < ALL.length ? cursor + PAGE_SIZE : null;
  return { rows, nextCursor };
};

async function* pages() {
  let cursor = 0;
  while (cursor !== null) {
    const page = await fetchPage(cursor);
    yield page.rows;
    cursor = page.nextCursor;
  }
}

async function* rows() {
  for await (const page of pages()) {
    for (const row of page) yield row;
  }
}

const takeAsync = async (source, count) => {
  const out = [];
  if (count <= 0) return out;
  for await (const value of source) {
    out.push(value);
    if (out.length >= count) break;
  }
  return out;
};

const everyone = [];
for await (const name of rows()) everyone.push(name);
const requestsForEveryone = requests;

requests = 0;
const firstFour = await takeAsync(rows(), 4);
const requestsForFour = requests;

requests = 0;
const none = await takeAsync(rows(), 0);
const requestsForNone = requests;

async function* mixed() {
  yield 'plain';
  yield Promise.resolve('a promise, unwrapped');
}
const unwrapped = [];
for await (const value of mixed()) unwrapped.push(value);

const overAnArray = [];
for await (const value of [Promise.resolve('a'), 'b']) overAnArray.push(value);

let cleaned = false;
async function* watched() {
  try {
    yield 'one';
    yield 'two';
  } finally {
    cleaned = true;
  }
}
const justOne = await takeAsync(watched(), 1);
const lastPage = await fetchPage(6);

console.log('everyone :', everyone, '| requests:', requestsForEveryone);
console.log('firstFour:', firstFour, '| requests:', requestsForFour);
console.log('cleanup  :', cleaned, '| none:', none, requestsForNone);

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61const TARIFF = Object.freeze({ Ikeja: 120000, Yaba: 90000, Ketu: 150000 });
const FREE_ABOVE = 1500000;
const WIDTH = 30;

const money = (kobo) =>
  `₦${(kobo / 100).toFixed(2).replace(/\B(?=(\d{3})+(?!\d))/g, ',')}`;

const problemsWith = (order) => [
  !order.customer?.trim() && 'customer is required',
  !Object.hasOwn(TARIFF, order.zone) && `no delivery to ${order.zone}`,
  !(order.lines?.length > 0) && 'an order needs at least one line',
  ...(order.lines ?? []).map((line, i) => line.qty > 0 ? false : `line ${i} needs a quantity`),
].filter(Boolean);

const priceUp = (order) => {
  const lines = order.lines.map((line) => ({ ...line, kobo: line.qty * line.unitKobo }));
  const goods = lines.reduce((sum, line) => sum + line.kobo, 0);
  const delivery = goods >= FREE_ABOVE ? 0 : TARIFF[order.zone];
  return { lines, goods, delivery, total: goods + delivery };
};

const row = (label, value) => label.padEnd(WIDTH - value.length, ' ') + value;
const receiptFor = (priced) => [
  ...priced.lines.map((line) => row(`${line.qty} x ${line.item}`, money(line.kobo))),
  row('Delivery', money(priced.delivery)),
  row('TOTAL', money(priced.total)),
];

const place = (order) => {
  const problems = problemsWith(order);
  return problems.length
    ? { ok: false, status: 'rejected', errors: problems }
    : { ok: true, status: 'accepted', ...priceUp(order) };
};

const smallOrder = {
  customer: 'Ngozi Okafor',
  zone: 'Yaba',
  lines: [
    { item: 'Garri, 5kg', qty: 2, unitKobo: 450000 },
    { item: 'Palm oil, 1L', qty: 1, unitKobo: 320000 },
  ],
};
const bulkOrder = {
  customer: 'Musa Bello',
  zone: 'Ketu',
  lines: [{ item: 'Rice, 50kg', qty: 1, unitKobo: 7500000 }],
};
const brokenOrder = { customer: '   ', zone: 'Abuja', lines: [{ item: 'Ice', qty: 0, unitKobo: 100 }] };

const small = place(smallOrder);
const bulk = place(bulkOrder);
const rejected = place(brokenOrder);
const receipt = receiptFor(small);

let frozenWrite = 'no error';
try { TARIFF.Yaba = 1; } catch (e) { frozenWrite = e.constructor.name; }

console.log(receipt.join('\n'));
console.log('bulk    :', bulk.status, money(bulk.total), '| delivery:', money(bulk.delivery));
console.log('rejected:', rejected.errors);

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60const order = [];
const log = (label) => order.push(label);

let releaseTimer;
const timerRan = new Promise((resolve) => { releaseTimer = resolve; });

log('1 script top');
setTimeout(() => { log('7 setTimeout 0'); releaseTimer(); }, 0);
Promise.resolve().then(() => log('4 promise.then'));
queueMicrotask(() => log('5 queueMicrotask'));

const tally = async () => {
  log('2 async body, before the first await');
  await null;
  log('6 async body, after the await');
};
tally();
log('3 script bottom');

const beforeAnythingAsync = [...order];
await timerRan;
const everything = [...order];
const timerCameLast = everything[everything.length - 1] === '7 setTimeout 0';

// One queue, not two: they interleave by registration order.
const sharedQueue = [];
queueMicrotask(() => sharedQueue.push('micro 1'));
Promise.resolve().then(() => sharedQueue.push('then 1'));
queueMicrotask(() => sharedQueue.push('micro 2'));
Promise.resolve().then(() => sharedQueue.push('then 2'));
await new Promise((resolve) => queueMicrotask(resolve));

// Each .then is one microtask, so two chains advance in lockstep.
const chain = [];
const chainA = Promise.resolve()
  .then(() => { chain.push('A1'); })
  .then(() => { chain.push('A2'); })
  .then(() => { chain.push('A3'); });
const chainB = Promise.resolve()
  .then(() => { chain.push('B1'); })
  .then(() => { chain.push('B2'); })
  .then(() => { chain.push('B3'); });
await Promise.all([chainA, chainB]);

// A microtask can add to the queue it is being drained from.
const nested = [];
let releaseSecond;
const secondTimer = new Promise((resolve) => { releaseSecond = resolve; });
setTimeout(() => { nested.push('timer'); releaseSecond(); }, 0);
Promise.resolve().then(() => {
  nested.push('microtask');
  Promise.resolve().then(() => nested.push('microtask queued from a microtask'));
});
await secondTimer;

console.log('sync only :', beforeAnythingAsync);
console.log('everything:', everything);
console.log('one queue :', sharedQueue);
console.log('two chains:', chain);
console.log('nested    :', nested);

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63const topLevelThis = typeof this;      // a strict function scope, so: undefined

const stall = {
  name: 'Balogun stall',
  items: ['gari', 'rice'],

  who() { return this.name; },                       // 1. decided by the call site

  whoArrow: () => (this === undefined ? '<no this>' : 'the stall'),   // 2. captured, not the object

  labelPlain() {                                     // 3. a plain callback loses it
    return this.items.map(function (item) {
      return (this === undefined ? '<no this>' : this.name) + '/' + item;
    });
  },
  labelArrow() {                                     // 4. an arrow keeps it
    return this.items.map((item) => this.name + '/' + item);
  },
  labelThisArg() {                                   // 5. so does map's second argument
    return this.items.map(function (item) { return this.name + '/' + item; }, this);
  },
  labelBound() {                                     // 6. and so does bind
    const fn = function (item) { return this.name + '/' + item; }.bind(this);
    return this.items.map(fn);
  },
};

const asMethod = stall.who();

const detached = stall.who;                          // 7. same function, no receiver
let detachedResult;
try { detachedResult = detached(); } catch (e) { detachedResult = e.constructor.name; }

const kiosk = { name: 'Yaba kiosk' };
const borrowed = [stall.who.call(kiosk), stall.who.apply(kiosk), stall.who.bind(kiosk)()];

const boundOnce = stall.who.bind(kiosk);
const boundTwice = boundOnce.bind(stall);            // the second bind cannot win
const rebound = boundTwice();

function Stallholder(name) { this.name = name; }
const BoundHolder = Stallholder.bind({ name: 'ignored by new' });
const built = new BoundHolder('Adaora');

class Counter {
  constructor() {
    this.n = 0;
    this.bumpField = () => { this.n += 1; return this.n; };   // an own arrow property
  }
  bumpMethod() { this.n += 1; return this.n; }                // lives on the prototype
}
const counter = new Counter();
const looseField = counter.bumpField;
const looseMethod = counter.bumpMethod;
let fieldResult, methodResult;
try { fieldResult = looseField(); } catch (e) { fieldResult = e.constructor.name; }
try { methodResult = looseMethod(); } catch (e) { methodResult = e.constructor.name; }

console.log('top level :', topLevelThis, '| as a method:', asMethod, '| detached:', detachedResult);
console.log('borrowed  :', borrowed, '| arrow in a literal:', stall.whoArrow());
console.log('callbacks :', stall.labelPlain(), stall.labelArrow());
console.log('bind twice:', rebound, '| new on a bound fn:', built.name);
console.log('detached  :', fieldResult, methodResult, '| counter.n:', counter.n);

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52const vehicle = {
  wheels: 4,
  describe() { return this.kind + ' on ' + this.wheels + ' wheels'; },
};

const danfo = Object.create(vehicle);
danfo.kind = 'danfo';

const okada = Object.create(vehicle, {
  kind: { value: 'okada', enumerable: true, writable: true },
  wheels: { value: 2, enumerable: true, writable: true },
});

const asBuilt = [danfo.describe(), okada.describe()];

const nameOf = (o) =>
  o === danfo ? 'danfo' : o === vehicle ? 'vehicle' : o === Object.prototype ? 'Object.prototype' : 'other';
const walk = [];
let cursor = danfo;
while (cursor !== null) { walk.push(nameOf(cursor)); cursor = Object.getPrototypeOf(cursor); }

const ownBefore = Object.keys(danfo);
const inherited = [danfo.wheels, Object.hasOwn(danfo, 'wheels')];
danfo.wheels = 6;                                   // creates an OWN property
const afterWrite = [danfo.wheels, vehicle.wheels, okada.wheels, Object.hasOwn(danfo, 'wheels')];

function Vehicle() {}
Vehicle.prototype = vehicle;                        // instanceof reads the RIGHT side's .prototype
const neverConstructed = danfo instanceof Vehicle;

function Bus() {}
const firstBus = new Bus();
Bus.prototype = { rows: 10 };                       // a different object entirely
const secondBus = new Bus();
const orphaned = [firstBus instanceof Bus, secondBus instanceof Bus];

class Wheeled {
  static [Symbol.hasInstance](value) { return typeof value?.wheels === 'number'; }
}
const hijacked = [{ wheels: 3 } instanceof Wheeled, { wheels: 'plenty' } instanceof Wheeled];

const bare = Object.create(null);
bare.kind = 'bare';
const bareFacts = [typeof bare.toString, 'toString' in bare, Object.getPrototypeOf(bare), bare instanceof Object];

const fromTheOtherEnd = [vehicle.isPrototypeOf(danfo), Object.prototype.isPrototypeOf(bare)];

console.log('as built  :', asBuilt);
console.log('chain     :', walk, '| own keys:', ownBefore);
console.log('shadowing :', inherited, '->', afterWrite);
console.log('instanceof:', neverConstructed, orphaned, hijacked);
console.log('no chain  :', bareFacts, '| isPrototypeOf:', fromTheOtherEnd);

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
33const withVar = [];
for (var i = 0; i < 3; i++) withVar.push(() => i);

const withLet = [];
for (let j = 0; j < 3; j++) withLet.push(() => j);

const withIife = [];
for (var k = 0; k < 3; k++) withIife.push(((frozen) => () => frozen)(k));

const withForEach = [];
[0, 1, 2].forEach(function (n) { withForEach.push(() => n); });

const called = [withVar.map((f) => f()), withLet.map((f) => f()), withIife.map((f) => f()), withForEach.map((f) => f())];

const afterVar = i;
let afterLet;
try { afterLet = j; } catch (e) { afterLet = e.constructor.name; }

const varOf = [];
for (var v of ['a', 'b', 'c']) varOf.push(() => v);
const constOf = [];
for (const w of ['a', 'b', 'c']) constOf.push(() => w);

// The body mutates the counter. Which binding did the closure capture?
const nudged = [];
const bodySaw = [];
for (let m = 0; m < 3; m++) { nudged.push(() => m); bodySaw.push(m); m += 10; }

console.log('var / let :', called[0], called[1]);
console.log('iife/each :', called[2], called[3]);
console.log('after     :', afterVar, afterLet);
console.log('for...of  :', varOf.map((f) => f()), constOf.map((f) => f()));
console.log('nudged    :', nudged.map((f) => f()), '| body saw:', bodySaw);

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50function survey() {
  const seen = {};
  seen.varBefore = typeof loose;
  try { seen.letBefore = typeof strictish; } catch (e) { seen.letBefore = e.constructor.name; }
  try { seen.constBefore = typeof fixed; } catch (e) { seen.constBefore = e.constructor.name; }
  try { seen.classBefore = typeof Stall; } catch (e) { seen.classBefore = e.constructor.name; }
  seen.fnBefore = typeof declared;
  seen.calledEarly = declared();
  try { seen.arrowBefore = typeof arrow; } catch (e) { seen.arrowBefore = e.constructor.name; }
  seen.neverDeclared = typeof nowhereAtAll;

  var loose = 'loose';
  let strictish = 'strictish';
  const fixed = 'fixed';
  class Stall {}
  function declared() { return 'callable above its own line'; }
  const arrow = () => 'not callable above its line';
  return seen;
}
const seen = survey();

const supplier = 'the outer supplier';
function shadowed() {
  let got;
  try { got = supplier; } catch (e) { got = e.constructor.name; }
  let supplier = 'the inner supplier';       // owns the name for the whole function
  return [got, supplier];
}

function defaults(a = b, b = 2) { return [a, b]; }
let defaultsBackwards;
try { defaultsBackwards = defaults(); } catch (e) { defaultsBackwards = e.constructor.name; }
const defaultsForwards = defaults(1);

function twins() { return 'first'; }
function twins() { return 'second'; }
const whichTwin = twins();

function varAgainstFunction() {
  const before = typeof mixed;
  var mixed = 1;
  const after = typeof mixed;
  function mixed() {}
  return [before, after];
}

console.log('survey    :', seen);
console.log('shadowed  :', shadowed());
console.log('defaults  :', defaultsBackwards, defaultsForwards);
console.log('twins     :', whichTwin, '| var vs function:', varAgainstFunction());

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62const nullish = {
  'null == undefined': null == undefined,
  'null === undefined': null === undefined,
  'null == false': null == false,
  'null == 0': null == 0,
  'null == empty string': null == '',
};

const relational = {
  'null >= 0': null >= 0,
  'null > 0': null > 0,
  'null <= 0': null <= 0,
  'undefined >= 0': undefined >= 0,
};

const emptyish = {
  'empty string == 0': '' == 0,
  'space == 0': ' ' == 0,
  'newline == 0': '\n' == 0,
  'zero string == 0': '0' == 0,
  'empty string == zero string': '' == '0',
};

const notTransitive = ['0' == 0, 0 == '', '0' == ''];

const boolish = {
  'zero string == false': '0' == false,
  'empty string == false': '' == false,
  'one string == true': '1' == true,
  '2 == true': 2 == true,
  'empty array == false': [] == false,
  'empty array == not empty array': [] == ![],
};

const arrays = {
  '[1] == 1': [1] == 1,
  'empty array == empty string': [] == '',
  'array of empty array == empty string': [[]] == '',
  '[null] == empty string': [null] == '',
  '[undefined] == empty string': [undefined] == '',
  "[1,2] == '1,2'": [1, 2] == '1,2',
};

const objects = {
  'plain object == its toString': ({}) == '[object Object]',
  'two empty arrays': [] == [],
  'two empty objects': ({}) === ({}),
};

const nanFacts = [NaN == NaN, NaN === NaN, Object.is(NaN, NaN), Number.isNaN(NaN)];
const zeroFacts = [0 === -0, 0 == -0, Object.is(0, -0), [0, -0].map((n) => 1 / n === Infinity)];
const coercions = [Number(''), Number(' '), Number(null), Number([]), Number([2]), String(Number(undefined))];

const everySurprise = [null == undefined, '' == 0, '0' == 0, [] == false, [1] == 1, ({}) == '[object Object]'];
const sameWithTripleEquals = [null === undefined, '' === 0, '0' === 0, [] === false, [1] === 1, ({}) === '[object Object]'];

console.log('nullish   :', nullish);
console.log('relational:', relational);
console.log('emptyish  :', emptyish, '| transitive?', notTransitive);
console.log('boolish   :', boolish);
console.log('arrays    :', arrays, '| objects:', objects);
console.log('NaN / -0  :', nanFacts, zeroFacts, '| Number():', coercions);

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54const tag = Symbol('tag');
const ledger = {};
ledger.zebra = 1;
ledger[2] = 'two';
ledger.apple = 2;
ledger[1] = 'one';
ledger['-1'] = 'minus one';
ledger['1.5'] = 'one and a half';
ledger['01'] = 'zero one';
ledger[tag] = 'a symbol value';
ledger[0] = 'zero';
ledger['4294967294'] = 'the largest array index';
ledger['4294967295'] = 'one past it';

const keys = Object.keys(ledger);
const ownKeys = Reflect.ownKeys(ledger).map(String);
const json = JSON.stringify(ledger);
const keyOrderInJson = (json.match(/"[^"]*":/g) || []).map((s) => s.slice(1, -2));
const spread = { ...ledger };
const spreadKeys = Object.keys(spread);
const symbolsCarried = [Object.getOwnPropertySymbols(ledger).length, Object.getOwnPropertySymbols(spread).length];

const literal = { b: 1, 2: 'x', a: 2, 1: 'y' };
const literalKeys = Object.keys(literal);

const parent = { inherited: true };
const child = Object.create(parent);
child.own2 = 1;
child[5] = 1;
child.own1 = 1;
const forIn = [];
for (const key in child) forIn.push(key);

const reinsert = { a: 1, b: 2, c: 3, 1: 'one', 2: 'two' };
delete reinsert.a;
reinsert.a = 9;
delete reinsert[1];
reinsert[1] = 'back';
const reinsertKeys = Object.keys(reinsert);

const asMap = new Map();
asMap.set('zebra', 1).set(2, 'two').set('apple', 2).set(1, 'one');
const mapKeys = [...asMap.keys()];
const mapKeyTypes = mapKeys.map((k) => typeof k);

const expected = ['0', '1', '2', '4294967294', 'zebra', 'apple', '-1', '1.5', '01', '4294967295'];

console.log('Object.keys   :', keys);
console.log('Reflect.ownKeys:', ownKeys);
console.log('in the JSON   :', keyOrderInJson);
console.log('spread        :', spreadKeys, '| symbols:', symbolsCarried);
console.log('literal       :', literalKeys, '| for...in:', forIn);
console.log('delete/re-add :', reinsertKeys);
console.log('a Map instead :', mapKeys, mapKeyTypes);

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61let getterCalls = 0;
let setterCalls = 0;

const order = { item: 'gari', qty: 3 };

Object.defineProperty(order, 'unitKobo', {
  value: 120000, enumerable: false, writable: false, configurable: false,
});

Object.defineProperty(order, 'totalNaira', {
  get() { getterCalls += 1; return (this.qty * this.unitKobo) / 100; },
  set(naira) { setterCalls += 1; this.qty = Math.round((naira * 100) / this.unitKobo); },
  enumerable: true,
  configurable: true,
});

const visible = Object.keys(order);
const everything = Object.getOwnPropertyNames(order);
const json = JSON.parse(JSON.stringify(order));
const callsAfterJson = getterCalls;

const snapshot = { ...order };
order.qty = 10;
const liveVersusSnapshot = [order.totalNaira, snapshot.totalNaira];

order.totalNaira = 7200;                        // the setter writes back through qty
const afterSetter = [setterCalls, order.qty, order.totalNaira];

let writeError;
try { order.unitKobo = 1; writeError = 'no throw'; } catch (e) { writeError = e.constructor.name; }
let deleteError;
try { delete order.unitKobo; deleteError = 'no throw'; } catch (e) { deleteError = e.constructor.name; }
let redefineError;
try { Object.defineProperty(order, 'unitKobo', { value: 2 }); redefineError = 'no throw'; }
catch (e) { redefineError = e.constructor.name; }

const defined = {};
Object.defineProperty(defined, 'x', { value: 1 });
const assigned = {};
assigned.x = 1;
const definedFlags = Object.getOwnPropertyDescriptor(defined, 'x');
const assignedFlags = Object.getOwnPropertyDescriptor(assigned, 'x');
let definedWrite;
try { defined.x = 2; definedWrite = 'no throw'; } catch (e) { definedWrite = e.constructor.name; }

const readOnly = {};
Object.defineProperty(readOnly, 'label', { get() { return 'fixed'; }, enumerable: true, configurable: true });
let getterOnlyWrite;
try { readOnly.label = 'other'; getterOnlyWrite = 'no throw'; } catch (e) { getterOnlyWrite = e.constructor.name; }

const accessor = Object.getOwnPropertyDescriptor(order, 'totalNaira');
const accessorShape = [Object.keys(accessor).sort(), typeof accessor.get, 'value' in accessor, 'writable' in accessor];
const reachability = ['unitKobo' in order, Object.hasOwn(order, 'unitKobo'), order.unitKobo];

console.log('visible   :', visible, '| all own names:', everything);
console.log('json      :', json, '| getter calls:', callsAfterJson);
console.log('snapshot  :', snapshot, '| live vs snapshot:', liveVersusSnapshot);
console.log('setter    :', afterSetter);
console.log('strict    :', writeError, deleteError, redefineError, definedWrite, getterOnlyWrite);
console.log('flags     :', definedFlags, assignedFlags);
console.log('accessor  :', accessorShape, '| reachable:', reachability);

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71const trace = [];

function* runningTotal() {
  let total = 0;
  try {
    while (true) {
      const amount = yield total;          // next(v) makes v the value of this expression
      trace.push('received ' + amount);
      total += amount;
    }
  } finally {
    trace.push('finally ran at ' + total);
  }
}

const till = runningTotal();
const started = till.next('IGNORED');      // only starts the body
const afterFirst = till.next(500);
const afterSecond = till.next(250);
const closed = till.return('till shut');
const afterDone = till.next(999);
const tillTrace = [...trace];

const second = runningTotal();
const discarded = [second.next(1000).value, second.next(1).value];
second.return();

const caught = [];
function* resilient() {
  let n = 0;
  while (n < 4) {
    try {
      n += yield n;
    } catch (e) {
      caught.push(e.message);
      n += 1;
    }
  }
  return { n, caught: [...caught] };
}
const tough = resilient();
const t1 = tough.next().value;
const t2 = tough.throw(new Error('bad note')).value;   // lands at the suspended yield
const t3 = tough.next(2).value;
const t4 = tough.next(1);

function* upTo(limit) {
  for (let i = 1; i <= limit; i++) yield i;
  return 'RETURNED';
}
const spread = [...upTo(4)];
const looped = [];
for (const value of upTo(3)) looped.push(value);
const byHand = [];
const manual = upTo(2);
byHand.push(manual.next().value, manual.next().value, manual.next().value, manual.next().done);

function* inner() { const a = yield 'i1'; const b = yield 'i2'; return a + b; }
function* outer() { const sum = yield* inner(); yield 'sum ' + sum; }
const delegating = outer();
const delegated = [delegating.next().value, delegating.next(10).value, delegating.next(5).value];

const once = upTo(2);
const drained = [[...once], [...once]];
const selfIterating = [once[Symbol.iterator]() === once, typeof once.next, typeof once.throw];

console.log('till      :', [started, afterFirst, afterSecond]);
console.log('closed    :', closed, afterDone, '| trace:', trace);
console.log('first arg :', discarded, '| throw in:', [t1, t2, t3, t4]);
console.log('for...of  :', spread, looped, byHand);
console.log('yield*    :', delegated, '| exhausted:', drained, selfIterating);

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81const DEPTH = 200000;

const sumRecursive = (n) => (n === 0 ? 0 : n + sumRecursive(n - 1));
const sumTail = (n, acc = 0) => (n === 0 ? acc : sumTail(n - 1, acc + n));
const sumLoop = (n) => { let total = 0; for (let i = n; i > 0; i--) total += i; return total; };

let recursiveFailure, tailFailure;
try { sumRecursive(DEPTH); recursiveFailure = 'no throw'; } catch (e) { recursiveFailure = e.constructor.name; }
try { sumTail(DEPTH); tailFailure = 'no throw'; } catch (e) { tailFailure = e.constructor.name; }
const shallowStillFine = [sumRecursive(100), sumTail(100), sumLoop(100)];

const chainOf = (depth) => {
  let node = { id: depth, kids: [] };
  for (let i = depth - 1; i >= 1; i--) node = { id: i, kids: [node] };
  return node;
};

const small = {
  id: 1,
  kids: [{ id: 2, kids: [{ id: 4, kids: [] }, { id: 5, kids: [] }] }, { id: 3, kids: [] }],
};

const walkRecursive = (node, out) => {
  out.push(node.id);
  for (const kid of node.kids) walkRecursive(kid, out);
  return out;
};

const walkStack = (root) => {
  const out = [];
  const stack = [root];
  let highWater = 0;
  while (stack.length > 0) {
    if (stack.length > highWater) highWater = stack.length;
    const node = stack.pop();
    out.push(node.id);
    for (let i = node.kids.length - 1; i >= 0; i--) stack.push(node.kids[i]);
  }
  return { out, highWater };
};

const walkStackForwardPush = (root) => {
  const out = [];
  const stack = [root];
  while (stack.length > 0) {
    const node = stack.pop();
    out.push(node.id);
    for (const kid of node.kids) stack.push(kid);
  }
  return out;
};

const smallRecursive = walkRecursive(small, []);
const smallStack = walkStack(small).out;
const smallForwardPush = walkStackForwardPush(small);

const deep = chainOf(50000);
let deepRecursive;
try { deepRecursive = walkRecursive(deep, []).length; } catch (e) { deepRecursive = e.constructor.name; }
const deepStack = walkStack(deep);
const deepStackFacts = [deepStack.out.length, deepStack.out[0], deepStack.out[49999], deepStack.highWater];

const trampoline = (fn) => (...args) => {
  let out = fn(...args);
  while (typeof out === 'function') out = out();
  return out;
};
const isEvenStep = (n) => (n === 0 ? true : () => isOddStep(n - 1));
const isOddStep = (n) => (n === 0 ? false : () => isEvenStep(n - 1));
const isEvenSafely = trampoline(isEvenStep);

function isEvenDirect(n) { return n === 0 ? true : isOddDirect(n - 1); }
function isOddDirect(n) { return n === 0 ? false : isEvenDirect(n - 1); }
let mutualFailure;
try { isEvenDirect(100000); mutualFailure = 'no throw'; } catch (e) { mutualFailure = e.constructor.name; }

console.log('recursive :', recursiveFailure, '| tail form:', tailFailure, '| shallow:', shallowStillFine);
console.log('loop      :', sumLoop(DEPTH));
console.log('small tree:', smallRecursive, smallStack, smallForwardPush);
console.log('deep tree :', deepRecursive, '->', deepStackFacts);
console.log('trampoline:', isEvenSafely(100000), isEvenSafely(99999), '| direct:', mutualFailure);