Quali pattern di progettazione sono comuni in JavaScript e TypeScript che non si trovano in Java?

• Singleton (in JS/TS più facilmente implementato tramite moduli e closure).
• Module (pattern implicito del linguaggio).
• Prototype (tramite ereditarietà prototipica).
• Mixin (tramite Object.assign, classi o funzioni factory).
• Pattern del modulo rivelato (usando closure).
• Funzione factory (alternativa ai costruttori di classi).
• Dependency Injection (più spesso tramite factory o container, non così dipendente dalle annotazioni come in Java).

Esempi di differenze:

• Singleton:

// singleton.js
const instance = {
  data: 'some data'
};

export default instance; // Esportazione semplice di un’unica istanza

In Java, serve un metodo statico getInstance() e un costruttore privato.

• Module:

// module.js
const privateVar = 'private';

export function publicMethod() {
  console.log(privateVar);
}

In Java, è richiesta una dichiarazione esplicita di classi e modificatori di accesso.

• Prototype:

const animal = {
  speak() {
    console.log('...');
  }
};

const dog = Object.create(animal);
dog.speak = function() {
  console.log('woof');
};

dog.speak(); // woof

In Java, l’ereditarietà si basa su classi.

• Mixin:

const searchable = {
  search() {
    console.log('Searching...');
  }
};

class Article {
  constructor(title) {
    this.title = title;
  }
}

Object.assign(Article.prototype, searchable);

const myArticle = new Article('Hello');
myArticle.search(); // Searching...

In Java, non esiste supporto nativo per i mixin (si usano interfacce o composizione).