Waarmee kunnen interfaces in JavaScript worden…

Interfaces in JavaScript worden niet native ondersteund, maar kunnen worden vervangen door:

Runtime type checking: Gebruik van bibliotheken zoals Zod, Yup of Joi om de datastructuur te beschrijven en inkomende waarden te valideren.

// Voorbeeld met Zod
import { z } from 'zod';

const UserSchema = z.object({
  id: z.number(),
  name: z.string(),
  email: z.string().email(),
});

try {
  const validUserData = UserSchema.parse({ id: 1, name: 'Alice', email: 'alice@example.com' });
  console.log('Geldige gebruikersgegevens:', validUserData);
} catch (error) {
  console.error('Validatiefout:', error.errors);
}

JSDoc: Commentaren met type-aanduidingen voor documentatie en informatievoorziening voor IDE's en statische analyzers.

/**
 * @typedef {Object} Product
 * @property {number} id - Unieke identificatie van het product.
 * @property {string} name - Naam van het product.
 * @property {number} price - Prijs van het product.
 */

/**
 * Toont informatie over het product.
 * @param {Product} product - Productobject.
 */
function displayProduct(product) {
  console.log(`Product: ${product.name}, Prijs: ${product.price}`);
}

const myProduct = { id: 101, name: 'Boek', price: 500 };
displayProduct(myProduct);

Naamgevingsconventies en documentatie: Duidelijke afspraken over hoe de eigenschappen en methoden van objecten moeten worden genoemd zoals beschreven in de documentatie van de code.

TypeScript: De meest effectieve methode, die het gebruik van volledige interfaces en statische typecontrole tijdens de ontwikkeling mogelijk maakt.

interface IProduct {
  id: number;
  name: string;
  price: number;
  displayInfo(): void; // Methodedefinitie
}

class Book implements IProduct {
  id: number;
  name: string;
  price: number;

  constructor(id: number, name: string, price: number) {
    this.id = id;
    this.name = name;
    this.price = price;
  }

  displayInfo(): void {
    console.log(`Product: ${this.name}, Prijs: ${this.price}`);
  }
}

const myBook: IProduct = new Book(102, 'Roman', 700);
myBook.displayInfo();

Abstracte klassen (in zekere mate): Hoewel JavaScript geen echte abstracte klassen heeft, kunnen ze worden nagebootst door fouten te genereren bij het proberen een instantie van een abstracte klasse te maken of 'abstracte' methoden aan te roepen.

class AbstractShape {
  constructor() {
    if (new.target === AbstractShape) {
      throw new Error("Kan geen instantie van de abstracte klasse AbstractShape maken");
    }
  }

  area() {
    throw new Error("De methode area moet worden geïmplementeerd in de subklasse");
  }
}

class Circle extends AbstractShape {
  radius: number;

  constructor(radius: number) {
    super();
    this.radius = radius;
  }

  area(): number { // Implementatie van de abstracte methode
    return Math.PI * this.radius * this.radius;
  }
}

// const shape = new AbstractShape(); // Geeft fout
const circle = new Circle(5);
console.log("Oppervlakte van de cirkel:", circle.area());

Het is belangrijk te begrijpen dat deze methoden verschillende niveaus van strengheid en controle bieden. TypeScript biedt de sterkste statische controle tijdens compilatie, terwijl de andere methoden meer gericht zijn op runtime controle of documentatie.

Waarmee kunnen interfaces in JavaScript worden vervangen?