Saltar al contenido
Clases

Campos públicos y privados

Lección 2 de 510 min4 ejercicios

Hasta 2022, en JavaScript no había forma de esconder de verdad un dato dentro de un objeto: todo lo que estaba en this se podía leer y cambiar desde afuera. Los campos privados, marcados con #, lo resolvieron: ahora una clase puede decidir qué expone y qué protege.

Campos públicos

Un campo declarado en el cuerpo de la clase se crea en cada instancia con su valor inicial, sin necesidad de escribirlo en el constructor:

class Tarea {
  hecha = false;
  etiquetas = [];

  constructor(titulo) {
    this.titulo = titulo;
  }
}

const t = new Tarea("Estudiar clases");
console.log(t);

Cada instancia recibe su propio array etiquetas: el inicializador se evalúa en cada new.

Campos y métodos privados (ES2022)

Con # delante del nombre, el campo es privado: solo el código escrito dentro de la clase puede usarlo.

class Cronometro {
  #inicio = null;
  #vueltas = [];

  iniciar() {
    this.#inicio = 0;
  }

  vuelta(segundos) {
    this.#vueltas.push(segundos);
    return this.#formatear(segundos);
  }

  #formatear(s) {           // método privado
    return `vuelta ${this.#vueltas.length}: ${s} s`;
  }
}

const c = new Cronometro();
c.iniciar();
console.log(c.vuelta(42));
console.log(Object.keys(c));  // los privados no aparecen

Intentar usar c.#vueltas fuera de la clase ni siquiera llega a ejecutarse: es un SyntaxError al analizar el código.

Solo lectura hacia afuera

El patrón más común: el dato es privado y un getter lo expone para leerlo, sin setter. La única forma de cambiarlo es a través de los métodos de la clase, donde pones las validaciones:

class Inventario {
  #stock = 0;

  get stock() {
    return this.#stock;
  }

  agregar(n) {
    if (n <= 0) throw new RangeError("La cantidad debe ser positiva");
    this.#stock += n;
  }
}

const inv = new Inventario();
inv.agregar(5);
console.log(inv.stock);

¿Es de mi clase? #campo in obj

Dentro de la clase, #campo in obj comprueba si un objeto tiene ese campo privado, es decir, si fue creado por esta clase:

class Moneda {
  #codigo;
  constructor(codigo) { this.#codigo = codigo; }

  static esMoneda(x) {
    return #codigo in x;
  }
}

console.log(Moneda.esMoneda(new Moneda("PEN")));
console.log(Moneda.esMoneda({ codigo: "PEN" }));

Campos y bloques static

Los campos static pertenecen a la clase y se comparten. Un bloque static { … } se ejecuta una sola vez, al definir la clase, para inicializaciones más complejas:

class Config {
  static entorno = "producción";
  static #claves = new Map();

  static {
    Config.#claves.set("api", "https://api.ejemplo.com");
    Config.#claves.set("cdn", "https://cdn.ejemplo.com");
  }

  static url(nombre) {
    return Config.#claves.get(nombre);
  }
}

console.log(Config.entorno, Config.url("api"));

Resumen

  • Los campos declarados en la clase se crean en cada instancia.
  • #nombre es privado: solo existe dentro de la clase; usarlo afuera es un SyntaxError.
  • También hay métodos privados: #ayudante() {…}.
  • Privado + getter = dato de solo lectura hacia afuera.
  • #campo in obj comprueba si un objeto es de tu clase.
  • static para lo que es de la clase; static { } para inicializarla.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Lo que se ve y lo que no

Elige una respuesta en cada pregunta.

  1. ¿Qué hace el # en #saldo = 0?

  2. ¿Qué pasa si escribes cuenta.#saldo fuera de la clase?

  3. ¿Para qué sirve #campo in obj?

  4. ¿Qué es un bloque static { … }?

Ordena la salida: Privados y estáticos

Un campo privado por instancia y uno estático compartido. Ordena lo que aparecería en la consola.

class Contador {  static creados = 0;  #cuenta = 0;   constructor() {    Contador.creados++;  }  sumar() {    return ++this.#cuenta;  }  static esContador(obj) {    return #cuenta in obj;  }} const a = new Contador();a.sumar();a.sumar();new Contador(); console.log(a.sumar());console.log(Contador.creados);console.log(Contador.esContador(a), Contador.esContador({}));console.log(Object.keys(a).length);

Consola, de arriba abajo

  1. 0
  2. 2
  3. 3
  4. true false

Detective: Espiar un campo privado

Alguien quiere ver cuánto queda en la billetera. Encuentra la línea que falla y elige la forma correcta de leer el saldo.

Consola

billetera.js:10
console.log(mia.#saldo);
               ^

SyntaxError: Private field '#saldo' must be declared in an enclosing class

Paso 1: toca la línea de código que causa el error.

Laboratorio: Un saldo que nadie puede tocar

Haz que el saldo sea privado y de solo lectura: que se pueda consultar, pero cambiar solo con depositar.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime 50: la asignación de afuera no tiene efecto (pendiente)
  • El saldo es un campo privado #saldo (pendiente)
  • Se puede leer y depositar: tras depositar(10), saldo sube 10 (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.