Campos privados y setters con validación en JavaScript

Contenido del curso

Clases Grabadas

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0012:25

Campos privados y setters con validación en JavaScript

Curso de JavaScript Orientado a Objetos

Clase 7 de 15

Clase 7 / 15

Recursos

La encapsulación es clave para crear software confiable: oculta el estado interno, expone solo lo necesario y protege las invariantes del dominio. Aquí verás cómo convertir una clase en un bloque seguro con campos privados, getters y setters con validación, y manejo de errores con try y catch para no romper el flujo.

¿Cómo aplicar la encapsulación con campos privados y getters?

Usar campos privados con el símbolo numeral garantiza que el estado no se modifique desde fuera de la clase. El acceso externo directo provoca un syntax error, así que todo se controla desde métodos internos con this.

Define campos privados con el símbolo numeral antes del constructor.
Limita el acceso externo: solo desde métodos internos con this.
Expón datos con getters como propiedades de solo lectura.

class Habit {
  // Campos privados
  #name;
  #frequency;
  #id;

  constructor({ name, frequency, id }) {
    // Usa setters para respetar validaciones e invariantes.
    this.name = name;
    this.frequency = frequency;
    this.#id = id; // sin setter: se asigna internamente.
  }

  // Getters: exponen lectura controlada
  get name() { return this.#name; }
  get frequency() { return this.#frequency; }
  get id() { return this.#id; }
}

¿Qué implicaciones tiene el acceso interno y externo?

Acceso interno: solo dentro de la clase con this y el nombre privado.
Acceso externo: bloqueado, se evita modificar el estado sin control.
Beneficio directo: se protege la coherencia del objeto.

¿Por qué los setters con validación protegen las invariantes del dominio?

Las invariantes del dominio son reglas que jamás deben romperse. Con setters validas y normalizas la entrada antes de guardar, evitando estados inválidos y manipulaciones malintencionadas desde el DOM del navegador.

Normaliza entradas: elimina espacios con trim.
Valida longitudes mínimas y formatos.
Restringe valores permitidos con listas de opciones.

class Habit {
  #name; #frequency; #id;
  constructor({ name, frequency, id }) {
    this.name = name;           // valida y normaliza
    this.frequency = frequency; // restringe a opciones válidas
    this.#id = id;
  }

  get name() { return this.#name; }
  get frequency() { return this.#frequency; }
  get id() { return this.#id; }

  // Setter con normalización y longitud mínima
  set name(value) {
    const normalized = value.trim();
    if (normalized.length < 3) {
      throw new Error('el nombre del hábito debe de tener al menos tres caracteres');
    }
    this.#name = normalized;
  }

  // Setter con opciones acotadas
  set frequency(value) {
    const validFrequencies = ['daily', 'weekly'];
    if (!validFrequencies.includes(value)) {
      throw new Error('la frecuencia debe de ser daily o weekly');
    }
    this.#frequency = value;
  }
}

¿Qué reglas de negocio quedan blindadas?

Nombre con mínimo de 3 caracteres.
Frecuencia solo en 'daily' o 'weekly'.
Estados inválidos bloqueados con throw new Error.

¿Cómo manejar errores con try y catch sin romper el flujo?

Cuando algo falla, no debe colapsar la experiencia. Con try y catch capturas los errores que lanzan los setters, muestras un mensaje claro con showMessage y detienes la operación con return null.

Captura errores y muestra mensajes descriptivos.
No rompas el flujo: usa return null.
Mantén datos del usuario sin perderse.

function addHabit(payload) {
  try {
    const habit = new Habit(payload);
    // continuar flujo normal: guardar, renderizar, etc.
    return habit;
  } catch (error) {
    showMessage(error.message, 'error');
    return null;
  }
}

¿Por qué usar setters dentro del constructor?

Si asignas directamente a los campos privados, evitas validaciones.
Usar setters en el constructor aplica invariantes desde el inicio.
Resultado: la clase nunca queda en estados inválidos.

¿Te quedó alguna duda o quieres compartir cómo aplicas estas invariantes en tu modelo de negocio? Deja tu comentario y cuéntanos tu enfoque.

Clases Grabadas

POO en JavaScript: cómo pensar antes de programar

Configuración de proyecto JavaScript con Git y npm

Función constructora y prototipo en JavaScript

Objeto literal para manejar balance en JavaScript

Cómo funcionan los prototipos en JavaScript

Clases en JavaScript: constructor y métodos static

Campos privados y setters con validación en JavaScript

Composición en POO: delegar logs a LogTracker

Polimorfismo en JavaScript con duck typing

Herencia en TypeScript: extends y super

Abstracción en POO: ocultar complejidad

Polimorfismo aplicado a calculadoras de rachas

Factory methods para hábitos en JavaScript

Errores de dominio con códigos y validación robusta

POO en JavaScript: cuándo usar objetos y funciones

Campos privados y setters con validación en JavaScript

Progreso del curso

Clases Grabadas

Recursos

Recursos