Eval () et new Function () sont-ils la même chose?

Ces deux fonctions font-elles la même chose dans les coulisses? (dans les fonctions d'instruction unique)

var evaluate = function(string) {
    return eval('(' + string + ')');
}

var func = function(string) {
    return (new Function( 'return (' + string + ')' )());
}

console.log(evaluate('2 + 1'));
console.log(func('2 + 1'));

Non, ce ne sont pas les mêmes.

• eval() évalue une chaîne en tant qu'expression JavaScript dans la portée d'exécution actuelle et peut accéder aux variables locales.
• new Function()analyse le code JavaScript stocké dans une chaîne dans un objet fonction, qui peut ensuite être appelé. Il ne peut pas accéder aux variables locales car le code s'exécute dans une portée distincte.

Considérez ce code:

function test1() {
    var a = 11;
    eval('(a = 22)');
    alert(a);            // alerts 22
}

Si elles new Function('return (a = 22);')()étaient utilisées, la variable locale aconserverait sa valeur. Néanmoins, certains programmeurs JavaScript tels que Douglas Crockford pensent que ni l'un ni l'autre ne devrait être utilisé à moins que cela ne soit absolument nécessaire , et l'évaluation / l'utilisation du Functionconstructeur sur des données non fiables n'est pas sécurisée et imprudente.

Non.

Dans votre mise à jour, les appels à evaluateet funcproduisent le même résultat. Mais ils ne "font certainement pas la même chose dans les coulisses". La funcfonction crée une nouvelle fonction, mais l'exécute immédiatement, alors que la evaluatefonction exécute simplement le code sur place.

De la question d'origine:

var evaluate = function(string) {
    return eval(string);
}
var func = function(string) {
    return (new Function( 'return (' + string + ')' )());
}

Ceux-ci vous donneront des résultats très différents:

evaluate('0) + (4');
func('0) + (4');

new Functioncrée une fonction qui peut être réutilisée. evalexécute simplement la chaîne donnée et renvoie le résultat de la dernière instruction. Votre question est erronée lorsque vous avez tenté de créer une fonction wrapper qui utilise Function pour émuler une évaluation.

Est-il vrai qu'ils partagent du code derrière les rideaux? Oui, très probablement. Exactement le même code? Non, certainement.

Pour le plaisir, voici ma propre implémentation imparfaite utilisant eval pour créer une fonction. J'espère que cela éclairera la différence!

function makeFunction() {
  var params = [];
  for (var i = 0; i < arguments.length -  1; i++) {
    params.push(arguments[i]);
  }
  var code = arguments[arguments.length -  1];


 // Creates the anonymous function to be returned
 // The following line doesn't work in IE
 // return eval('(function (' + params.join(',')+ '){' + code + '})');
 // This does though
 return eval('[function (' + params.join(',')+ '){' + code + '}][0]');
}

La plus grande différence entre cette fonction et la nouvelle fonction est que la fonction n'est pas de portée lexicale. Il n'aurait donc pas accès aux variables de fermeture et la mienne le ferait.

Je veux juste souligner une syntaxe utilisée dans les exemples ici et ce que cela signifie:

 var func = function(string) {
     return (new Function( 'return (' + string + ')' )());
 }

notez que la fonction (...) () a le "()" à la fin. Cette syntaxe obligera func à exécuter la nouvelle fonction et à renvoyer la chaîne, pas une fonction qui renvoie une chaîne, mais si vous utilisez ce qui suit:

 var func = function(string) {
     return (new Function( 'return (' + string + ')' ));
 }

Maintenant func retournera une fonction qui retourne une chaîne.

Si vous voulez dire, cela donnera-t-il les mêmes résultats, alors oui ... mais juste pour eval (aka, "évaluer cette chaîne de JavaScript") serait beaucoup plus simple.

EDIT ci-dessous:

C'est comme dire ... ces deux problèmes mathématiques sont-ils les mêmes:

1 + 1

1 + 1 + 1 - 1 + 1 - 1 * 1/1

Dans cet exemple, les résultats sont les mêmes, oui. Les deux exécutent l'expression que vous transmettez. C'est ce qui les rend si dangereux.

Mais ils font des choses différentes derrière le scense. Celui qui implique new Function(), en coulisses, crée une fonction anonyme à partir du code que vous fournissez, qui est exécutée lorsque la fonction est appelée.

Le JavaScript que vous lui transmettez n'est techniquement pas exécuté tant que vous n'appelez pas la fonction anonyme. Cela contraste avec eval()qui exécute le code tout de suite et ne génère pas de fonction basée sur celui-ci.