Getters and Setters

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

  // Note: no brackets at the call site.
  get size() {
    if (this.seats > 30) return 'full coach';
    if (this.seats > 14) return 'coaster';
    return 'minibus';
  }

  get label() {
    return `${this.plate} (${this.size})`;
  }
}

const b = new Bus('LAG-441-XA', 14);
console.log(b.size);
console.log(b.label);

b.seats = 33;
console.log('after a refit:', b.label);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19class Cart {
  constructor() {
    this.items = [];
    this.total = 0;
  }
  add(price) {
    this.items.push(price);
    this.total += price;
  }
}

const cart = new Cart();
cart.add(12);
cart.add(8);
console.log('total:', cart.total);

// Someone edits the array directly, and the total is now a lie.
cart.items.push(100);
console.log('items:', cart.items, '| total says:', cart.total);

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 Cart {
  #items = [];

  add(price) {
    this.#items.push(price);
    return this;
  }

  get items() {
    return [...this.#items];      // a copy, so callers cannot edit the real one
  }

  get total() {
    return this.#items.reduce((sum, p) => sum + p, 0);
  }

  get count() {
    return this.#items.length;
  }
}

const cart = new Cart();
cart.add(12).add(8);
console.log('total:', cart.total, '| count:', cart.count);

// The same attempt now changes nothing, because items hands back a copy.
cart.items.push(100);
console.log('items:', cart.items, '| total:', cart.total);

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

  constructor(plate) { this.plate = plate; }

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

  set seats(value) {
    const n = Number(value);
    if (!Number.isInteger(n)) throw new TypeError('seats must be a whole number.');
    if (n < 1 || n > 59) throw new RangeError(`seats must be 1 to 59, got ${n}.`);
    this.#seats = n;
  }
}

const b = new Bus('LAG-441-XA');
b.seats = 33;
console.log(b.seats);

b.seats = '44';                   // normalised on the way in
console.log(b.seats, typeof b.seats);

try { b.seats = 0; } catch (err) { console.log('refused:', err.message); }
try { b.seats = 2.5; } catch (err) { console.log('refused:', err.message); }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23class Broken {
  set label(value) {
    // This assignment calls the setter again. And again.
    this.label = value.trim();
  }
  get label() { return this._nothing; }
}

try {
  new Broken().label = '  x  ';
} catch (err) {
  console.log(err.name + ':', err.message);
}

// The fix is to store somewhere else: a private field, or a differently named one.
class Fixed {
  #label = '';
  set label(value) { this.#label = String(value).trim(); }
  get label() { return this.#label; }
}
const f = new Fixed();
f.label = '   Lagos - Abuja   ';
console.log('fixed:', JSON.stringify(f.label));

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
27class ReadOnly {
  #value = 42;
  get value() { return this.#value; }
}

const r = new ReadOnly();

// In strict mode, which is every module and every class body, this throws.
// In an old sloppy-mode script it was ignored in silence, and the caller
// walked away believing the assignment had worked.
try {
  r.value = 99;
} catch (err) {
  console.log(err.name + ':', err.message);
}
console.log('value is still', r.value);

// Either way the message is about mechanics, not intent. Say what you mean.
class Loud {
  #value = 42;
  get value() { return this.#value; }
  set value(_) {
    throw new TypeError('value is derived and cannot be assigned. Use recalculate().');
  }
}

try { new Loud().value = 99; } catch (err) { console.log('refused:', err.message); }

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
33class Slow {
  #rows = Array.from({ length: 200 }, (_, i) => i);

  get worst() {
    // Pretend this is a real calculation.
    return this.#rows.reduce((a, b) => a + b, 0);
  }
}

const s = new Slow();
let touched = 0;
for (let i = 0; i < 5; i++) {
  touched += s.worst;             // recomputed every single time
}
console.log('sum of five reads:', touched);

// Cache it when the cost is real and the inputs do not change.
class Cached {
  #rows = Array.from({ length: 200 }, (_, i) => i);
  #sum = null;

  get worst() {
    if (this.#sum === null) this.#sum = this.#rows.reduce((a, b) => a + b, 0);
    return this.#sum;
  }

  add(n) { this.#rows.push(n); this.#sum = null; return this; }
}

const c = new Cached();
console.log('cached read:', c.worst, c.worst, c.worst);
c.add(1000);
console.log('after add, recomputed:', c.worst);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20const hold = {
  widthM: 2,
  depthM: 5,

  get areaM2() { return this.widthM * this.depthM; },
  set areaM2(_) { throw new TypeError('Set widthM and depthM instead.'); },
};

console.log('luggage floor area:', hold.areaM2);
hold.widthM = 3;
console.log('after widening:', hold.areaM2);

// And the fully explicit form, which is what a getter compiles down to.
const seat = {};
Object.defineProperty(seat, 'label', {
  get() { return 'D12'; },
  enumerable: true,
});
console.log(seat.label);
console.log('descriptor:', Object.getOwnPropertyDescriptor(seat, 'label'));

1
2
3
4
5
6
7
8
9
10
11
12
13
14class Ticket {
  #serial = 'A-1';
  constructor(row, seat) { this.row = row; this.seat = seat; }

  get label() { return `${this.row}${this.seat}`; }

  toJSON() {
    return { serial: this.#serial, label: this.label };
  }
}

const t = new Ticket('D', 12);
console.log('without toJSON the label would vanish. With it:');
console.log(JSON.stringify(t));