Echemos un vistazo al propósito de los cierres. De hecho, al usar cierres, podemos hacer muchas cosas. Por ejemplo, simule el estilo de código orientado a objetos; expresar código de manera más elegante y concisa; y mejorar la eficiencia de la ejecución del código en algunos aspectos.
1 función anónima de auto-ejecutiva
Sabemos que si no se agregan todas las variables con la palabra clave VAR, el valor predeterminado se agregará a las propiedades del objeto global. Hay muchas desventajas para agregar tales variables temporales al objeto global.
Por ejemplo: otras funciones pueden usar mal estas variables; Haciendo que el objeto global sea demasiado grande y que afecte la velocidad de acceso (porque el valor de la variable debe atravesarse desde la cadena prototipo).
Además de usar la palabra clave VAR cada vez que usamos la variable, a menudo encontramos una situación en la que algunas funciones solo necesitan ejecutarse una vez y sus variables internas no necesitan mantenerse.
Por ejemplo, en la inicialización de la interfaz de usuario, podemos usar cierres:
La copia del código es la siguiente:
var dataModel = {
mesa : [],
árbol : {}
};
(función (dm) {
para (var i = 0; i <dm.table.rows; i ++) {
var fila = dm.table.rows [i];
para (var j = 0; j <row.cells; i ++) {
DrawCell (I, J);
}
}
// construir dm.tree
}) (dataModel);
Creamos una función anónima y la ejecutamos de inmediato, ya que las variables externas de referencia no pueden referencia dentro de ella,
Por lo tanto, se lanzará poco después de la ejecución. La clave es que este mecanismo no contaminará el objeto global.
2 caché
Tomemos otro ejemplo. Imagine que tenemos un objeto de función que requiere mucho tiempo que lleva mucho tiempo procesar cada llamada.
Luego necesitamos almacenar el valor calculado. Al llamar a esta función, primero buscamos en el caché. Si no se puede encontrar, realizaremos el cálculo.
Luego actualice el caché y devuelva el valor. Si se encuentra, simplemente devuelva el valor encontrado directamente. El cierre hace exactamente esto, porque no libera referencias externas,
Por lo tanto, se puede conservar el valor dentro de la función.
La copia del código es la siguiente:
var cachedsearchbox = (function () {
var cacheo = {},
count = [];
devolver {
adjectSearchBox: function (dsid) {
if (dsid en caché) {// Si el resultado está en caché
return cache [dsid]; // Regrese directamente al objeto en el caché
}
var fsb = new Uikit.webctrl.searchbox (dsid); // nuevo
caché [dsid] = fsb; // Actualizar caché
if (count.length> 100) {// El tamaño del caché está garantizado <= 100
eliminar caché [count.hift ()];
}
regresar FSB;
},
ClearSearchBox: function (DSID) {
if (dsid en caché) {
caché [dsid] .clearSelection ();
}
}
};
}) ();
CachedSearchBox.AttachSearchBox ("input1");
De esta manera, cuando llamamos a CachedSearchBox.Attachserachbox ("Input1") la segunda vez,
Podemos acceder al objeto desde el caché sin crear un nuevo objeto Searchbox.
3 Implementar el embalaje
Primero veamos un ejemplo sobre la encapsulación. Las variables en el interior no son accesibles fuera de la persona, pero se accede proporcionando cierres:
La copia del código es la siguiente:
var persona = function () {
// El alcance de la variable está dentro de la función y no se puede acceder fuera de la función
var name = "predeterminado";
devolver {
getName: function () {
nombre de retorno;
},
setname: function (newname) {
nombre = Newname;
}
}
} ();
print (persona.name); // Acceso directo, el resultado está indefinido
print (persona.getName ());
persona.setName ("Abruzzi");
print (persona.getName ());
Los resultados son los siguientes:
indefinido
por defecto
bronceado
4 Otro propósito importante de los cierres es implementar objetos orientados a objetos. Los idiomas de objetos tradicionales proporcionan mecanismos de plantilla de clase.
De esta manera, diferentes objetos (instancias de clases) tienen miembros y estados independientes y no interfieren entre sí. Aunque no existe el mecanismo como clase en JavaScript, mediante el uso de cierres,
Podemos simular tal mecanismo. Hablemos del ejemplo anterior:
La copia del código es la siguiente:
función persona () {
var name = "predeterminado";
devolver {
getName: function () {
nombre de retorno;
},
setname: function (newname) {
nombre = Newname;
}
}
};
var John = persona ();
print (John.getName ());
John.setName ("John");
print (John.getName ());
var jack = persona ();
print (jack.getName ());
Jack.SetName ("Jack");
print (jack.getName ());
Los resultados de la operación son los siguientes:
por defecto
John
por defecto
Jacobo
A partir de este código, podemos ver que tanto John como Jack pueden llamarse instancias de la clase de persona, porque el acceso al miembro del nombre es independiente y no se afecta entre sí.
Lo anterior es la función del cierre JS, que es muy simple y fácil de entender. Espero que sea útil para mis amigos.