Miembros estáticos y métodos privados

Miembros estáticos: pertenecen a la CLASE, no a la instancia

Con static defines propiedades y métodos que viven en la clase misma, no en cada objeto creado. Se acceden por el nombre de la clase, sin new.

Analogía: la instancia es cada coche fabricado; lo estático es información de la fábrica (cuántos coches lleva fabricados, la constante de conversión que usan todos, etc.).

class Circulo {
  static PI = 3.14159;           // propiedad estática (constante compartida)
  constructor(radio) {
    this.radio = radio;
  }
  area() {
    return Circulo.PI * this.radio * this.radio;
  }
}
console.log(Circulo.PI);          // 3.14159  (por la clase, no por instancia)

Usos típicos

Métodos "factory" que crean instancias de forma más expresiva que new:

class Usuario {
  constructor(nombre) {
    this.nombre = nombre;
  }
  static crear(nombre) {          // método estático factory
    return new Usuario(nombre);
  }
}
const u = Usuario.crear("Ana");   // se lee mejor que new Usuario("Ana")

Contadores de instancias (un dato que es de toda la clase, no de un objeto):

class Conexion {
  static abiertas = 0;
  constructor() {
    Conexion.abiertas++;          // se incrementa en cada new
  }
}
new Conexion();
new Conexion();
console.log(Conexion.abiertas);   // 2

Utilidades que no necesitan una instancia (como hace Math.max o Array.from): agrupas funciones relacionadas dentro de una clase.

Métodos y campos privados

Ya viste los campos privados #campo. También puedes tener métodos privados #metodo(): helpers internos que la clase usa pero que el exterior no debe llamar. Son invisibles desde fuera.

class Password {
  #valor;
  constructor(texto) {
    this.#valor = texto;
  }
  // método privado: solo se llama desde dentro de la clase
  #esLargo() {
    return this.#valor.length >= 8;
  }
  esSegura() {
    return this.#esLargo();       // el método público delega en el privado
  }
}
const p = new Password("supersecreto");
console.log(p.esSegura());        // true
// p.#esLargo()  ->  SyntaxError: el método privado no existe fuera

Esto te permite exponer una interfaz pública pequeña y clara, escondiendo los detalles internos. Mañana puedes reescribir #esLargo sin que nadie de fuera se entere, porque nadie podía depender de él.

Ejemplos

Propiedad estática compartida por todas las instancias

class Producto {
  static iva = 0.21;
  constructor(precio) {
    this.precio = precio;
  }
  precioFinal() {
    return this.precio * (1 + Producto.iva);
  }
}
console.log("IVA:", Producto.iva);
console.log("Final:", new Producto(100).precioFinal());

Contador de instancias con un campo estático

class Sesion {
  static total = 0;
  constructor(usuario) {
    this.usuario = usuario;
    Sesion.total++;
  }
}
new Sesion("ana");
new Sesion("luis");
console.log("Sesiones creadas:", Sesion.total);

Método privado como helper interno

class Carrito {
  #items = [];
  agregar(precio) {
    this.#items.push(precio);
  }
  #suma() {
    return this.#items.reduce((a, b) => a + b, 0);
  }
  total() {
    return "Total: " + this.#suma();
  }
}
const c = new Carrito();
c.agregar(10);
c.agregar(25);
console.log(c.total());