Tengo una clase Point que representa las coordenadas x e y . Un enfoque es hacer que las propiedades de esa clase sean inmutables y crear constantemente nuevos objetos cuando sea necesario, así:

 class Point { readonly x: number; readonly y: number; constructor(x: number, y: number) { this.x = x; this.y = y; } add(x: number, y: number) { return new Point(this.x + x, this.y + y); } } document.addEventListener("mousemove", (e) => { let p = new Point(e.clientX, e.clientY); let p2 = p.add(24, 42); // ... });

Otro enfoque es crear objetos de antemano y reutilizarlos, por ejemplo:

 class Point { x: number; y: number; constructor(x?: number, y?: number) { this.set(x, y); } set(x: number, y: number) { this.x = x; this.y = y; } add(x: number, y: number) { this.set(this.x + x, this.y + y); } copy(p: Point) { this.set(px, py) return this; } } let p = new Point(); let p2 = new Point(); document.addEventListener("mousemove", (e) => { p.set(e.clientX, e.clientY); p2.copy(p).add(24, 42) // ... });

Mi teoría es que, dado que JavaScript se recolecta como basura, seguir el primer patrón y arrojar objetos no debería ser un problema, siempre que no deje referencias a ellos. Sin embargo, observé cómo la popular biblioteca Three.js implementa su objeto Vector2 , que hace básicamente lo mismo que mostré anteriormente, y sigue el segundo patrón.

El primer enfoque parece más mantenible y fácil de usar, pero el segundo es quizás más eficiente en memoria.

Cuando se habla de patrones de diseño en general, se trata en gran medida de preferencias y opiniones. Mi pregunta es, en el contexto de JavaScript , ¿hay una razón concreta para elegir uno u otro, o las diferencias de rendimiento son insignificantes?