Eval () e new Function () são a mesma coisa?

Essas duas funções estão fazendo a mesma coisa nos bastidores? (em funções de instrução única)

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'));

Não, eles não são os mesmos.

• eval() avalia uma string como uma expressão JavaScript dentro do escopo de execução atual e pode acessar variáveis ​​locais.
• new Function()analisa o código JavaScript armazenado em uma string em um objeto de função, que pode então ser chamado. Ele não pode acessar variáveis ​​locais porque o código é executado em um escopo separado.

Considere este código:

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

Se new Function('return (a = 22);')()fosse usada, a variável local amanteria seu valor. No entanto, alguns programadores de JavaScript, como Douglas Crockford, acreditam que nenhum dos dois deve ser usado a menos que seja absolutamente necessário , e avaliar / usar o Functionconstrutor em dados não confiáveis ​​é inseguro e imprudente.

Não.

Em sua atualização, as chamadas para evaluatee funcproduzem o mesmo resultado. Mas, eles definitivamente não estão "fazendo a mesma coisa nos bastidores". A funcfunção cria uma nova função, mas a executa imediatamente, enquanto a evaluatefunção simplesmente executa o código no local.

Da pergunta original:

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

Isso lhe dará resultados muito diferentes:

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

new Functioncria uma função que pode ser reutilizada. evalapenas executa a string fornecida e retorna o resultado da última instrução. Sua pergunta está equivocada, pois você tentou criar uma função de wrapper que usa Function para emular um eval.

É verdade que eles compartilham algum código por trás das cortinas? Sim, muito provavelmente. Exatamente o mesmo código? Certamente.

Por diversão, aqui está minha própria implementação imperfeita usando eval para criar uma função. Espero que esclareça a diferença!

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]');
}

A maior diferença entre esta e a nova Função é que Function não tem escopo léxico. Portanto, ele não teria acesso às variáveis ​​de fechamento e o meu teria.

Quero apenas apontar algumas sintaxes usadas nos exemplos aqui e o que isso significa:

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

observe que Function (...) () tem o "()" no final. Essa sintaxe fará com que func execute a nova função e retorne a string, não uma função que retorne string, mas se você usar o seguinte:

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

Agora func retornará uma função que retorna uma string.

Se você quer dizer, ele produzirá os mesmos resultados, então sim ... mas apenas avaliar (também conhecido como "avaliar esta string de JavaScript") seria muito mais simples.

EDITAR abaixo:

É como dizer ... esses dois problemas matemáticos são iguais:

1 + 1

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

Nesse exemplo, os resultados são os mesmos, sim. Ambos executam a expressão que você passa. Isso é o que os torna tão perigosos.

Mas eles fazem coisas diferentes por trás do scense. O que envolve new Function(), nos bastidores, cria uma função anônima a partir do código que você fornece, que é executada quando a função é chamada.

O JavaScript que você passa para ele não é tecnicamente executado até que você invoque a função anônima. Isso contrasta com o eval()que executa o código imediatamente e não gera uma função baseada nele.