Hoe kunnen we tijdens de uitvoering van het programma…

De klassen in JavaScript, die syntactische suiker vormen over prototypische overerving, kunnen niet "gemaakt" worden in de gebruikelijke zin tijdens runtime. Echter, we kunnen dynamisch constructorfuncties (die vóór de introductie van classes hun equivalent waren) of instanties van classes met bepaalde eigenschappen en methoden creëren.

Methoden voor dynamisch creëren:

Met behulp van de Function constructor:

// Dynamisch een constructorfunctie maken
const DynamicClassConstructor = new Function('name', `
  this.name = name;
  this.sayHello = function() {
    console.log('Hallo, ik heet ' + this.name);
  };
`);

// Een instantie van de class maken met de dynamische constructor
const dynamicInstance = new DynamicClassConstructor('Alice');
dynamicInstance.sayHello(); // Hallo, ik heet Alice

Deze methode is het minst gebruikelijk, omdat het onveilig is (voert de string uit als code) en moeilijk te debuggen.

Met behulp van fabrieksfuncties:

// Fabriekfunctie die een object teruggeeft met bepaalde eigenschappen en methoden
function createDynamicObject(type) {
  const baseObject = {
    id: Math.random() // Voorbeeld van dynamische eigenschap
  };

  if (type === 'gebruiker') {
    return {
      ...baseObject,
      role: 'gebruiker',
      greet: function() {
        console.log('Ik ben een gebruiker!');
      }
    };
  } else if (type === 'beheerder') {
    return {
      ...baseObject,
      role: 'beheerder',
      greet: function() {
        console.log('Ik ben een beheerder!');
      }
    };
  }
  return baseObject;
}

const user = createDynamicObject('gebruiker');
user.greet(); // Ik ben een gebruiker!

const admin = createDynamicObject('beheerder');
admin.greet(); // Ik ben een beheerder!

Fabriekfuncties zijn flexibeler en veiliger, en maken het mogelijk om objecten met verschillende configuraties te creëren op runtime.

Met behulp van eval (niet aanbevolen):

// Gebruik van eval om een class te maken (zeer gevaarlijk en niet aanbevolen)
const className = 'MyDynamicClass';
const classDefinition = `
  class ${className} {
    constructor(value) {
      this.value = value;
    }
    printValue() {
      console.log(this.value);
    }
  }
`;

eval(classDefinition);

const dynamicInstanceEval = new MyDynamicClass('dynamische waarde');
dynamicInstanceEval.printValue(); // dynamische waarde

Het gebruik van eval wordt sterk afgeraden vanwege veiligheidsproblemen, prestatieproblemen en debuggingmoeilijkheden.

Belangrijke punten:

De term "dynamisch creëren van klassen" in JavaScript verwijst meestal naar het maken van objecten met een bepaalde structuur en gedrag tijdens runtime, niet naar het maken van de class-constructors zelf.
Voor de meeste scenario's zijn fabrieksfuncties of eenvoudige objectcreatie met de benodigde eigenschappen meer de voorkeur en veiliger.
Bij het werken met frameworks en bibliotheken kunnen zij eigen mechanismen bieden voor het werken met dynamische creatie van componenten of objecten, gebaseerd op deze principes.

Hoe kunnen we tijdens de uitvoering van het programma dynamisch klassen maken?