usos legítimos del constructor Función

Question

dijo Como en varias ocasiones, se considera mala práctica utilizar el Function constructor (véase también la ECMAScript Language Specification, 5 ª edición , § 15.3.2.1):

new Function ([arg1[, arg2[, … argN]],] functionBody) 

(donde todos los argumentos son cadenas que contienen nombres de argumento y la última (o única) cadena contiene el cuerpo de la función).

A modo de recapitulación, se dice que es lento, según lo explicado por the Opera team:

Cada vez que [...] el Function se llama al constructor en una cadena que representa el código fuente, el motor de guiones debe comenzar la maquinaria que convierte el código fuente en el código ejecutable . Esto suele ser costoso para el rendimiento - fácilmente cien veces más caro que una simple función llamada, por ejemplo. (Marcos Tarquino 'Wilton-Jones)

Aunque no es que mal, de acuerdo con this post en MDC (no he probado esto por mí mismo usando la versión actual de Firefox, sin embargo).

Crockford adds que

[e] l citando convenciones del lenguaje hacen que sea muy difícil de expresar correctamente cuerpo de una función como una cadena . En el formulario de cadena, no se puede realizar la comprobación de errores temprana . [...] Y desperdicia memoria porque cada función requiere su propia implementación independiente .

Otra diferencia es que

una función definida por una función constructor no hereda ningún margen que no sea el ámbito global (que todas las funciones heredan). (MDC)

Aparte de esto, usted tiene que estar atento para evitar la inyección de código malicioso, cuando se crea un new Function utilizando contenidos dinámicos.

Dicho esto, T.J. dice Crowder en an answer que

[n] o casi nunca es cualquier necesidad de la similares [...] nueva función (...), ya sea , de nuevo a excepción de algunos casos extremos avanzadas.

Entonces, ahora me pregunto: ¿cuáles son estos "casos avanzados"? ¿Existen usos legítimos del constructor de funciones?

Answer 1

jQuery lo usa para analizar cadenas JSON cuando un objeto del analizador JSON no está disponible. Parece de fiar a mí :)

 // Try to use the native JSON parser first 
     return window.JSON && window.JSON.parse ? 
      window.JSON.parse(data) : 
      (new Function("return " + data))(); 

Answer 2

que utilizar el constructor new Function() como intérprete JS en línea en una de las aplicaciones web que estoy en vías de desarrollo:

function interpret(s) { 
    //eval(s); <-- even worse practice 
    try { 
     var f = new Function(s); 
     f(); 
    } 
    catch (err) { 
     //graceful error handling in the case of malformed code 
    } 
} 

Mientras que consigo cosas de streaming a través de AJAX (no un iframe), continuamente interpret() en readyStateChange == 3. Esto funciona sorprendentemente bien.

Editar: aquí hay un estudio de caso claro que muestra que new Function() es categóricamente más rápido que eval(). Es decir. nunca debería (¿raramente?) usar eval en lugar de new Function().

http://polyfx.com/stuff/bsort.html < - la versión 1000 iteración, se puede bloquear el navegador

http://polyfx.com/stuff/bsort10.html < - la versión más corta

Eval es, en promedio, casi 8 veces más lento quenew Function().

Answer 3

Este es un caso separado de mi otra respuesta.

Utilicé el constructor de funciones hace un tiempo para crear formateadores de cadenas personalizadas a los que se llamaba repetidamente. La sobrecarga de crear la función (que considero que es el problema de rendimiento del que está hablando) fue ampliamente superada por el rendimiento mejorado de las funciones personalizadas, que se crearon en tiempo de ejecución específicamente para procesar una cadena de formato en particular, y por lo tanto no necesitó evaluar toneladas de casos irrelevantes — o analizar una cadena de formato, para el caso. Es un poco como compilar una expresión regular, supongo.

Answer 4

John Resig utilizó el constructor de funciones para crear versiones "compiladas" de plantillas del lado del cliente escritas en una sintaxis asp. http://ejohn.org/blog/javascript-micro-templating/

Answer 5

NWMatcher - Javascript CSS selector y de coincidencias, por Diego Perini - utiliza Function constructor (1, 2, 3, 4, etc.) para crear ("compilar") versiones de alta eficiencia de igualadores de selectores.

El benchmark (que acaba de ejecutar en Chrome 5) habla por sí mismo:

Nota la diferencia entre NWMatcher y el chisporroteo, que es un motor de selección muy similar, sólo sin compilación función :)

En una nota lateral, ECMAScript 5 no arroja ningún error en la invocación de Function. Ni en modo estricto, ni en modos "estándar".El modo estricto, sin embargo, presenta algunas restricciones a la presencia de identificadores tales como "eval" y "argumentos":

• No puede haber declarar variables/funciones/argumentos con tales nombres:

  function eval() { } 
  var eval = { }; 
  function f(eval) { } 
  var o = { set f(eval){ } }; 
  

• no se puede asignar a dicho identificador:

  eval = { }; 
  

también tenga en cuenta que en modo estricto, eval semántica es ligeramente diferente de la de ES3. Código de modo estricto no puede crear instancias de las variables o funciones en el entorno de la que se llamó:

eval(' "use strict"; var x = 1; '); 
typeof x; // "undefined" 

Answer 6

El único uso legítimo He venido porque es cuando escribí esto:

Function.prototype.New = (function() { 
    var fs = []; 
    return function() { 
    var f = fs [arguments.length]; 
    if (f) { 
     return f.apply (this, arguments); 
    } 
    var argStrs = []; 
    for (var i = 0; i < arguments.length; ++i) { 
     argStrs.push ("a[" + i + "]"); 
    } 
    f = new Function ("var a=arguments;return new this(" + argStrs.join() + ");"); 
    if (arguments.length < 100) { 
     fs [arguments.length] = f; 
    } 
    return f.apply (this, arguments); 
    }; 
})(); 

El El código le permite usar Function.prototype.apply mientras usa la palabra clave new.

Ejemplo:

function Foo (x, y, z) { 
    this.x = x; 
    this.y = y; 
    this.z = z; 
    this.otherArgs = Array.prototype.slice.call (arguments, 3); 
} 

var foo = Function.prototype.New.apply (Foo, [1, 2, 3, 4, 5, 6, 7]); 
// /*equiv*/ var foo = Foo.New.apply (Foo, [1, 2, 3, 4, 5, 6, 7]); 
// /*equiv*/ var foo = Foo.New (1, 2, 3, 4, 5, 6, 7); 
var bool = true 
    && foo.x == 1 
    && foo.y == 2 
    && foo.z == 3 
    && foo.otherArgs.length == 4 
    && foo.otherArgs [0] == 4 
    && foo.otherArgs [1] == 5 
    && foo.otherArgs [2] == 6 
    && foo.otherArgs [3] == 7 
    ; 

alert (bool); 

Answer 7

Es posible que desee ejecutar una cadena de código más de una vez. Usar el constructor de Funciones significa que solo tiene que compilarlo una vez.

Es posible que desee pasar argumentos al código, por ejemplo, si está rellenando un evento, puede recuperar el atributo de evento y construir una función esperando un argumento de evento.

Puede combinar los dos y compilarlo en una ubicación y ejecutarlo en otra y aún así administrar pasar argumentos en las variables que la cadena de código espera.