Con cosa si possono sostituire le interfacce in…

Le interfacce in JavaScript non sono supportate nativamente, ma possono essere sostituite da:

Controllo dei tipi a runtime (Runtime type checking): Uso di librerie come Zod, Yup o Joi per descrivere la struttura dei dati e convalidare i valori in ingresso.

// Esempio con 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('Dati utente validi:', validUserData);
} catch (error) {
  console.error('Errore di validazione:', error.errors);
}

JSDoc: Commenti con annotazioni di tipi per documentare e fornire informazioni per IDE e analizzatori statici.

/**
 * @typedef {Object} Product
 * @property {number} id - Identificativo unico del prodotto.
 * @property {string} name - Nome del prodotto.
 * @property {number} price - Prezzo del prodotto.
 */

/**
 * Mostra informazioni sul prodotto.
 * @param {Product} product - Oggetto del prodotto.
 */
function displayProduct(product) {
  console.log(`Prodotto: ${product.name}, Prezzo: ${product.price}`);
}

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

Convenzioni di denominazione e documentazione: Accordi chiari su come devono essere chiamate le proprietà e i metodi degli oggetti descritti nella documentazione del codice.

TypeScript: Il metodo più efficace, che permette di usare interfacce complete e tipizzazione statica durante lo sviluppo.

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

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

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

Classi astratte (in certa misura): Sebbene JavaScript non abbia vere classi astratte, è possibile emularle generando errori nel tentativo di creare un'istanza di una classe astratta o chiamando metodi "astratti".

class AbstractShape {
  constructor() {
    if (new.target === AbstractShape) {
      throw new Error("Impossibile creare un'istanza della classe astratta AbstractShape");
    }
  }

  area() {
    throw new Error("Il metodo area deve essere implementato nella sottoclasse");
  }
}

class Circle extends AbstractShape {
  radius: number;

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

  area(): number { // Implementazione del metodo astratto
    return Math.PI * this.radius * this.radius;
  }
}

// const shape = new AbstractShape(); // Genererà errore
const circle = new Circle(5);
console.log("Area del cerchio:", circle.area());

È importante capire che questi metodi offrono diversi livelli di rigore e verifica. TypeScript fornisce il controllo statico più forte durante la compilazione, mentre gli altri metodi sono più orientati al controllo in runtime o alla documentazione.

Con cosa si possono sostituire le interfacce in JavaScript?