Introducción a la encapsulación en JavaScript
JavaScript es un lenguaje de secuencias de comandos orientado a objetos robusto, que es capaz de construir aplicaciones complejas tanto en el cliente como el servidor. Sin embargo, cuanto mayor es la complejidad en la implementación, se necesita un código más fácil de mantener y flexible para abordar la situación. La encapsulación, uno de los principios de la Programación Orientada a Objetos es la clave para lograr tales objetivos.
Por definición, la encapsulación en JavaScript es un proceso de vinculación de los datos con las funciones que actúan sobre los datos. La encapsulación nos permite controlar y validar los datos. En JavaScript, las variables se parecen a los datos.
La encapsulación significa ocultar información, es decir, la idea de que las entidades internas de un objeto no deben estar directamente al descubierto como entidades públicas. Esto ayudará a restringir el uso no autorizado de las variables. En cambio, si las personas que llaman desean lograr un resultado definido, deben usar el método público o entidades públicas dentro del objeto para acceder a las variables privadas del objeto.
Trabajo de encapsulación en JavaScript
Tomemos un problema simple en el que un objeto "empleado" contiene dos atributos "nombre" atributo.
var employee = (
name : "Aditya Chaturvedi",
);
alert(employee.name); // Aditya Chaturvedi
employee.name = "Rahul Khanna";
alert(employee.name); // Rahul Khanna
Todo se ve bien en el ejemplo anterior. Creamos el objeto, imprimimos su valor de atributo y lo modificamos. Pero el problema parece surgir cuando algún usuario intenta establecer un valor entero para el atributo de nombre.
employee.name = "Amit Trivedi";
alert(employee.name); // Amit Trivedi
En lo que respecta a JavaScript, esto es completamente legal, ya que en JavaScript una variable puede aceptar cualquier tipo que se le dé. Para rectificar esto, necesitamos establecer el rango de caracteres válidos que se pueden establecer en el nombre del atributo del objeto. Estas validaciones no pueden funcionar si la persona que llama puede acceder y modificar el valor de estos datos. La solución simple para esto sería
var employee = (
name : "Aditya Chaturvedi",
setName : function (value) (
var exp = new RegExp(/\d+/);
if( exp.test(value) ) (
alert("Invalid Name");
)
else (
this.name = value;
)
),
"getName" : function() (
return this.name;
)
);
alert( employee.getName() ); // Aditya Chaturvedi
employee.setName( "Rahul Khanna" );
alert( employee.getName() ); // Rahul Khanna
employee.setName( 42 ); // Invalid Name
alert( employee.getName() ); // Rahul Khanna
El ejemplo anterior aplica la validación, pero aún tiene algunas fallas, ya que si la persona que llama accede al nombre directamente, aún puede cambiarlo.
employee.setName( 42 ); // Invalid Name; Here name won't be changed.
employee.name = 42; // No validation happens and the name is changed
alert( employee.getName() ); // 42 is printed.
El objetivo final aquí es que el nombre de la variable no debe estar disponible globalmente con el objeto "empleado". La encapsulación lo ayuda. Esto puede resolverse mediante los conceptos Alcance y cierres de funciones.
1. Alcance de la función
Cualquier variable que esté escrita dentro del bloque de código de las funciones permanece oculta desde el exterior.
function fnScope()
(
var fnVar = "Hi!";
alert( fnVar ) // "Hi!";
)
alert( fnVar ) // error; fnVar is not accessible outside the function.
Por lo tanto, si movemos la variable "nombre" dentro de la función "setName", los llamantes no podrán acceder a ella directamente. Pero no es fácil poner directamente la variable "nombre" dentro de la función "setName" ya que la variable dentro de un bloque de funciones no se puede usar fuera de su alcance, por lo tanto, el nombre no estaría disponible para el método "getName". Para este cierre ayudará.
2. Cierres
Cuando dos funciones se agrupan junto con referencias a su estado circundante o el entorno léxico se conoce como cierre. En palabras simples, el cierre da acceso a una variable local de una función para ser utilizada por otra función dentro de una función principal. Aquí tenemos un nombre de variable oculto dentro de la función setName del mundo exterior. Pero el objeto interno (myObj) puede acceder a él:
var employee = function () (
var name = "Aditya Chaturvedi";
var exp = new RegExp(/\d+/);
var myObj = (
setName : function (value) (
if( exp.test(value) ) (
alert("invalid name");
)
else (
name = value; // The object has access to "name"
)
),
getName : function () (
return name; // The object has access to "name"
)
); // End of the Object
);
employee.getName(); // doesn't work!
Ahora que hemos utilizado el concepto de cierre, ambas funciones pueden acceder al objeto interno myObj. Pero aún así, hay una falla para acceder al objeto interno. Arriba hemos visto que employee.getName no se puede usar, ni employee.myObj.getName se puede usar ya que myObj también es privado para la función y no se puede acceder a las variables privadas fuera de este modo. Por lo tanto, debemos devolver el objeto interno cada vez que se llama a la función anónima y asignarla a una variable externa.
var employee = function () (
var name = "Aditya Chaturvedi";
var exp = new RegExp(/\d+/);
return (
setName : function (value) (
if( exp.test(value) ) (
alert("Invalid Name");
)
else (
name = value;
)
),
getName : function () (
return name;
)
); // end of the return
)(); // Note this '()' means we're calling the function
// and assigning the returned value to the variable employee
alert(employee.getName()); // Aditya Chaturvedi
employee.setName( "Rahul Khanna" );
alert(employee.getName()); // Rahul Khanna
employee.setName( 42 ); // Invalid Name; the name does'nt changes.
employee.name = 42; // Doesn't affect the private fullName variable.
alert(employee.getName()); // Rahul Khanna is printed again.
Ventajas de la encapsulación en JavaScript
La principal ventaja de utilizar la encapsulación en JavaScript es proporcionar seguridad a los datos. Otros beneficios de la encapsulación incluyen:
- La encapsulación protege un objeto contra el acceso ilegal.
- La encapsulación ayuda a alcanzar un nivel sin revelar sus detalles complejos.
- Esto reducirá los errores humanos.
- Haga que la aplicación sea más flexible y manejable.
- Simplifica la aplicación.
Conclusión
La encapsulación es la herramienta en JavaScript que se puede usar para hacer que la operación compleja sea fácil y manejable, haciendo que la aplicación general sea segura y fácil de trabajar.
Artículos recomendados
Esta es una guía de encapsulación en JavaScript. Aquí discutimos el funcionamiento de la encapsulación en JavaScript junto con conceptos y ventajas. También puede consultar los siguientes artículos para obtener más información.
- Características de JavaScript (Comentarios)
- Matrices en JavaScript: tipos y métodos
- Herramientas de JavaScript
- Para bucle en JavaScript (flujo de trabajo)
- Variables en JavaScript
- Tipos y errores de manejo en JavaScript
- Funciones de expresiones regulares en Python (ejemplo)
- Ejemplos de comentarios en PHP