Klassen

Question 1

Wat is een klasse?

Answer 1

Een klasse is een container die de eigenschappen en methoden van objecten beschrijft van een bepaald type. Uit een klasse worden objecten gecreëerd. We zeggen dat een object een instantie is van een bepaalde klasse.

Question 2

Implementeer een klasse Circle die de eigenschap radius bezit en de methode draw bezit. De methode print enkel het woord ‘draw’ in de conole.

Answer 2

class Circle {
constructor(radius) {
this.radius = radius;
}

draw() {
console.log(‘draw’);
}
}

const c = new Circle(5);

Question 3

Worden klassen gehoist?

Answer 3

Klassen worden niet gehoist. Het is dus niet mogelijk om ze te gebruiken voor hun definitie.

Question 4

Klassen kunnen twee soorten methoden hebben: static methods en instance methods.

1. Wat is het verschil tussen beiden?
2. Wat is de use case van statische methoden?
3. Hoe kan je een statische methode of eigenschap implementeren?

Answer 4

1. Instantie methoden zijn methoden die beschikbaar zijn op een instantie van een klasse.

Statische methoden zijn niet beschikbaar op een instantie van een klasse maar zijn beschikbaar op de klasse zelf. Dit wilt ook zeggen dat, wanneer je de inhoud van een object in de console bekijkt, dat je geen statische methoden zal waarnemen.

2. We gebruiken ze vaak als helperfuncties (utlity functions) bijvoorbeeld wanneer je twee objecten van dezelfde klasse met elkaar wilt vergelijken of wanneer je bijvoorbeeld wilt bijhouden hoeveel instanties er van die klasse bestaan.
3. Je kan een statische methode of klasse implementeren door gebruik te maken van de static keyword, bijvoorbeeld:

class Circle {
static totalCircles = 0;

constructor(radius) {
Circle.totalCircles++;
this.radius = radius;
}

static someMethod() {
//do some
}
}

Question 5

Op welke twee manieren kan je private leden definiëren? Implementeer voor elk van beiden een voorbeeld.

Answer 5

Er zijn twee manieren om private leden te definiëren:
1. Door gebruik te maken van Symbols
2. Door gebruik te maken van WeakMaps

Voorbeeld 1: private members met symbols:

const _radius = Symbol();
const _draw = Symbol();

class Circle {
constructor(radius) {
this[_radius] = radius;
}

_draw {
console.log(“I’m a circle”);
}
}

Voorbeeld 2: Private members met weakMaps:

const _radius = new WeakMap();
const _move = new WeakMap();

class Circle {
constructor(radius) {
_radius.set(this, radius);

  _move.set(this, function () {
     console.log('move: ', this);
  });    }

draw() {
console.log(‘radius: ‘ + _radius.get(this));
_move.get(this).call(this);
}
}

OF:

const _privateMembers = new WeakMap();

class Circle {
constructor(radius) {
_privateMembers.set(this, {
radius,
move: function () {
console.log(‘move: ‘, this);
},
});
}

draw() {
console.log(‘radius: ‘ + _privateMembers.get(this).radius);
_privateMembers.get(this).move.call(this);
}
}

Question 6

Wat is het nadeel van het definiëren van private members als Symbols?

Answer 6

Het nadeel is dat er wel een manier bestaat om toch toegang te krijgen tot de private data. DIt kan dan als volgt:

// c is een object dat private members bevat
const symbols = Object.getOwnPropertySymbols(c);
const firstPrivateMember = symbols[0];
console.log(c[firstPrivateMember]);

Question 7

Wat kan je zeggen over klassen en strict mode?

Answer 7

De body van klassen wordt automatisch uitgevoerd in strict mode.

Question 8

Hoe definieer je getters en setters in klassen?

Answer 8

Door gewoonweg de set en get keywords voor de methode te plaatsen.

Question 9

Hoe kan je ervoor zorgen dat een klasse B de leden van klasse A overerft?

Answer 9

Doorgebruik te maken van het extends keyword:

class B extends A {
//…
}

Question 10

Stel dat klasse B overerft van klasse A:

1. Geef aan hoe we de constructor van A oproepen in B
2. Geef aan hoe we een methode dat gedefinieerd is in A oproepen in B

Answer 10

1. In het eerste geval gebruiken we de super methode. Bijvoorbeeld:

class Shape {
constructor(color) {
this.color = color;
}
}

class Circle extends Shape {
constructor(radius, color) {
super(color);
this.radius = radius;
}
}

Het is belangrijk dat de super call gebeurt alvorens de andere eigenschappen in de constructor worden geïnitialiseerd.

2. In het tweede geval gebruiken we het super object. Bijvoorbeeld:

class Shape {
move() {
console.log(“move”);
}
}

class Circle extends Shape {
move() {
// move methode van superklasse wordt opgeroepen
super.move();
console.log(“circle move”);
}
}