Tutorial JavaScript: Encapsulación

La encapsulación es un principio fundamental en la programación orientada a objetos (OOP) que busca encapsular, es decir, aislar y proteger la información interna de un objeto de una manera controlada, evitando el acceso y la modificación directa de sus propiedades (atributos) y métodos (funciones) desde el exterior. En JavaScript, la encapsulación puede lograrse utilizando conceptos como funciones, objetos, clausuras y ámbitos, pero no existe un mecanismo nativo de clases o modificadores de acceso, como en otros lenguajes.

A continuación, se presentan ejemplos de cómo se puede implementar la encapsulación utilizando diferentes enfoques en JavaScript.

Objeto literal con métodos de acceso:

Una posible forma de encapsulación en JavaScript es a través de objetos literales que contengan funciones que actúen como métodos de acceso (getters y setters) y de modificación de las propiedades, sin exponer las propiedades directamente.

const persona = {
  nombre: 'Juan',
  apellido: 'Pérez',

  getNombre: function() {
    return this.nombre;
  },

  setNombre: function(nombre) {
    this.nombre = nombre;
  }
};

console.log(persona.getNombre()); // 'Juan'

persona.setNombre('Pedro');
console.log(persona.getNombre()); // 'Pedro'

Sin embargo, esta aproximación no es óptima, ya que las propiedades siguen siendo públicas y accesibles directamente desde fuera del objeto (persona.nombre).

IIFE y clausuras:

Una forma más efectiva de encapsulación en JavaScript es a través de funciones anónimas auto-ejecutables (IIFE, por sus siglas en inglés, Immediately Invoked Function Expression) y clausuras, lo que permite mantener la información privada al limitar el ámbito de las variables.

const persona = (function() {
  let nombre = 'Juan';

  function getNombre() {
    return nombre;
  }

  function setNombre(nuevoNombre) {
    nombre = nuevoNombre;
  }

  return {
    getNombre: getNombre,
    setNombre: setNombre
  };
})();

console.log(persona.getNombre()); // 'Juan'

persona.setNombre('Pedro');
console.log(persona.getNombre()); // 'Pedro'

console.log(persona.nombre); // undefined

En este ejemplo, las propiedades y métodos privados se definen dentro del ámbito de la función anónima, y sólo se retornan los métodos públicos. De esta manera, la variable nombre es inaccesible desde fuera de la función (no está expuesta en el objeto persona), y solamente se puede acceder y modificar a través de los métodos getNombre y setNombre.

Clases y getters/setters:

Desde ES6, JavaScript ofrece una sintaxis más clara para crear objetos y manejar la herencia mediante el uso de clases, lo que facilita la implementación de la encapsulación utilizando getters y setters.

class Persona {
  constructor(nombre) {
    this._nombre = nombre;
  }

  get nombre() {
    return this._nombre;
  }

  set nombre(nuevoNombre) {
    this._nombre = nuevoNombre;
  }
}

const persona = new Persona('Juan');
console.log(persona.nombre); // 'Juan'

persona.nombre = 'Pedro';
console.log(persona.nombre); // 'Pedro'

console.log(persona._nombre); // 'Pedro'

Aunque esto mejora la legibilidad del código y permite una mejor implementación de OOP, la propiedad sigue siendo pública y accesible (con el prefijo _), porque JavaScript no ofrece modificadores de acceso nativos como private.

En resumen, la encapsulación en JavaScript puede lograrse utilizando diferentes enfoques, aunque no existe un mecanismo nativo y completo como en otros lenguajes. Es importante tener en cuenta estos conceptos para implementar un código más modular y fácil de mantener, así como para evitar la exposición de información sensible y la modificación involuntaria de datos internos de los objetos.