La guía definitiva para los recolectores y establecedores en JavaScript
Getters y setters son funciones o metodos usados para obtener y conjunto los valores de las variables. El concepto de getter-setter es común en la programación de computadoras: casi todos los lenguajes de programación de alto nivel vienen con un conjunto de sintaxis para implementar getters y setters, incluido JavaScipt.
En esta publicación, veremos qué son los establecedores de captadores y cómo créalos y utilízalos en JavaScript.
Getters-setters y encapsulación
La idea de getters y setters es siempre mencionada. en conjunción con la encapsulación. La encapsulación puede ser entendido de dos maneras.
En primer lugar, es la puesta en marcha de la configuradores de datos Trío para acceder y modificar esos datos. Esta definición es útil cuando algunas operaciones, como la validación, tienen que ser realizado en los datos Antes de guardarlo o verlo, los creadores y creadores proporcionan el hogar perfecto para él..
En segundo lugar, hay una definición más estricta según la cual se realiza la encapsulación para ocultar datos, para que sea inaccesible desde otro código, Excepto a través de los captadores y setters.. De esta manera no terminamos accidentalmente sobrescribiendo datos importantes Con algún otro código en el programa..
Crea getters y setters.
1. Con los métodos.
Dado que los captadores y setters son básicamente funciones que buscar / cambiar un valor, hay más de una manera para crearlos y usarlos. La primera forma es:
var obj = foo: 'este es el valor de foo', getFoo: function () return this.foo; , setFoo: function (val) this.foo = val; console.log (obj.getFoo ()); // "este es el valor de foo" obj.setFoo ('hello'); console.log (obj.getFoo ()); // "Hola" Esto es la forma más sencilla para crear getters y setters. Hay una propiedad foo y hay dos métodos: getFoo y setFoo a devolver y asignar un valor a esa propiedad.
2. Con palabras clave
Un mas “oficial” y la forma robusta de crear captadores y definidores es usando el obtener y conjunto palabras clave.
A crear un captador, colocar el obtener palabra clave delante de una declaración de función que servirá como el método getter, y usará el conjunto palabra clave de la misma manera a crear un setter. La sintaxis es la siguiente:
var obj = fooVal: 'este es el valor de foo', obtiene foo () return this.fooVal; , establece foo (val) this.fooVal = val; console.log (obj.foo); // "este es el valor de foo" obj.foo = 'hello'; console.log (obj.foo); // "Hola"
Tenga en cuenta que los datos sólo pueden ser almacenado bajo un nombre de propiedad (fooVal) eso es diferente del nombre de los métodos de getter-setter (foo) porque una propiedad que posee el establecedor getter no puede contener los datos también.
Que camino es mejor?
Si elige crear captadores y definidores con palabras clave, puede utilizar el operador de asignación para establecer los datos y el operador de puntos para obtener los datos, de la misma forma en que accedería / establecería el valor de una propiedad regular.
Sin embargo, si elige la primera forma de codificar los captadores y definidores, debe llamar a los métodos setter y getter. usando la función de sintaxis de llamada porque son funciones típicas (nada especial como las creadas usando el obtener y conjunto palabras clave).
Además, existe la posibilidad de que termines accidentalmente. asignando algún otro valor a las propiedades que mantenían esos métodos de getter-setter y perderlos completamente! Algo de lo que no tienes que preocuparte en el método posterior.
Entonces, puedes ver por qué dije la La segunda técnica es más robusta..
Prevención de sobrescritura
Si, por algún motivo, prefiere la primera técnica, configure las propiedades que contienen los métodos de establecimiento de la configuración. solo lectura al crearlos utilizando Object.defineProperties. Propiedades creadas a través de Object.defineProperties, Object.defineProperty y Reflect.defineProperty configurar automáticamente a escribible: falso lo que significa solo lectura:
/ * Prevención de sobrescritura * / var obj = foo: 'este es el valor de foo'; Object.defineProperties (obj, 'getFoo': value: function () return this.foo;, 'setFoo': value: function (val) this.foo = val;); obj.getFoo = 66; // ¡getFoo no va a ser sobrescrito! console.log (obj.getFoo ()); // "este es el valor de foo"
Operaciones dentro de getters y setters.
Una vez que haya introducido a los captadores y establecedores, puede seguir adelante y Realizar operaciones sobre los datos. antes de cambiarlo o devolverlo.
En el siguiente código, en la función getter, los datos son concatenado con una cuerda antes de ser devuelto, y en la función de establecimiento una validación de Si el valor es un número o no se realiza antes de actualizar norte.
var obj = n: 67, get id () return 'El ID es:' + this.n; , establecer id (val) if (typeof val === 'número') this.n = val; console.log (obj.id); // "El ID es: 67" obj.id = 893; console.log (obj.id); // "El ID es: 893" obj.id = 'hello'; console.log (obj.id); // "El ID es: 893"
Proteger los datos con captadores y configuradores
Hasta ahora, hemos cubierto el uso de captadores y definidores en el primer contexto de encapsulación. Vamos a pasar al segundo, es decir, cómo ocultar datos del código externo Con la ayuda de getters y setters..
Datos no protegidos
La configuración de captadores y definidores no significa que solo se pueda acceder a los datos y cambiarlos a través de esos métodos. En el siguiente ejemplo, es cambiado directamente sin tocar los métodos getter y setter:
var obj = fooVal: 'este es el valor de foo', obtiene foo () return this.fooVal; , establece foo (val) this.fooVal = val; obj.fooVal = 'hola'; console.log (obj.foo); // "Hola"
No usamos el setter pero Cambió directamente los datos (fooVal). Los datos que inicialmente establecemos dentro obj se ha ido ahora! Para evitar que esto suceda (accidentalmente), usted necesita algo de protección para sus datos. Usted puede agregar eso por limitando el alcance de donde están disponibles sus datos. Usted puede hacer eso por cualquiera bloqueo del alcance o función de alcance.
1. Bloquear el alcance
Una forma es usar un ámbito de bloque dentro de la cual los datos se definirán utilizando el dejar palabra clave que limita su alcance a ese bloque.
UNA alcance del bloque Se puede crear colocando tu código. dentro de un par de llaves. Cada vez que cree un ámbito de bloque, asegúrese de Deja un comentario encima de ella pidiendo que se dejen los frenillos solos, para que nadie quita las llaves por error pensando que son algunas llaves extra redundantes en el código o agregar una etiqueta al ámbito del bloque.
/ * ÁMBITO DE BLOQUEO, ¡deja las llaves solos! * / let fooVal = 'este es el valor de foo'; var obj = get foo () return fooVal; , establece foo (val) fooVal = val fooVal = 'hola'; // no va a afectar el fooVal dentro del bloque console.log (obj.foo); // "este es el valor de foo"
Cambiar / crear fooValfuera de la cuadra no afectará la fooVal referido dentro de los setters getters.
2. Función de alcance
La forma más común de proteger los datos con alcance es mediante manteniendo los datos dentro de una función y devolviendo un objeto Con los captadores y setters de esa función..
function myobj () var fooVal = 'este es el valor de foo'; return get foo () return fooVal; , establece foo (val) fooVal = val fooVal = 'hola'; // no va a afectar nuestro original fooVal var obj = myobj (); console.log (obj.foo); // "este es el valor de foo"
El objeto (con el foo () getter-setter dentro de ella) devuelto por el myobj () la función es guardado en obj, y entonces obj se usa para llama al captador y al colocador.
3. Protección de datos sin alcance
También hay otra manera de proteger sus datos para que no se sobrescriban. sin limitar su alcance. La lógica detrás de esto es la siguiente: ¿cómo puedes cambiar un dato si no sabes cómo se llama??
Si los datos tienen una nombre de propiedad / variable no tan fácilmente reproducible, es probable que nadie (incluso nosotros mismos) termine sobrescribiéndolo asignando algún valor a esa variable / nombre de propiedad.
var obj = s89274934764: 'este es el valor de foo', obtener foo () return this.s89274934764; , establece foo (val) this.s89274934764 = val; console.log (obj.foo); // "este es el valor de foo"
Mira, esa es una manera de resolver las cosas. Aunque el nombre que elegí no es realmente bueno, también puedes utilizar valores o símbolos aleatorios para crear nombres de propiedades como lo propone Derick Bailey en esta publicación de blog. El objetivo principal es mantener los datos ocultos a partir de otro código y deje que un par de instaladores getter acceda / actualice.
¿Cuándo deberías usar getters y setters??
Ahora viene la gran pregunta: ¿empiezas a asignar getters y setters? a todos tus datos ahora?
Si eres ocultar datos, entonces hay sin otra opción.
Pero si tus datos están siendo vistos por otro código está bien, ¿todavía necesitas utilizar los configuradores de captadores? sólo para empaquetarlo con código que realiza algunas operaciones en él? Yo diría que sí. Código se suma muy pronto. Creando micro unidades de datos individuales con su propio getter-setter. Te proporciona cierta independencia. Trabajar en dichos datos sin afectar otras partes del código..
