¿Por qué no utilizar funciones anónimas JS?
La forma básica de una función anónima es (function(){...}) ();
El primer corchete contiene el cuerpo de la función y el segundo corchete es pasadas a funciones anónimas y parámetros que se ejecutan inmediatamente
El propósito de las funciones anónimas es evitar la contaminación de las variables globales y el conflicto de los nombres de las funciones
Debe prestar atención a las funciones anónimas siempre que lees el código. A veces se llaman lambdas, a veces se llaman funciones anónimas y, de cualquier manera, no creo que las funciones anónimas sean fáciles de usar.
Si no sabe qué es una función anónima, consulte lo siguiente:
Las funciones anónimas son funciones que se declaran dinámicamente en tiempo de ejecución. Se denominan funciones anónimas porque, a diferencia de las funciones normales, no tienen nombre de función. - Helen Emerson, Helenphant.com
Las funciones anónimas tienen la forma:
función () {... código...}
O
(args) =gt; { ... código... Hoy estoy tratando de comprender la idea de que las funciones anónimas generalmente solo deben usarse cuando es absolutamente necesario. No se deben preferir las funciones anónimas y se deben utilizar si se sabe por qué. Comprenda esta idea y su código será más limpio, más fácil de mantener y más fácil de rastrear errores. Comencemos con tres razones para evitar el uso de funciones anónimas:
Cuando escribes código, no importa lo bueno que seas tecleándolo, siempre encontrarás errores. A veces son fáciles de detectar, otras no.
Los errores son fáciles de detectar si conoces su origen. Para encontrar el error, necesitamos utilizar la herramienta de seguimiento de pila. Si no conoce los seguimientos de pila, Goole proporciona una buena introducción.
Supongamos que ahora tenemos un proyecto muy simple:
función inicio () {
(función media () {
( función end () {
console.lg('prueba');
})()()
})()
} Hay un error muy estúpido en el código anterior, es decir, un error tipográfico (console.log). En un proyecto pequeño, este error ortográfico sería un problema menor. Si se trata de una pequeña parte de un proyecto más grande con muchos módulos, es un gran problema. Suponiendo que no haya cometido este estúpido error, ¡el nuevo ingeniero junior lo habría cometido en el código base antes de irse de vacaciones!
Ahora, tenemos que encontrarlo. Usando nuestra función cuidadosamente nombrada, obtendríamos el siguiente seguimiento de pila:
¡Gracias por nombrar tu función, desarrollador junior!
Pero... una vez que solucionamos eso, encontramos otro error. Esta vez fue presentado por un desarrollador de mayor rango. Este desarrollador conoce lambdas
Entonces se topan con un error y es nuestro trabajo localizarlo.
Aquí está el código:
(función() {
(función() {
(función() {
console.lg('prueba');
})(
})(
})();
}) ( );
¡No sorprende que este desarrollador también haya olvidado cómo se escribe console.log! ¡Qué coincidencia! Desafortunadamente, ninguno de ellos mencionó sus funciones.
Entonces, ¿cuál será el resultado de la consola?
Bueno, al menos todavía tenemos números de línea, ¿verdad? En este ejemplo parece que tenemos alrededor de 7 líneas de código. ¿Qué sucede si estamos ante un gran bloque de código? ¿Como 10.000 líneas de código? ¿Cómo deberíamos manejar una extensión tan grande de filas? Si no hay un archivo de mapeo de código al plegar el código, ¿no sería inútil presentar los números de línea?
Creo que la respuesta a estas preguntas es muy simple, es que pensar en estas preguntas hará que tu día sea terrible.
Legibilidad
Oye, he oído que todavía no me crees. Bueno, tengo que pedirte disculpas porque pensaste que tu código era perfecto. ¡Echemos un vistazo a esto!
Mire los dos fragmentos de código siguientes:
función iniciar (argumentos) {
return new Promise((resolver, rechazar) =gt; {
prueba {
if (argumentos) {<
return resolve(true
}
return resolver(falso);
} catch (e) {
rechazar(e);
}
}); /p>
}
}
iniciar(verdadero)
.then(res =gt; {
if ( res) {
hacerAlgoMás();
} más {
hacerAlgo()
}
).catch (e =gt; {
logError(e.message);
restartApp();
}
) ; Este es un ejemplo muy inusual, pero estoy seguro de que entiendes la idea. Nuestro método devuelve una promesa y utilizamos este objeto/método de promesa para manejar diferentes respuestas posibles.
Podrías pensar que algunos fragmentos de código no son difíciles de leer, ¡pero creo que podrían ser mejores!
¿Qué pasa si eliminamos todas las funciones anónimas?
función iniciar (argumentos) {
return new Promise(checkForArguments);
}
función checkForArguments (resolver, rechazar) {
prueba {
if (argumentos) {
return resolve(true);
}
return; resolver(falso);
} capturar (e) {
rechazar(e
}
}
función evaluarRes (res) {
if (res) {
hacerAlgoElse();
} más {
hacerAlgo ( );
}
}
función handleError (e) {
logError(e. mensaje);