Este artículo analiza los métodos de creación y llamadas de funciones anónimas en JS. Compártelo para su referencia. El método de implementación específico es el siguiente:
Las funciones anónimas son funciones sin nombres, también llamadas cierres, que permiten la creación temporal de una función sin un nombre especificado. Muy a menudo utilizado como un valor para los parámetros de devolución de llamada, muchos novatos no saben sobre las funciones anónimas. Analicémoslo aquí.
Nombre de la función de función (Lista de parámetros) {Function Body;}
Si está creando funciones anónimas, debería ser:
function () {function body;}
Debido a que es una función anónima, generalmente no se le pasan parámetros.
¿Por qué crear funciones anónimas? ¿En qué circunstancias se utilizarán funciones anónimas? Hay dos escenarios comunes para funciones anónimas, uno es la función de devolución de llamada y el otro es ejecutar directamente la función.
Las funciones de devolución de llamada, como las operaciones asíncronas de Ajax, requieren funciones de devolución de llamada. No lo explicaré en detalle aquí. Con respecto a la ejecución directa de las funciones, lo entenderé después de mirar un ejemplo:
Copie el código de la siguiente manera: <script language = "javaScript">
var a = "a";
(función(){
var a = "b";
alerta (a);
}) ();
alerta (a);
</script>
En el código anterior, se emitirán dos cuadros de alerta en secuencia. El contenido del primer cuadro de alerta es B y el segundo es a. ¿Has visto algún beneficio? Correcto, el uso de la ejecución de la función puede limitar el alcance de las variables para que las mismas variables en diferentes scripts puedan coexistir.
A continuación, primero entendamos los conceptos relacionados con las funciones anónimas.
Declaraciones de función. Para usar una función, primero debemos declarar su existencia. La forma más común que usamos es definir una función utilizando declaraciones de función, como:
Copie el código de la siguiente manera: function ABC () {
// código para procesar
}
función abc () {// código para procesar}
Por supuesto, su función también puede ser con parámetros o incluso con valores de retorno.
La copia del código es la siguiente: ¿Vea PlainCopy a Portboardprint?
función abc (x, y) {
return x+y;
}
función abc (x, y) {return x+y; }
Sin embargo, no importa cómo defina su función, el intérprete JS lo traducirá en un objeto de función. Por ejemplo, define el número de función de uno de los ejemplos anteriores e ingresa el siguiente código:
Copie el código de la siguiente manera: alerta (typeof ABC); // "función"
Su navegador aparecerá en un cuadro de inmediato, lo que le provocará que ABC es un objeto de función. Entonces, ¿cuál es exactamente el objeto de función?
Objeto de función
El objeto de función es un objeto inherente en JavaScript, y todas las funciones son en realidad un objeto de función. Primero veamos si el objeto de función puede usar directamente el constructor para crear una nueva función. La respuesta es sí. Por ejemplo:
La copia del código es la siguiente: var abc = nueva función ("x", "y", "return x*y;");
alerta (ABC (2,3)); // "6"
Creo que todos deberían comprender cómo declarar una función ahora. Entonces, ¿qué es una función anónima?
Declarar funciones anónimas
Como su nombre lo indica, las funciones anónimas son funciones sin nombres reales. Por ejemplo, eliminamos el nombre de la función en el ejemplo anterior y luego determinamos si es una función:
Copie el código de la siguiente manera: alert (typeof function () {}); // "función"
alerta (función de typeof (x, y) {return x+y;}); // "función"
alerta (typeof nueva función ("x", "y", "return x*y;")) // "función"
alert (typeof function () {}); // "función"
alerta (función de typeof (x, y) {return x+y;}); // "función"
alerta (typeof nueva función ("x", "y", "return x*y;")) // "función"
Podemos ver fácilmente que todos son objetos de función, en otras palabras, todas son funciones, pero todas tienen una característica, sin nombres. Entonces los llamamos "funciones anónimas". Sin embargo, precisamente porque no tienen un "nombre", no tenemos forma de encontrarlos. Esto extiende la cuestión de cómo llamar a una función anónima.
Llamar a la función anónima
Para llamar a una función, debemos tener un método para localizarla y hacer referencia a ella. Entonces, tendremos que encontrar un nombre para ello. Por ejemplo:
Copie el código de la siguiente manera: var abc = function (x, y) {
return x+y;
}
alerta (ABC (2,3)); // "5"
La operación anterior es realmente equivalente a definir una función de una manera diferente. Este uso es algo que encontramos con más frecuencia. Por ejemplo, cuando configuramos una función de controlador de eventos de elementos DOM, generalmente no los nombramos, sino que le damos a su evento correspondiente una referencia a una función anónima.
En realidad, hay otra forma de llamar a las funciones anónimas, que es el fragmento jQuery que vemos - use () para encerrar las funciones anónimas y luego agregar un par de soportes (incluidas las listas de parámetros). Echemos un vistazo a los siguientes ejemplos:
Copie el código de la siguiente manera: alerta ((función (x, y) {return x+y;}) (2,3)); // "5"
alerta ((nueva función ("x", "y", "return x*y;")) (2,3)); // "6"
Muchas personas pueden preguntarse por qué este método se puede llamar con éxito. Si cree que esta aplicación es extraña, consulte mi explicación a continuación.
¿Conoces el papel de los soportes? Los soportes pueden dividir nuestras expresiones en trozos, y cada pieza, es decir, cada par de aparatos ortopédicos, tiene un valor de retorno. Este valor de retorno es en realidad el valor de retorno de la expresión entre paréntesis. Por lo tanto, cuando encerramos una función anónima con un par de soportes, los paréntesis devuelven un objeto de función de una función anónima. Por lo tanto, agregar funciones anónimas al par de soporte es como una función con nombre y obtenemos su posición de referencia. Entonces, si agrega una lista de parámetros después de esta variable de referencia, se implementará el formulario de llamada de la función ordinaria.
No sé si puedes entender el texto anterior. Si aún no puede entenderlo, eche un vistazo al siguiente código y pruebe.
Copie el código de la siguiente manera: var abc = function (x, y) {return x+y;}; // asignar objeto de función anónima a ABC
// El constructor de ABC es el mismo que el constructor de funciones anónimas. Es decir, la implementación de las dos funciones es la misma.
alert ((ABC) .Constructor == (función (x, y) {return x+y;}). constructor);
PS: el constructor se refiere a una función que crea un objeto. Es decir, el cuerpo de función representado por el objeto de función.
En resumen, comprenda (función anónima contenida en los soportes) como un objeto de función devuelto por la expresión del soporte, y luego puede hacer una llamada de la lista de parámetros normal a este objeto de función. (Cometí un error aquí antes. Solo las expresiones de función no se pueden llamar directamente. Eliminar los soportes de la función anónima y se debe asignar con la expresión. Es decir, (function () {alerta (1)}) () debe ser equivalente a a = function () {alerta (1)} (), y ni siquiera puede eliminar un =).
Cierre
¿Qué es un cierre? Los cierres se refieren a bloques de código en un cierto lenguaje de programación que permiten la existencia de una función de primer nivel y las variables libres definidas en la función de primer nivel no se pueden lanzar. Hasta que se lance la función de primer nivel, estas variables libres inéditas se pueden aplicar fuera de la función de primer nivel.
¿cómo? Estaba sudando ... estaba bien, yo también (aunque lo entiendo, era solo una cuestión de capacidad de expresión). Explicémoslo de una manera más simple: el cierre es en realidad una característica de idioma. Se refiere al lenguaje de programación que permite que las funciones se consideren objetos, y luego las variables de instancia (locales) se pueden definir en funciones como operaciones en objetos. Estas variables se pueden guardar en las funciones hasta que se destruye el objeto de instancia de la función. Otros bloques de código pueden obtener los valores de estas variables (locales) de alguna manera y aplicarlas a la aplicación.
No sé si será más claro después de explicar de esta manera. Si aún no lo entiende, simplificamos: los cierres realmente se refieren a variables locales definidas en las funciones de ejecución en el lenguaje de programación.
Ahora veamos un ejemplo:
Copie el código de la siguiente manera: var abc = function (y) {
var x = y; // Esta es una variable local
Función de retorno () {
alerta (x ++); // Aquí es donde se llama a X en la función de la función de primer nivel en la función de cierre y funciona en ella
alerta (y-); // La variable de parámetro referenciada también es una variable gratuita
}} (5); // Inicialización
abc (); // "5" "5"
abc (); // "6" "4"
abc (); // "7" "3"
alerta (x); // ¡un error! ¡"X" no está definido!
Después de ver esto, ¿puede saber si el fragmento de código de jQuery es el cierre?
En mi opinión, hablemos de ello. Ya sea que se aplique la función de cierre, es necesario determinar si el elemento más importante de este código es: variables locales sin restricciones. Entonces es obvio que es imposible aplicar la función de cierre sin ninguna implementación. Pero, ¿qué pasa si hay una implementación en una función anónima? También debe determinar si hay variables locales indestamadas en su implementación. Entonces, si pregunta qué características en JS se usan al comienzo del fragmento de código jQuery. Entonces es solo una llamada a funciones anónimas y funciones anónimas. Sin embargo, implica las características de los cierres y se pueden implementar en cualquier momento.
El uso más común:
Copie el código de la siguiente manera: (function () {
alerta ('agua');
}) ();
Por supuesto, los parámetros también se pueden incluir:
Copie el código de la siguiente manera: (función (o) {
alerta (O);
})('agua');
¿Quieres usar llamadas encadenadas con funciones anónimas? Muy simple:
Copie el código de la siguiente manera: (función (o) {
alerta (O);
Return Arguments.callee;
}) ('Water') ('Down');
Conoces todas las funciones anónimas comunes, echemos un vistazo a las poco comunes:
Copie el código de la siguiente manera: ~ (function () {
alerta ('agua');
}) (); // La escritura es un poco genial ~
función vacía () {
alerta ('agua');
} (); // Se dice que el más eficiente ~
+function () {
alerta ('agua');
} ();
-función(){
alerta ('agua');
} ();
~ function () {
alerta ('agua');
} ();
!función(){
alerta ('agua');
} ();
(función(){
alerta ('agua');
} ()); // Un poco de ejecución forzada ~
Espero que este artículo sea útil para la programación de JavaScript de todos.