Cu ce pot fi înlocuite interfețele în JavaScript…

Interfețele în JavaScript nu sunt suportate în mod nativ, dar pot fi înlocuite cu:

Verificarea tipurilor în timpul execuției (Runtime type checking): Utilizarea bibliotecilor precum Zod, Yup sau Joi pentru a descrie structura datelor și a valida valorile de intrare.

// Exemplu cu 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('Datele utilizatorului valide:', validUserData);
} catch (error) {
  console.error('Eroare de validare:', error.errors);
}

JSDoc: Comentarii cu adnotări de tipuri pentru documentare și furnizarea de informații pentru IDE-uri și analizatori statici.

/**
 * @typedef {Object} Product
 * @property {number} id - Identificatorul unic al produsului.
 * @property {string} name - Numele produsului.
 * @property {number} price - Prețul produsului.
 */

/**
 * Afișează informații despre produs.
 * @param {Product} product - Obiectul produsului.
 */
function displayProduct(product) {
  console.log(`Produs: ${product.name}, Preț: ${product.price}`);
}

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

Acorduri de denumire și documentare: Acorduri clare despre modul în care trebuie să fie denumite proprietățile și metodele obiectelor descrise în documentația codului.

TypeScript: Cel mai eficient metodă, care permite utilizarea interfețelor complete și a tipizării statice în timpul dezvoltării.

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

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(`Produs: ${this.name}, Preț: ${this.price}`);
  }
}

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

Clase abstracte (în anumite măsuri): Deși JavaScript nu are clase abstracte reale, acestea pot fi emulate prin generarea de erori la încercarea de a crea o instanță a unei clase abstracte sau de a apela metode "abstracte".

class AbstractShape {
  constructor() {
    if (new.target === AbstractShape) {
      throw new Error("Nu se poate crea o instanță a clasei abstracte AbstractShape");
    }
  }

  area() {
    throw new Error("Metoda area trebuie implementată în subclasă");
  }
}

class Circle extends AbstractShape {
  radius: number;

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

  area(): number { // Implementarea metodei abstracte
    return Math.PI * this.radius * this.radius;
  }
}

// const shape = new AbstractShape(); // Va genera eroare
const circle = new Circle(5);
console.log("Aria cercului:", circle.area());

Este important să înțelegem că aceste metode oferă diferite niveluri de rigurozitate și verificare. TypeScript oferă cea mai puternică verificare statică în timpul compilării, în timp ce celelalte metode sunt mai orientate spre verificarea în timpul execuției sau documentație.

Cu ce pot fi înlocuite interfețele în JavaScript?