JavaScript: Fundamental (ES6), part 1, 41–76

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 Stall {
  constructor(owner, area) {
    this.owner = owner;
    this.area = area;
  }
  label() {
    return `${this.owner} of ${this.area}`;
  }
}

const oyin = new Stall('oyin', 'Balogun');
const bola = new Stall('bola', 'Yaba');

const ownData = Object.keys(oyin);
const methodIsOwn = Object.prototype.hasOwnProperty.call(oyin, 'label');
const methodIsShared = Object.prototype.hasOwnProperty.call(Stall.prototype, 'label');
const sameFunction = oyin.label === bola.label;
const enumerable = Object.getOwnPropertyDescriptor(Stall.prototype, 'label').enumerable;
const seenByForIn = [];
for (const key in oyin) seenByForIn.push(key);

console.log('instance   :', oyin);
console.log('label()    :', oyin.label());
console.log('own keys   :', ownData, '| label is own?', methodIsOwn);
console.log('on prototype:', methodIsShared, '| one function for both instances?', sameFunction);
console.log('serialised :', JSON.stringify(oyin));

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
44class Cart {
  constructor() {
    this.items = [];
  }
  add(name, kobo) {
    this.items.push({ name, kobo });
    return this;                              // so calls chain
  }
  get total() {
    return this.items.reduce((sum, item) => sum + item.kobo, 0);
  }
  get naira() {
    return `₦${(this.total / 100).toFixed(2)}`;
  }
  set discountPercent(pct) {
    if (typeof pct !== 'number' || pct < 0 || pct > 100) {
      throw new RangeError(`discount ${pct} is not a percentage`);
    }
    this._discount = pct;
  }
  get payable() {
    return Math.round((this.total * (100 - (this._discount ?? 0))) / 100);
  }
}

const attempt = (fn) => { try { fn(); return 'accepted'; } catch (e) { return e.constructor.name; } };

const cart = new Cart().add('gari', 250000).add('palm oil', 480000);
const beforeDiscount = cart.total;
const formatted = cart.naira;
const storedKeys = Object.keys(cart);
const onPrototype = Object.prototype.hasOwnProperty.call(Cart.prototype, 'total');
const descriptor = Object.getOwnPropertyDescriptor(Cart.prototype, 'total');
const refused = attempt(() => { cart.discountPercent = 120; });
cart.discountPercent = 10;
const payable = cart.payable;
const writeToGetter = attempt(() => { cart.total = 0; });
const serialised = JSON.parse(JSON.stringify(cart));

console.log('total   :', beforeDiscount, 'kobo | shown as', formatted);
console.log('stored  :', storedKeys, '| total on prototype?', onPrototype);
console.log('120%    :', refused, '| 10% payable:', payable);
console.log('cart.total = 0 ->', writeToGetter);
console.log('serialised:', serialised);

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
45class Fare {
  static base = 25000;                        // kobo
  static #rates = new Map();

  static {                                    // runs once, at definition time
    Fare.#rates.set('Ikeja', 1);
    Fare.#rates.set('Lekki', 2.5);
    Fare.#rates.set('Yaba', 1.5);
  }

  static price(area) {
    if (!Fare.#rates.has(area)) throw new RangeError(`no rate for ${area}`);
    return Math.round(this.base * Fare.#rates.get(area));   // this = the class called on
  }
  static rateViaThis(area) {
    return this.#rates.get(area);             // only works when this really is Fare
  }
  static get areas() {
    return [...Fare.#rates.keys()];
  }
  constructor(area) {
    this.area = area;
    this.kobo = Fare.price(area);
  }
}

class NightFare extends Fare {
  static base = 40000;                        // same table, dearer base
}

const attempt = (fn) => { try { return fn(); } catch (e) { return e.constructor.name; } };

const ride = new Fare('Ikeja');
const areasKnownBeforeAnyInstance = Fare.areas;
const dayLekki = Fare.price('Lekki');
const nightIkeja = NightFare.price('Ikeja');
const unknown = attempt(() => Fare.price('Epe'));
const privateViaFare = Fare.rateViaThis('Ikeja');
const privateViaSubclass = attempt(() => NightFare.rateViaThis('Ikeja'));

console.log('areas    :', areasKnownBeforeAnyInstance);
console.log('day Lekki:', dayLekki, '| night Ikeja:', nightIkeja);
console.log('instance :', ride, '| ride.base:', ride.base);
console.log('unknown area     :', unknown);
console.log('#rates via Fare  :', privateViaFare, '| via NightFare:', privateViaSubclass);

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
44class Account {
  #kobo = 0;
  #log = [];
  static #opened = 0;

  constructor(owner) {
    this.owner = owner;
    Account.#opened++;
  }
  deposit(kobo) {
    this.#record('in', kobo);
    this.#kobo += kobo;
    return this;
  }
  get balance() {
    return this.#kobo;
  }
  get history() {
    return [...this.#log];                    // a copy, so callers cannot edit it
  }
  #record(kind, kobo) {                       // private method
    this.#log.push(`${kind}:${kobo}`);
  }
  static has(value) {
    return #kobo in value;                    // brand check, never throws
  }
  static get opened() {
    return Account.#opened;
  }
}

const parses = (src) => { try { new Function(src); return 'parsed'; } catch (e) { return e.constructor.name; } };

const tunde = new Account('tunde').deposit(500000);
const ada = new Account('ada');
const outsideAccess = parses('class A { #x = 1; } const a = new A(); return a.#x;');
const insideAccess = parses('class A { #x = 1; read() { return this.#x; } } return new A().read();');
const impostor = { owner: 'tunde', balance: 500000 };

console.log('balance  :', tunde.balance, '| history:', tunde.history);
console.log('own keys :', Object.keys(tunde), '| JSON:', JSON.stringify(tunde));
console.log('a.#x outside the class parses?', outsideAccess, '| inside?', insideAccess);
console.log('brand    :', Account.has(tunde), Account.has(impostor));
console.log('opened   :', Account.opened);

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
46class Vehicle {
  static fleet = 'Lagos';
  constructor(plate) {
    this.plate = plate;
    this.trips = 0;
  }
  describe() {
    return `vehicle ${this.plate}`;
  }
  run(km) {
    this.trips++;
    return km;
  }
}

class Danfo extends Vehicle {
  constructor(plate, seats) {
    super(plate);                             // parent first
    this.seats = seats;
  }
  describe() {
    return `danfo ${super.describe()} with ${this.seats} seats`;
  }
  run(km) {
    return super.run(km) * this.seats;        // parent counts, child scales
  }
}

const bus = new Danfo('LSD-244-XA', 14);
const scaled = bus.run(10);

const tooEarly = (() => {
  class Broken extends Vehicle {
    constructor() {
      this.plate = 'set before super';        // illegal
      super('never reached');
    }
  }
  try { new Broken(); return 'built'; } catch (e) { return e.constructor.name; }
})();

console.log('keys     :', Object.keys(bus));
console.log('describe :', bus.describe());
console.log('run(10)  :', scaled, '| trips now', bus.trips);
console.log('statics  :', Danfo.fleet, '| Danfo.__proto__ === Vehicle:', Object.getPrototypeOf(Danfo) === Vehicle);
console.log('this before super():', tooEarly);

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 calls = [];

class Base {
  constructor() {
    calls.push('Base constructor');
    this.setUp();                             // calls the child's override
  }
  setUp() {
    this.ready = 'base';
  }
}

class WithField extends Base {
  ready = 'field';                            // runs AFTER super() returns
  setUp() {
    calls.push('override ran');
    this.ready = 'override';
  }
}

class WithAssignment extends Base {
  constructor() {
    super();                                  // override's value is left alone
    calls.push('after super');
  }
  setUp() {
    this.ready = 'override';
  }
}

const surprising = new WithField();
const expected = new WithAssignment();

class Rate {
  constructor() { this.kobo = 25000; }
}
class Doubled extends Rate {
  twice = this.kobo * 2;                      // parent already ran, so this works
}

class Forward {
  first = 1;
  second = this.first + 1;
}
class Backward {
  second = this.first + 1;                    // first is still undefined here
  first = 1;
}

class Both {
  field = () => 'arrow';
  method() { return 'method'; }
}
const both = new Both();

console.log('call order    :', calls);
console.log('with a field  :', surprising.ready, '<- the override was overwritten');
console.log('with an assign:', expected.ready);
console.log('field reading the parent:', new Doubled().twice);
console.log('top to bottom :', new Forward().second, '| bottom to top:', new Backward().second);
console.log('own keys of Both:', Object.keys(both));

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
31class Market {}
class OpenMarket extends Market {}

class Even {
  static [Symbol.hasInstance](value) {
    return Number.isInteger(value) && value % 2 === 0;
  }
}

const attempt = (fn) => { try { return fn(); } catch (e) { return e.constructor.name; } };

const shop = new OpenMarket();
const upTheChain = [shop instanceof OpenMarket, shop instanceof Market, shop instanceof Object];
const notDownIt = new Market() instanceof OpenMarket;

const neverConstructed = Object.create(OpenMarket.prototype);
const countsAnyway = neverConstructed instanceof OpenMarket;

const demoted = new OpenMarket();
Object.setPrototypeOf(demoted, Market.prototype);
const afterSwap = [demoted instanceof OpenMarket, demoted instanceof Market];

const primitives = ['text' instanceof String, new String('text') instanceof String];
const arrays = [[] instanceof Array, Array.isArray([])];
const notCallable = attempt(() => shop instanceof { prototype: Market.prototype });

console.log('up the chain :', upTheChain, '| down it:', notDownIt);
console.log('Object.create:', countsAnyway, '| after setPrototypeOf:', afterSwap);
console.log('primitives   :', primitives, '| arrays:', arrays);
console.log('right side not callable:', notCallable);
console.log('hasInstance  :', 4 instanceof Even, 5 instanceof Even);

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 classFirst() {
  let out;
  try { out = new Kiosk('A').tag; } catch (e) { out = e.constructor.name; }
  class Kiosk {
    constructor(id) { this.tag = 'kiosk-' + id; }
  }
  return out;
}

function functionFirst() {
  const made = kiosk('A');                    // fine: hoisted whole
  function kiosk(id) { return 'kiosk-' + id; }
  return made;
}

function typeofBefore() {
  let seen;
  try { seen = typeof Kiosk; } catch (e) { seen = e.constructor.name; }
  class Kiosk {}
  return seen;
}

function extendsLater() {
  let out;
  try { class Child extends Parent {} out = 'declared'; } catch (e) { out = e.constructor.name; }
  class Parent {}
  return out;
}

class Fixed {
  static rename() {
    try { Fixed = 1; return 'changed'; } catch (e) { return e.constructor.name; }
  }
}

const Anon = class {
  kind = 'anon';
};

class Kiosk {
  constructor(id) { this.tag = 'kiosk-' + id; }
}
const afterDeclaration = new Kiosk('B').tag;

console.log('class used first   :', classFirst());
console.log('function used first:', functionFirst());
console.log('typeof in the dead zone:', typeofBefore(), '| typeof undeclared:', typeof NoSuchClass);
console.log('extends a later class  :', extendsLater());
console.log('after the declaration  :', afterDeclaration);
console.log('rename from inside     :', Fixed.rename(), '| expression class name:', Anon.name);

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
35const seen = [];

function Fee(kobo) {
  seen.push(new.target === undefined ? 'no new' : new.target.name);
  if (!new.target) return new Fee(kobo);      // called flat: put it right
  this.kobo = kobo;
}

class Levy {
  constructor(kobo) { this.kobo = kobo; }
}

class Payment {
  static built = [];
  constructor(kobo) {
    if (new.target === Payment) throw new TypeError('Payment is abstract');
    Payment.built.push(new.target.name);
    this.kobo = kobo;
  }
}
class Transfer extends Payment {}

const attempt = (fn) => { try { return fn(); } catch (e) { return e.constructor.name; } };

const withNew = new Fee(500);
const withoutNew = Fee(500);
const calledFlat = attempt(() => Levy(500));
const abstractDirect = attempt(() => new Payment(100));
const transfer = new Transfer(750);

console.log('new.target seen  :', seen);
console.log('with new         :', withNew, '| without new:', withoutNew);
console.log('class called flat:', calledFlat);
console.log('new Payment()    :', abstractDirect, '| new Transfer():', transfer);
console.log('base saw target  :', Payment.built);

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
30class Counter {
  count = 0;
  bump() {                                    // prototype method
    this.count++;
    return this.count;
  }
  bumpArrow = () => {                         // own field, this captured
    this.count++;
    return this.count;
  };
}

class Sub extends Counter {
  bumpArrow() {                               // never reached
    return 'from the subclass prototype';
  }
}

const attempt = (fn) => { try { return fn(); } catch (e) { return e.constructor.name; } };

const counter = new Counter();
const detachedMethod = counter.bump;
const detachedArrow = counter.bumpArrow;
const rebound = counter.bump.bind(counter);
const looseCall = attempt(() => detachedMethod());

console.log('detached method:', looseCall);
console.log('own keys       :', Object.keys(counter));
console.log('arrow on prototype?', Object.prototype.hasOwnProperty.call(Counter.prototype, 'bumpArrow'));
console.log('subclass call  :', new Sub().bumpArrow(), '<- the inherited field won');

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
34const areas = ['Ikeja', 'Yaba', 'Lekki'];
areas.note = 'stray property';

const values = [];
for (const area of areas) values.push(area);

const keys = [];
for (const key in areas) keys.push(key);
const keyTypes = keys.map((k) => typeof k);

const sparse = [1, , 3];                      // one hole in the middle
const ofSparse = [];
for (const v of sparse) ofSparse.push(v === undefined ? 'hole' : v);
const inSparse = [];
for (const i in sparse) inSparse.push(i);

const parent = { inherited: 'from the prototype' };
const child = Object.create(parent);
child.own = 'mine';
const inChild = [];
for (const key in child) inChild.push(key);

const attempt = (fn) => { try { return fn(); } catch (e) { return e.constructor.name; } };
const overObject = attempt(() => {
  const out = [];
  for (const v of { a: 1 }) out.push(v);
  return out;
});

console.log('for...of :', values);
console.log('for...in :', keys, '| types:', keyTypes);
console.log('sparse   : of ->', ofSparse, '| in ->', inSparse);
console.log('inherited: for...in ->', inChild, '| Object.keys ->', Object.keys(child));
console.log('for...of over a plain object:', overObject);

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
26const arrayLike = { 0: 'gari', 1: 'rice', length: 2 };

const attempt = (fn) => { try { return fn(); } catch (e) { return e.constructor.name; } };

const spreadFails = attempt(() => [...arrayLike]);
const viaFrom = Array.from(arrayLike);
const viaSlice = Array.prototype.slice.call(arrayLike);
const mapped = Array.from(arrayLike, (item) => item.toUpperCase());
const range = Array.from({ length: 4 }, (_, i) => i * 250);
const noLength = Array.from({ a: 1 });
const shortLength = Array.from({ 0: 'a', 1: 'b', length: 1 });

function collect() {
  return [...arguments];                      // arguments is iterable
}
const spreadArguments = collect('gari', 'rice');

const iteratorPresence = [typeof arrayLike[Symbol.iterator], typeof [][Symbol.iterator]];
const stringSpread = [...'Yaba'];
const setSpread = [...new Set(['a', 'a', 'b'])];

console.log('spread   :', spreadFails);
console.log('Array.from:', viaFrom, '| slice.call:', viaSlice);
console.log('mapped   :', mapped, '| generated range:', range);
console.log('no length:', noLength, '| length shorter than the keys:', shortLength);
console.log('arguments:', spreadArguments, '| iterator present?', iteratorPresence);

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
43class Route {
  constructor(...stops) {
    this.stops = stops;
  }
  [Symbol.iterator]() {
    let i = 0;
    const stops = this.stops;                 // captured, so next() needs no this
    return {
      next: () => (i < stops.length
        ? { value: stops[i++], done: false }
        : { value: undefined, done: true }),
    };
  }
}

const range = (from, to) => ({
  [Symbol.iterator]() {
    let n = from;
    return { next: () => (n <= to ? { value: n++, done: false } : { value: undefined, done: true }) };
  },
});

const route = new Route('Oshodi', 'Ikeja', 'Agege');

const walked = [...route];
const twice = [[...route].length, [...route].length];
const [first, ...rest] = route;

const upToIkeja = [];
for (const stop of route) {
  if (stop === 'Ikeja') break;                // stops pulling
  upToIkeja.push(stop);
}

const firstResult = route[Symbol.iterator]().next();
const numbers = [...range(1, 4)];
const sum = numbers.reduce((a, b) => a + b, 0);

console.log('spread      :', walked);
console.log('twice       :', twice, '<- a fresh iterator each time');
console.log('destructured:', first, rest);
console.log('break       :', upToIkeja);
console.log('first result:', firstResult, '| range:', numbers, 'sum', sum);

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
40function* stops() {
  yield 'Oshodi';
  yield 'Ikeja';
  yield 'Agege';
  return 'depot';                             // not a yielded value
}

const log = [];
function* traced() {
  log.push('started');
  yield 1;
  log.push('resumed');
  yield 2;
  log.push('finished');
}

const it = traced();
const beforeAnyNext = [...log];               // still empty: nothing has run
const firstPull = it.next();
const afterFirst = [...log];
const secondPull = it.next();
const thirdPull = it.next();
const fourthPull = it.next();

const spread = [...stops()];
const viaForOf = [];
for (const stop of stops()) viaForOf.push(stop);

const g = stops();
g.next(); g.next(); g.next();
const withReturn = g.next();

const kinds = [typeof stops, typeof stops()];

console.log('before any next():', beforeAnyNext);
console.log('first pull       :', firstPull, '| log:', afterFirst);
console.log('second, third    :', secondPull, thirdPull);
console.log('log at the end   :', log);
console.log('spread           :', spread, '| return value:', withReturn);
console.log('typeof           :', kinds);

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
55function* naturals(from = 1) {
  let n = from;
  while (true) yield n++;                     // never ends, and never runs unpulled
}

function* take(iterable, count) {
  if (count <= 0) return;
  let left = count;
  for (const item of iterable) {
    yield item;
    if (--left === 0) return;                 // stops pulling the source
  }
}

function* takeWhile(iterable, ok) {
  for (const item of iterable) {
    if (!ok(item)) return;
    yield item;
  }
}

function* mapped(iterable, fn) {
  for (const item of iterable) yield fn(item);
}

function* fib() {
  let [a, b] = [0, 1];
  while (true) {
    yield a;
    [a, b] = [b, a + b];
  }
}

let produced = 0;
function* counted() {
  let n = 1;
  while (true) {
    produced++;
    yield n++;
  }
}

const firstFive = [...take(naturals(), 5)];
const firstThree = [...take(counted(), 3)];
const nothing = [...take(naturals(), 0)];
const fares = [...take(mapped(naturals(), (n) => n * 25000), 3)];
const firstEight = [...take(fib(), 8)];
const underHundred = [...takeWhile(fib(), (n) => n < 100)];
const bothProtocols = [typeof naturals().next, typeof naturals()[Symbol.iterator]];

console.log('take 5    :', firstFive);
console.log('laziness  :', firstThree, 'and the source ran', produced, 'times');
console.log('take 0    :', nothing, '| mapped then taken:', fares);
console.log('fib 8     :', firstEight);
console.log('under 100 :', underHundred);

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
46function* stops() {
  yield 'Oshodi';
  yield 'Ikeja';
}

const gen = stops();
const isOwnIterator = gen[Symbol.iterator]() === gen;
const firstSpread = [...gen];
const secondSpread = [...gen];                // empty: already drained
let loopsRun = 0;
for (const stop of gen) loopsRun++;           // body never entered

const split = stops();
const pulledOne = split.next().value;
const remainder = [...split];                 // resumes, does not restart

const closedByBreak = stops();
const beforeBreak = [];
for (const stop of closedByBreak) {
  beforeBreak.push(stop);
  break;                                      // calls return() on the generator
}
const afterBreak = [...closedByBreak];

const route = {
  *[Symbol.iterator]() {                      // a NEW generator per call
    yield 'Oshodi';
    yield 'Ikeja';
  },
};

class Line {
  constructor(...stops) { this.stops = stops; }
  *[Symbol.iterator]() {
    for (const stop of this.stops) yield stop;
  }
}
const line = new Line('Yaba', 'Surulere');

console.log('own iterator?  :', isOwnIterator);
console.log('first spread   :', firstSpread, '| second:', secondSpread);
console.log('for...of after :', loopsRun, 'iterations');
console.log('split          :', pulledOne, remainder);
console.log('break then read:', beforeBreak, afterBreak);
console.log('route twice    :', [...route], [...route]);
console.log('class twice    :', [...line], [...line]);

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
29const stalls = ['gari', 'rice', 'beans'];

const arrayEntries = [...stalls.entries()];
const numbered = [];
for (const [i, name] of stalls.entries()) numbered.push(`${i + 1}. ${name}`);
const arrayKeys = [...stalls.keys()];
const keyKinds = arrayKeys.map((k) => typeof k);
const arrayValues = [...stalls.values()];

const prices = new Map([['gari', 250000], ['rice', 480000]]);
const mapDefault = [...prices];
const mapEntries = [...prices.entries()];
const total = [...prices.values()].reduce((sum, kobo) => sum + kobo, 0);

const forEachOrder = [];
prices.forEach((value, key) => forEachOrder.push(`${key}=${value}`));

const iterator = prices.keys();
const drained = [...iterator];
const again = [...iterator];                  // an iterator is used up

const shapes = [Array.isArray(Object.keys({ a: 1 })), Array.isArray([...prices.keys()]), Array.isArray(prices.keys())];

console.log('array entries:', arrayEntries);
console.log('numbered     :', numbered);
console.log('array keys   :', arrayKeys, keyKinds);
console.log('map default  :', mapDefault);
console.log('total        :', total, '| forEach order:', forEachOrder);
console.log('iterator     :', drained, 'then', again);

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 stall = { id: 'stall-1' };
const callback = () => 'noop';
const area = Symbol('area');

const notes = new Map();
notes
  .set(stall, 'Balogun')
  .set(callback, 'a function key')
  .set(area, 'a symbol key')
  .set(1, 'the number one')
  .set('1', 'the string one')
  .set(NaN, 'not a number')
  .set(true, 'a boolean key');

const byIdentity = notes.get(stall);
const byLookalike = notes.get({ id: 'stall-1' });
const numberVersusString = [notes.get(1), notes.get('1')];
const nanKey = notes.get(NaN);
const byFunction = notes.get(callback);
const bySymbol = notes.get(area);
const sizeBefore = notes.size;

const indexOfNaN = [NaN, 1].indexOf(NaN);
const findIndexOfNaN = [NaN, 1].findIndex(Number.isNaN);
const includesNaN = [NaN, 1].includes(NaN);

const zeroes = new Map().set(0, 'zero');
const viaMinusZero = zeroes.get(-0);

const removals = [notes.delete(callback), notes.delete(callback)];
const stillThere = notes.has(callback);

console.log('by identity  :', byIdentity, '| by a lookalike:', byLookalike);
console.log('1 vs "1"     :', numberVersusString);
console.log('NaN as a key :', nanKey, '| indexOf(NaN):', indexOfNaN, '| includes(NaN):', includesNaN);
console.log('-0 finds 0   :', viaMinusZero, '| size:', sizeBefore);
console.log('delete twice :', removals, '| has after:', stillThere);

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
29const asObject = {};
asObject[3] = 'third';
asObject[1] = 'first';
asObject.zone = 'B';
asObject[2] = 'second';
const objectOrder = Object.keys(asObject);

const asMap = new Map();
asMap.set(3, 'third').set(1, 'first').set('zone', 'B').set(2, 'second');
const mapOrder = [...asMap.keys()];
const mapKeyKinds = mapOrder.map((k) => typeof k);
const objectKeyKinds = objectOrder.map((k) => typeof k);

const reset = new Map([['a', 1], ['b', 2], ['c', 3]]);
reset.set('a', 99);
const afterOverwrite = [...reset.keys()];
reset.delete('b');
reset.set('b', 2);
const afterDeleteAndSet = [...reset.keys()];

const counts = [Object.keys(asObject).length, asMap.size];
const inheritedOnObject = 'toString' in {};
const inheritedOnMap = new Map().has('toString');

console.log('object order:', objectOrder, objectKeyKinds);
console.log('map order   :', mapOrder, mapKeyKinds);
console.log('overwrite   :', afterOverwrite, '| delete then set:', afterDeleteAndSet);
console.log('counts      :', counts);
console.log('inherited   : object', inheritedOnObject, '| map', inheritedOnMap);

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
26const arrivals = ['Ikeja', 'Yaba', 'Ikeja', 'Lekki', 'Yaba'];

const unique = [...new Set(arrivals)];
const seen = new Set(arrivals);
const size = seen.size;
const membership = [seen.has('Yaba'), seen.has('Epe')];
const returned = seen.add('Ikeja');           // already there
const sizeAfterAdd = seen.size;
const chained = new Set().add('gari').add('rice').size;

const oddValues = new Set([NaN, NaN, 0, -0]);
const objects = new Set([{ id: 1 }, { id: 1 }]);
const order = [...new Set([3, 1, 3, 2, 1])];

const left = ['gari', 'rice'];
const right = ['rice', 'beans'];
const union = [...new Set([...left, ...right])];
const rightSet = new Set(right);
const intersection = [...new Set(left)].filter((item) => rightSet.has(item));

console.log('unique     :', unique, '| size:', size);
console.log('membership :', membership);
console.log('add again  :', sizeAfterAdd, '| add returned the set:', returned === seen);
console.log('NaN and -0 :', oddValues.size, '| two equal objects:', objects.size);
console.log('order      :', order);
console.log('union      :', union, '| intersection:', intersection);

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
26const prices = new Map([['gari', 250000], ['rice', 480000]]);

const asPairs = [...prices];
const asObject = Object.fromEntries(prices);
const backToMap = new Map(Object.entries(asObject));
const roundTripped = [...backToMap];
const keysArray = Array.from(prices.keys());
const labelled = Array.from(prices, ([name, kobo]) => `${name}: ₦${kobo / 100}`);

const stock = new Set(['gari', 'rice']);
const jsonAttempts = [JSON.stringify(prices), JSON.stringify(stock)];
const jsonAfterConverting = [JSON.stringify(Object.fromEntries(prices)), JSON.stringify([...stock])];

const tally = new Map();
for (const area of ['Ikeja', 'Yaba', 'Ikeja']) tally.set(area, (tally.get(area) ?? 0) + 1);
const tallyAsObject = Object.fromEntries(tally);

const dear = new Map([...prices].filter(([, kobo]) => kobo > 300000));
const doubled = new Map([...prices].map(([name, kobo]) => [name, kobo * 2]));

console.log('pairs     :', asPairs);
console.log('object    :', asObject, '| back to a Map:', roundTripped);
console.log('labelled  :', labelled);
console.log('JSON      :', jsonAttempts, '<- both empty');
console.log('converted :', jsonAfterConverting);
console.log('tally     :', tallyAsObject, '| filtered:', [...dear]);

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
38const attempt = (fn) => { try { return fn(); } catch (e) { return e.constructor.name; } };

const store = {};
const inheritedHit = ['toString' in store, typeof store.toString];
const mapMiss = new Map().has('toString');

store[1] = 'a number key';
const stringifiedKey = [Object.keys(store), store['1'] === store[1]];

const collisions = (() => {
  const o = {};
  o[{ id: 1 }] = 'first';
  o[{ id: 2 }] = 'second';                    // the same key as above
  return [Object.keys(o), o[{ id: 99 }]];
})();

const shadowed = { hasOwnProperty: 'not a function at all' };
const brokenCheck = attempt(() => shadowed.hasOwnProperty('x'));
const properCheck = Object.hasOwn(shadowed, 'hasOwnProperty');

const protoWrite = {};
protoWrite.__proto__ = 'ignored';             // silently not stored
const protoKeys = Object.keys(protoWrite);
const mapStoresIt = new Map().set('__proto__', 'stored').get('__proto__');

const bare = Object.create(null);
const bareBefore = ['toString' in bare, typeof bare.hasOwnProperty];
bare.toString = 'now just data';              // a key like any other here
const bareLookup = [...bareBefore, bare.toString];

const counts = [Object.keys({ a: 1, b: 2 }).length, new Map([['a', 1], ['b', 2]]).size];

console.log('inherited :', inheritedHit, '| a Map:', mapMiss);
console.log('key types :', stringifiedKey);
console.log('collision :', collisions);
console.log('shadowed  :', brokenCheck, '| Object.hasOwn:', properCheck);
console.log('__proto__ :', protoKeys, '| a Map:', mapStoresIt);
console.log('null proto:', bareLookup, '| counts:', counts);

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
42const makeCounter = (start = 0, step = 1) => {
  let count = start;                          // private: no other way in
  return {
    next: () => (count += step),
    peek: () => count,
    reset: () => { count = start; return count; },
  };
};

const once = (fn) => {
  let called = false;
  let result;
  return (...args) => {
    if (called) return result;
    called = true;
    result = fn(...args);
    return result;
  };
};

let charges = 0;
const charge = (kobo) => { charges++; return `charged ${kobo}`; };
const chargeOnce = once(charge);

const ticket = makeCounter(100);
const other = makeCounter(100);
const threeInARow = [ticket.next(), ticket.next(), ticket.next()];
const otherUntouched = other.peek();
const afterReset = [ticket.reset(), ticket.next()];
const inFives = (() => {
  const c = makeCounter(0, 5);
  return [c.next(), c.next()];
})();

const results = [chargeOnce(500), chargeOnce(999), chargeOnce(1)];
const exposed = Object.keys(ticket);
const shared = ticket.next === other.next;

console.log('three pulls :', threeInARow, '| the other counter:', otherUntouched);
console.log('reset       :', afterReset, '| step of five:', inFives);
console.log('once        :', results, '| the wrapped function ran', charges, 'time(s)');
console.log('what is public:', exposed, '| count reachable?', ticket.count);

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 memoise = (fn) => {
  const cache = new Map();
  const memo = (...args) => {
    const key = JSON.stringify(args);
    if (cache.has(key)) return cache.get(key);
    const value = fn(...args);
    cache.set(key, value);
    return value;
  };
  memo.keys = () => [...cache.keys()];
  return memo;
};

const memoiseByArg = (fn) => {
  const cache = new Map();
  return (arg) => {
    if (cache.has(arg)) return cache.get(arg);
    const value = fn(arg);
    cache.set(arg, value);
    return value;
  };
};

let fareCalls = 0;
const slowFare = (km, area) => {
  fareCalls++;
  return km * (area === 'Lekki' ? 2500 : 1000);
};
const fare = memoise(slowFare);
const first = fare(10, 'Lekki');
const repeated = fare(10, 'Lekki');
const different = fare(10, 'Ikeja');
const fareCallsAfter = fareCalls;

let kindCalls = 0;
const kindOf = (value) => { kindCalls++; return typeof value; };
const memoKind = memoise(kindOf);
const forUndefined = memoKind(undefined);
const forNull = memoKind(null);               // a HIT on the same key
const forNaN = memoKind(NaN);                 // another one
const kindCallsAfter = kindCalls;
const cachedKeys = memoKind.keys();

let areaCalls = 0;
const areaOf = (o) => { areaCalls++; return `${o.lga}/${o.zone}`; };
const memoArea = memoise(areaOf);
const inOrder = memoArea({ lga: 'Eti-Osa', zone: 'B' });
const reversed = memoArea({ zone: 'B', lga: 'Eti-Osa' });
const areaCallsAfter = areaCalls;

let exactCalls = 0;
const exact = memoiseByArg((value) => { exactCalls++; return String(value); });
const nanTwice = [exact(NaN), exact(NaN)];
const callsAfterNaN = exactCalls;
const nullAndUndefined = [exact(undefined), exact(null)];
const callsAtTheEnd = exactCalls;

console.log('fare      :', first, repeated, different, '| calls:', fareCallsAfter);
console.log('collision :', [forUndefined, forNull, forNaN], '| calls:', kindCallsAfter, '| keys:', cachedKeys);
console.log('key order :', inOrder, reversed, '| calls:', areaCallsAfter);
console.log('by arg    :', nanTwice, nullAndUndefined, '| calls:', callsAtTheEnd);

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
36const fare = (base, perKm, km) => base + perKm * km;

const partial = (fn, ...fixed) => (...rest) => fn(...fixed, ...rest);
const lagosFare = partial(fare, 25000, 1500);
const viaBind = fare.bind(null, 25000, 1500);

const curry = (fn) => {
  const collect = (got) => (...args) => {
    const all = [...got, ...args];
    return all.length >= fn.length ? fn(...all) : collect(all);
  };
  return collect([]);
};
const curried = curry(fare);

const pipe = (...fns) => (value) => fns.reduce((acc, fn) => fn(acc), value);
const compose = (...fns) => (value) => fns.reduceRight((acc, fn) => fn(acc), value);

const toKobo = (naira) => naira * 100;
const addVat = (kobo) => Math.round(kobo * 1.075);
const label = (kobo) => `₦${kobo / 100}`;

const priced = pipe(toKobo, addVat, label);
const sameThing = compose(label, addVat, toKobo);
const directions = [pipe((n) => n + 1, (n) => n * 2)(5), compose((n) => n + 1, (n) => n * 2)(5)];

const variadic = (...args) => args.length;
const brokenCurry = curry(variadic);
const collectedNothing = brokenCurry();
const arities = [fare.length, viaBind.length, lagosFare.length];

console.log('partial   :', lagosFare(10), '| bind:', viaBind(10));
console.log('curried   :', curried(25000)(1500)(10), curried(25000, 1500)(10));
console.log('pipe      :', priced(400), '| compose:', sameThing(400));
console.log('directions:', directions);
console.log('arities   :', arities, '| curry of a variadic function:', collectedNothing);

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
39const readOrder = ({
  item,
  qty: quantity = 1,
  price: kobo = 0,
  buyer: { name: buyerName = 'walk-in', phone = null } = {},
  ...extras
} = {}) => ({ item, quantity, kobo, buyerName, phone, extras });

const full = readOrder({
  item: 'garri',
  qty: 3,
  price: 90000,
  buyer: { name: 'Adaeze', phone: '0803' },
  market: 'Ikeja',
  note: 'coarse',
});
const bare = readOrder({ item: 'yam' });
const nothing = readOrder();

// A default answers "was it undefined", not "was it empty".
const withNull = readOrder({ item: 'rice', qty: null }).quantity;
const withZero = readOrder({ item: 'rice', qty: 0 }).quantity;

// Destructuring undefined is a TypeError, which is why the = {} is there.
let cracked;
try {
  const { item } = undefined;
  cracked = item;
} catch (error) {
  cracked = error.constructor.name;
}

// Renaming moves the binding: the source key never becomes a variable.
const sourceKeyInScope = typeof qty;

console.log('full   :', full);
console.log('bare   :', bare);
console.log('nothing:', nothing.item, nothing.quantity, nothing.buyerName);
console.log('null vs zero:', withNull, withZero, '| undefined:', cracked);

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
30let first = 'Ikeja';
let second = 'Yaba';
[first, second] = [second, first];

const readings = [12, 45, 78, 91, 103];
const [, secondReading, , ...tail] = readings;

let lookups = 0;
const fallbackRate = () => {
  lookups++;
  return 1500;
};
const [cheap = fallbackRate(), dear = fallbackRate()] = [900];

const rows = [['Adaeze', 3], ['Bola', 1]];
const named = rows.map(([who, howMany]) => `${who} x${howMany}`);

const [[a, b], [c]] = [[1, 2], [3, 4]];
const [x, y, z] = 'NG';
const [only, missing] = [7];
const [head, ...nothingLeft] = [7];

const tally = new Map([['garri', 2], ['rice', 5]]);
const asLines = [];
for (const [good, count] of tally) asLines.push(`${good}=${count}`);

console.log('swap    :', first, second);
console.log('skipped :', secondReading, tail);
console.log('lazy    :', cheap, dear, '| fallback ran', lookups, 'time(s)');
console.log('nested  :', a, b, c, '| string:', x, y, z);

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
38const total = (...amounts) => amounts.reduce((sum, n) => sum + n, 0);
const takeThrough = (label, ...rest) => `${label}:${rest.length}`;

const prices = [45000, 12000, 3000];
const sumOfPrices = total(...prices);
const withExtra = total(...prices, 500);
const forwarded = takeThrough('cart', ...prices);
const shifted = takeThrough(...prices);

const biggest = Math.max(...prices);
const ofNothing = Math.max(...[]);
const emptyIsInfinity = ofNothing === -Infinity;

const base = { market: 'Ikeja', currency: 'NGN', open: true };
const patch = { open: false, note: 'renovating' };
const merged = { ...base, ...patch };
const guarded = { ...patch, ...base };

const tag = Symbol('internal');
const spreadKeepsSymbols = { ...{ [tag]: 'yes', shown: 1 } };
const symbolSurvived = spreadKeepsSymbols[tag];
const jsonDropsIt = JSON.stringify(spreadKeepsSymbols);

const seen = new Set(['garri', 'rice', 'garri']);
const fromSet = [...seen];
const fromString = [...'NGN'];
const spreadNullObject = { ...null };
let spreadNullArray;
try {
  spreadNullArray = [...null];
} catch (error) {
  spreadNullArray = error.constructor.name;
}

console.log('total  :', sumOfPrices, withExtra, forwarded, shifted);
console.log('max    :', biggest, '| of nothing:', ofNothing);
console.log('merged :', merged, '| other order:', guarded.open);
console.log('spread :', fromSet, fromString, spreadNullObject, spreadNullArray);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23const kobo = { garri: 90000, rice: 450000, palmOil: 120000 };

const mapValues = (o, fn) => Object.fromEntries(Object.entries(o).map(([k, v]) => [k, fn(v, k)]));
const filterValues = (o, keep) => Object.fromEntries(Object.entries(o).filter(([k, v]) => keep(v, k)));

const naira = mapValues(kobo, (k) => k / 100);
const dear = filterValues(kobo, (k) => k >= 120000);
const shouted = Object.fromEntries(Object.entries(kobo).map(([k, v]) => [k.toUpperCase(), v]));
const roundTripped = same(Object.fromEntries(Object.entries(kobo)), kobo);

const stock = new Map([['garri', 12], ['rice', 4]]);
const fromMap = Object.fromEntries(stock);
const backToMap = [...new Map(Object.entries(fromMap))];

const duplicated = Object.fromEntries([['lga', 'Ikeja'], ['lga', 'Eti-Osa']]);
const numericOrder = Object.entries({ 10: 'ten', 2: 'two', zone: 'B', 1: 'one' });
const arrayEntries = Object.entries(['a', 'b']);
const valuesAndKeys = [Object.keys(kobo).length, Object.values(kobo).reduce((a, b) => a + b, 0)];

console.log('naira  :', naira);
console.log('filter :', dear, '| shouted:', shouted);
console.log('map    :', fromMap, backToMap);
console.log('dupes  :', duplicated, '| order:', numericOrder.map(([k]) => k));

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
46const stall = {
  owner: { name: 'Adaeze', phone: null },
  display: { pageSize: 0, label: '', printable: false },
  tools: { print: (what) => `printing ${what}` },
  address: null,
};

const city = stall.address?.city;
const deeper = stall.address?.city.lga.zone;   // the WHOLE chain is skipped
const dynamic = stall.display?.['pageSize'];
const printed = stall.tools.print?.('receipt');
const emailed = stall.tools.email?.('receipt');

let sideEffects = 0;
const argument = () => {
  sideEffects++;
  return 'x';
};
const skipped = stall.tools.email?.(argument());
const ran = stall.tools.print?.(argument());

const pageSize = stall.display.pageSize ?? 20;
const pageSizeWrong = stall.display.pageSize || 20;
const label = stall.display.label ?? 'Ikeja stall';
const labelWrong = stall.display.label || 'Ikeja stall';
const phone = stall.owner.phone ?? 'none';
const printable = stall.display.printable ?? true;

let mixed;
try {
  mixed = new Function('return null ?? 1 || 2;')();
} catch (error) {
  mixed = error.constructor.name;
}

let unguarded;
try {
  unguarded = stall.address.city?.name;   // ?. after the null, not before it
} catch (error) {
  unguarded = error.constructor.name;
}

console.log('chain  :', city, deeper, dynamic);
console.log('calls  :', printed, emailed, '| side effects:', sideEffects);
console.log('?? vs ||:', [pageSize, pageSizeWrong], [label, labelWrong]);
console.log('mixed  :', mixed, '| unguarded:', unguarded);

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
44const applyDefaults = (o) => {
  o.pageSize ??= 20;          // absent only
  o.label ||= 'Ikeja stall';  // anything falsy
  o.currency ??= 'NGN';
  o.note &&= o.note.trim();   // present only
  return o;
};

const partial = applyDefaults({ pageSize: 0, label: '', note: '  ripe  ' });
const empty = applyDefaults({});
const noteWasNotCreated = 'note' in empty;

let writes = 0;
let reads = 0;
const account = {
  _kobo: 500000,
  get kobo() {
    reads++;
    return this._kobo;
  },
  set kobo(value) {
    writes++;
    this._kobo = value;
  },
};

account.kobo ??= 1;                  // 500000 is not nullish, so NO write
account.kobo ||= 1;                  // 500000 is truthy, so NO write
const writesAfterShortCircuit = writes;
account.kobo &&= account.kobo + 100; // truthy, so this one does write
const writesAfterUpdate = writes;

const always = { _n: 0, get n() { return this._n; }, set n(v) { writes++; this._n = v; } };
always.n = always.n || 7;            // the old spelling: always writes
const writesAfterOldSpelling = writes;

const flags = { verbose: false, retries: 0 };
flags.verbose ||= true;
flags.retries ??= 5;

console.log('partial:', partial);
console.log('empty  :', empty, '| note created:', noteWasNotCreated);
console.log('account:', account._kobo, '| writes:', writes, '| reads:', reads);
console.log('flags  :', flags);

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
28const fares = Array.from({ length: 5 }, (_, i) => 250 + i * 150);
const seats = Array.from({ length: 3 }, (_, i) => `A${i + 1}`);

const holes = new Array(3);
const mappedHoles = holes.map((_, i) => i);
const holesStayedHoles = mappedHoles.every((v) => v === undefined);
const filled = Array.from(holes, (_, i) => i);
const blank = Array.from({ length: 2 });
const blankIsUndefined = blank.every((v) => v === undefined);

const repeated = ['garri', 'rice', 'garri', 'beans'];
const unique = Array.from(new Set(repeated));
const shouted = Array.from('Ikeja', (c) => c.toUpperCase());

const flag = '🇳🇬';
const unitsAgainstPoints = [flag.length, Array.from(flag).length];

const stock = new Map([['garri', 12], ['rice', 4]]);
const asPairs = Array.from(stock);
const labels = Array.from(stock, ([good, count]) => `${good}:${count}`);

const arrayLike = { length: 3, 0: 'Lagos', 2: 'Kano' };
const fromArrayLike = Array.from(arrayLike, (v) => v ?? 'gap');

console.log('fares  :', fares, seats);
console.log('holes  :', mappedHoles, '| from:', filled);
console.log('unique :', unique, '| shouted:', shouted);
console.log('map    :', asPairs, labels, '| array-like:', fromArrayLike);

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
27const takings = [[4500, 12000], [8000], [[3000, 1000], 500]];

const oneLevel = takings.flat();
const twoLevels = takings.flat(2);
const allLevels = takings.flat(Infinity);
const totalOfAll = allLevels.reduce((a, b) => a + b, 0);

const orders = [
  { item: 'garri', qty: 2, kobo: 45000 },
  { item: 'rice', qty: 0, kobo: 450000 },
  { item: 'beans', qty: 3, kobo: 30000 },
];

const lines = orders.flatMap(({ item, qty }) => Array.from({ length: qty }, (_, i) => `${item} #${i + 1}`));
const priced = orders.flatMap(({ item, qty, kobo }) => (qty === 0 ? [] : [`${item}=${(qty * kobo) / 100}`]));
const withIndex = orders.flatMap(({ item }, i) => [i, item]);

const stillNested = [1, 2].flatMap((n) => [[n * 10]]);
const sparse = [1, , 3];
const sparseFlat = sparse.flat();
const strings = [['a'], 'bc', ['d']].flat();
const flatOfFlat = [[[1]]].flat().flat();

console.log('flat   :', oneLevel);
console.log('depths :', twoLevels, allLevels, totalOfAll);
console.log('lines  :', lines, '| priced:', priced);
console.log('sparse :', sparse.length, sparseFlat, '| strings:', strings);

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
31const readings = [12, 45, 78, 91, 103];

const last = readings.at(-1);
const penultimate = readings.at(-2);
const firstOne = readings.at(0);
const bracketMinusOne = readings[-1];
const oldWay = readings[readings.length - 1];

const pastTheEnd = readings.at(5);
const wayBefore = readings.at(-9);
const negativeZero = readings.at(-0);
const fractional = readings.at(1.7);
const notANumber = readings.at('2');

const lga = 'Ikeja';
const lastLetter = lga.at(-1);
const charAtPastEnd = lga.charAt(99);
const atPastEnd = lga.at(99);

const flag = '🇳🇬';
const halfAPair = flag.at(-1);
const wholePoint = Array.from(flag).at(-1);
const pieceSizes = [halfAPair.length, wholePoint.length];

const arrayLike = { length: 2, 0: 'Lagos', 1: 'Kano' };
const borrowed = Array.prototype.at.call(arrayLike, -1);

console.log('at     :', last, penultimate, firstOne);
console.log('bracket:', bracketMinusOne, '| the old way:', oldWay);
console.log('edges  :', pastTheEnd, wayBefore, negativeZero, fractional, notANumber);
console.log('string :', lastLetter, JSON.stringify(charAtPastEnd), atPastEnd, '| borrowed:', borrowed);

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
38const sales = [
  { good: 'garri', area: 'Ikeja', kobo: 45000 },
  { good: 'rice', area: 'Yaba', kobo: 450000 },
  { good: 'beans', area: 'Ikeja', kobo: 130000 },
  { good: 'palm oil', area: 'Surulere', kobo: 120000 },
];

const byArea = Object.groupBy(sales, ({ area }) => area);
const areas = Object.keys(byArea);
const ikejaGoods = byArea.Ikeja.map(({ good }) => good);

const byBucket = Object.groupBy(sales, ({ kobo }) => (kobo >= 130000 ? 'wholesale' : 'retail'));
const bucketNames = Object.entries(byBucket).map(([name, rows]) => `${name}:${rows.length}`);

const noPrototype = Object.getPrototypeOf(byArea) === null;
const inheritsNothing = ['toString' in byArea, typeof byArea.hasOwnProperty];

const awkward = Object.groupBy(['a', 'b'], () => 'toString');
const naiveGroupBy = (list, fn) => {
  const out = {};
  for (const item of list) (out[fn(item)] ??= []).push(item);
  return out;
};
let naiveResult;
try {
  naiveResult = naiveGroupBy(['a', 'b'], () => 'toString');
} catch (error) {
  naiveResult = error.constructor.name;
}

const coerced = Object.keys(Object.groupBy([1, 2, 3], (n) => n % 2 === 0));
const missing = Object.keys(Object.groupBy([1], () => undefined));
const keptAsKeys = [...Map.groupBy([1, 2, 3], (n) => n % 2 === 0).keys()];

console.log('by area  :', areas, ikejaGoods);
console.log('buckets  :', bucketNames);
console.log('prototype:', noPrototype, inheritsNothing);
console.log('naive    :', naiveResult, '| built-in:', Object.entries(awkward).map(([k, v]) => [k, v.length]));

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
38const money = (strings, ...values) =>
  strings.reduce((out, part, i) => {
    const value = values[i];
    const shown =
      i >= values.length ? '' : typeof value === 'number' ? `₦${(value / 100).toFixed(2)}` : String(value);
    return out + part + shown;
  }, '');

const buyer = 'Adaeze';
const kobo = 45000;
const qty = 3;
const bags = `${qty} bags`;
const receipt = money`${buyer} takes ${bags} and pays ${kobo * qty}`;
const noHoles = money`nothing to fill`;

const shape = (strings, ...values) => ({
  parts: [...strings],
  values,
  counts: [strings.length, values.length],
  frozen: Object.isFrozen(strings),
});
const inspected = shape`a${1}b${2}c`;
const edges = shape`${'first'}middle${'last'}`;

const rawText = String.raw`line\nbreak`;
const cookedText = `line\nbreak`;
const fifthChar = [rawText.charCodeAt(4), cookedText.charCodeAt(4)];

const peek = (strings) => [strings[0], strings.raw[0]];
const invalid = peek`\unit`;

const pattern = new RegExp(String.raw`\d{4}-\d{2}`);
const matched = pattern.test('2019-05');

console.log('receipt:', receipt);
console.log('shape  :', inspected);
console.log('edges  :', edges.parts, edges.values);
console.log('raw    :', rawText, '| lengths:', rawText.length, cookedText.length);