Czym można zastąpić interfejsy w JavaScript?

Interfejsy w JavaScript nie są obsługiwane natywnie, ale można je zastąpić:

• Sprawdzaniem typów w czasie wykonywania (Runtime type checking): Użycie bibliotek takich jak Zod, Yup lub Joi do opisu struktury danych i walidacji wartości wejściowych.

  // Przykład z 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('Poprawne dane użytkownika:', validUserData);
  } catch (error) {
    console.error('Błąd walidacji:', error.errors);
  }
  

• JSDoc: Komentarze z adnotacjami typów do dokumentacji i dostarczania informacji dla IDE i analizatorów statycznych.

  /**
   * @typedef {Object} Product
   * @property {number} id - Unikalny identyfikator produktu.
   * @property {string} name - Nazwa produktu.
   * @property {number} price - Cena produktu.
   */
  
  /**
   * Wyświetla informacje o produkcie.
   * @param {Product} product - Obiekt produktu.
   */
  function displayProduct(product) {
    console.log(`Produkt: ${product.name}, Cena: ${product.price}`);
  }
  
  const myProduct = { id: 101, name: 'Książka', price: 500 };
  displayProduct(myProduct);
  

• Ustalenia dotyczące nazewnictwa i dokumentacji: Jasne ustalenia dotyczące tego, jak powinny być nazywane właściwości i metody obiektów opisanych w dokumentacji kodu.

• TypeScript: Najskuteczniejsza metoda, pozwalająca na korzystanie z pełnych interfejsów i statycznego typowania podczas rozwoju.

  interface IProduct {
    id: number;
    name: string;
    price: number;
    displayInfo(): void; // Definicja metody
  }
  
  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(`Produkt: ${this.name}, Cena: ${this.price}`);
    }
  }
  
  const myBook: IProduct = new Book(102, 'Romans', 700);
  myBook.displayInfo();
  

• Klasy abstrakcyjne (w pewnym stopniu): Chociaż JavaScript nie posiada prawdziwych klas abstrakcyjnych, można je emulować, generując błędy przy próbie tworzenia instancji klasy abstrakcyjnej lub wywoływania "abstrakcyjnych" metod.

  class AbstractShape {
    constructor() {
      if (new.target === AbstractShape) {
        throw new Error("Nie można utworzyć instancji klasy abstrakcyjnej AbstractShape");
      }
    }
  
    area() {
      throw new Error("Metoda area musi być zaimplementowana w podklasie");
    }
  }
  
  class Circle extends AbstractShape {
    radius: number;
  
    constructor(radius: number) {
      super();
      this.radius = radius;
    }
  
    area(): number { // Implementacja metody abstrakcyjnej
      return Math.PI * this.radius * this.radius;
    }
  }
  
  // const shape = new AbstractShape(); // Wygeneruje błąd
  const circle = new Circle(5);
  console.log("Pole koła:", circle.area());
  

Ważne jest, aby zrozumieć, że te metody oferują różne poziomy rygoru i sprawdzania. TypeScript zapewnia najsilniejszą statyczną kontrolę podczas kompilacji, podczas gdy pozostałe metody są bardziej ukierunkowane na sprawdzanie w czasie wykonywania lub dokumentację.