Mit lehet helyettesíteni az interfészeket…

A JavaScript-ben a felületek natív módon nem támogatottak, helyettesíthetők a következőkkel:

Futásidő típusellenőrzés (Runtime type checking): Könyvtárak, mint a Zod, Yup vagy Joi használata az adatszerkezet leírására és az bemeneti értékek validálására.

// Zod példával
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('A felhasználói adatok érvényesek:', validUserData);
} catch (error) {
  console.error('Érvényesítési hiba:', error.errors);
}

JSDoc: Típus annotációkkal ellátott megjegyzések a dokumentációhoz és az IDE-k, valamint a statikus elemzők számára.

/**
 * @typedef {Object} Product
 * @property {number} id - A termék egyedi azonosítója.
 * @property {string} name - A termék neve.
 * @property {number} price - A termék ára.
 */

/**
 * A termék adatait jeleníti meg.
 * @param {Product} product - A termék objektum.
 */
function displayProduct(product) {
  console.log(`Termék: ${product.name}, Ár: ${product.price}`);
}

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

Névkonvenciók és dokumentáció: Világos megállapodások arról, hogyan kell az objektumok tulajdonságait és metódusait nevezni, ahogy az a dokumentációban szerepel.

TypeScript: A leghatékonyabb módszer, amely lehetővé teszi a teljes interfészek és a statikus típusellenőrzés használatát fejlesztés közben.

interface IProduct {
  id: number;
  name: string;
  price: number;
  displayInfo(): void; // Metódus definíció
}

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(`Termék: ${this.name}, Ár: ${this.price}`);
  }
}

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

Absztrakt osztályok (egy bizonyos fokig): Bár a JavaScript nem rendelkezik valódi absztrakt osztályokkal, azok szimulálhatók hibák generálásával az absztrakt osztály példányosításakor vagy "absztrakt" metódusok hívásával.

class AbstractShape {
  constructor() {
    if (new.target === AbstractShape) {
      throw new Error("Nem hozhat létre példányt az AbstractShape absztrakt osztályból");
    }
  }

  area() {
    throw new Error("Az area metódust az alosztálynak kell megvalósítania");
  }
}

class Circle extends AbstractShape {
  radius: number;

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

  area(): number { // Az absztrakt metódus megvalósítása
    return Math.PI * this.radius * this.radius;
  }
}

// const shape = new AbstractShape(); // Hibát okoz
const circle = new Circle(5);
console.log("Kör területe:", circle.area());

Fontos megérteni, hogy ezek a módszerek különböző szinteken biztosítanak szigorúságot és ellenőrzést. A TypeScript a legteljesebb statikus ellenőrzést nyújtja fordítási időben, míg a többi módszer inkább futásidőben történő ellenőrzésre vagy dokumentációra irányul.

Mit lehet helyettesíteni az interfészeket JavaScript-ben?