Por que usar a função eval JavaScript é uma má idéia?

534

A função eval é uma maneira fácil e poderosa de gerar código dinamicamente. Quais são as advertências?

Brian Singh
fonte
92
Não seja eval () por Simon Willison - 24ways.org/2005/dont-be-eval
Brian Singh
5
Conforme descrito em moduscreate.com/javascript-performance-tips-tricks - (new Function (str)) () tem mais desempenho que eval (str). Apenas meus 2 centavos :)
Grgur
3
aparentemente a nova função (a) é 67% mais lenta que a eval (a) no chrome
what is sleep
para mim novas funções (a) é de 80% mais lento mais recente cromo no OSX
John Smith
3
Eu adicionei uma função estática, apenas para comparar o desempenho. jsperf.com/eval-vs-new-function/2
Nepoxx

Respostas:

386
  1. O uso inadequado de eval abre seu código para ataques de injeção

  2. A depuração pode ser mais desafiadora (sem números de linha etc.)

  3. código eval'd executa mais lentamente (sem oportunidade de compilar / armazenar em cache código eval'd)

Edit: Como @Jeff Walden aponta nos comentários, o # 3 é menos verdadeiro hoje do que em 2008. No entanto, embora ocorra algum cache de scripts compilados, isso será limitado apenas a scripts que são eval'd repetidos sem modificação. Um cenário mais provável é que você esteja avaliando scripts que sofreram pequenas modificações a cada vez e, como tal, não puderam ser armazenados em cache. Digamos apenas que ALGUM código avaliado é executado mais lentamente.

Prestaul
fonte
2
@JeffWalden, ótimo comentário. Atualizei minha postagem, embora saiba que já faz um ano que você postou. Xnzo72, se você qualificou um pouco o seu comentário (como Jeff fez), posso concordar com você. Jeff apontou a chave: "avaliar a mesma string várias vezes pode evitar a análise de sobrecarga". Como está, você está errado; O número 3 é válido para muitos cenários.
Prestaul
7
@ Prestaul: Como o suposto invasor pode usar qualquer ferramenta de desenvolvedor para alterar o JavaScript no cliente, por que você diz que o Eval () abre seu código para ataques de injeção? Já não está aberto? (Estou falando de cliente JavaScript é claro)
Eduardo Molteni
60
@EduardoMolteni, não nos importamos (e de fato não podemos impedir) que os usuários executem js em seus próprios navegadores. Os ataques que estamos tentando evitar ocorrem quando os valores fornecidos pelo usuário são salvos e depois colocados em javascript e avaliados. Por exemplo, eu posso definir meu nome de usuário para: badHackerGuy'); doMaliciousThings();e se você pegar meu nome de usuário, concatê-lo em algum script e avaliá-lo nos navegadores de outras pessoas, eu posso executar qualquer javascript que desejar nas máquinas deles (por exemplo, forçá-los a marcar com +1 minhas postagens, postar seus dados no meu servidor, etc.)
Prestaul 25/10/12
3
Em geral, o número 1 é verdadeiro para muitas, se não a maioria das chamadas de função. eval () não deve ser destacado e evitado por programadores experientes, apenas porque programadores inexperientes abusam dele. No entanto, programadores experientes geralmente têm uma arquitetura melhor em seu código, e eval () raramente será necessário ou até pensado devido a essa melhor arquitetura.
Frodeborli 12/03/14
4
@TamilVendhan Claro que você pode colocar pontos de interrupção. Você pode acessar o arquivo virtual criado pelo Chrome para o seu código avaliado, adicionando a debugger;instrução ao seu código-fonte. Isso interromperá a execução do seu programa nessa linha. Depois disso, você pode adicionar pontos de interrupção de depuração como se fosse apenas outro arquivo JS.
Sid
346

avaliação nem sempre é má. Há momentos em que é perfeitamente apropriado.

No entanto, o eval é atualmente e historicamente excessivamente utilizado por pessoas que não sabem o que estão fazendo. Infelizmente, isso inclui pessoas que escrevem tutoriais sobre JavaScript e, em alguns casos, isso pode ter consequências de segurança - ou, mais frequentemente, bugs simples. Portanto, quanto mais podemos fazer para colocar um ponto de interrogação sobre a avaliação, melhor. Sempre que você usa o eval, você precisa verificar a sanidade do que está fazendo, porque é possível que esteja fazendo isso de uma maneira melhor, mais segura e mais limpa.

Para dar um exemplo muito típico, defina a cor de um elemento com um ID armazenado na variável 'potato':

eval('document.' + potato + '.style.color = "red"');

Se os autores do tipo de código acima tivessem uma idéia sobre o básico de como os objetos JavaScript funcionam, eles teriam percebido que colchetes podem ser usados ​​em vez de nomes de pontos literais, evitando a necessidade de avaliação:

document[potato].style.color = 'red';

... o que é muito mais fácil de ler, além de ter menos bugs.

(Mas então, alguém que realmente sabia o que estava fazendo diria:

document.getElementById(potato).style.color = 'red';

que é mais confiável do que o velho truque de acessar elementos DOM diretamente do objeto de documento.)

bobince
fonte
82
Hmm, acho que tive sorte quando aprendi JavaScript. Eu sempre usei "document.getElementById" para acessar o DOM; Ironicamente, eu só fiz isso no momento porque eu não tinha idéia de como objetos trabalhou em JavaScript ;-)
Mike Spross
5
aceita. Às vezes, eval é
aceitável
40
@schoetbi: você não deveria usar JSON.parse()em vez de eval()para JSON?
precisa saber é o seguinte
4
O @bobince code.google.com/p/json-sans-eval funciona em todos os navegadores, assim como github.com/douglascrockford/JSON-js . O json2.js de Doug Crockford usa eval internamente, mas com verificações. Além disso, é compatível com o suporte do navegador embutido para JSON.
287 Martijn
8
@bobince Existe algo chamado recurso de detecção e polyfills para lidar com falta bibliotecas JSON e outras coisas (olhada modernizr.com )
MauganRa
37

Eu acredito que é porque ele pode executar qualquer função JavaScript de uma string. Seu uso facilita a injeção de código não autorizado no aplicativo.

kemiller2002
fonte
5
Qual é a alternativa então?
moderns
5
Realmente a alternativa é apenas escrever um código que não o exija. Crockford discorre sobre isso e, se você precisar usá-lo, ele praticamente diz que é uma falha no design do programa e precisa ser reformulado. Na verdade, eu também concordo com ele. O JS, por todas as suas falhas, é realmente flexível e permite muito espaço para torná-lo flexível.
kemiller2002
3
Não é verdade, a maioria das estruturas possui um método para analisar JSON e, se você não estiver usando uma estrutura, poderá usar JSON.parse (). A maioria dos navegadores é compatível e, se você estiver realmente preocupado, poderá escrever um analisador para JSON com bastante facilidade.
kemiller2002
6
Eu não compro esse argumento, porque já é fácil injetar código nocivo em um aplicativo Javascript. Temos consoles de navegador, extensões de script, etc. Cada código único enviado ao cliente é opcional para sua execução.
user2867288
6
O ponto é que é mais fácil injetar código no seu navegador. Digamos que você esteja usando eval em uma string de consulta. Se eu induzi-lo a clicar em um link que acessa esse site com minha string de consulta anexada, agora eu executei meu código na sua máquina com total permissão do navegador. Quero registrar tudo o que você digita nesse site e enviá-lo para mim? Concluído e não há como me impedir, porque quando o eval é executado, o navegador concede a maior autoridade.
kemiller2002
27

Dois pontos vêm à mente:

  1. Segurança (mas, desde que você gere a sequência a ser avaliada, isso pode ser um problema)

  2. Desempenho: até que o código a ser executado seja desconhecido, ele não pode ser otimizado. (sobre javascript e desempenho, certamente a apresentação de Steve Yegge )

xtofl
fonte
9
Por que a segurança é um problema se o cliente pode fazer com o nosso código o que ele / ela deseja? Greasemonkey?
Paul Brewczynski
2
@PaulBrewczynski, o problema de segurança aparece quando o usuário A salva sua parte do código a ser evaluated e, em seguida, aquele pequeno pedaço de código é executado no navegador do usuário B
Felipe Pereira
21

Passar a entrada do usuário para eval () é um risco de segurança, mas também cada chamada de eval () cria uma nova instância do interpretador JavaScript. Isso pode ser um recurso pesado.

Andrew Hedges
fonte
27
Nos três anos ou mais desde que respondi a isso, meu entendimento do que acontece se aprofundou, digamos. O que realmente acontece é que um novo contexto de execução é criado. Veja dmitrysoshnikov.com/ecmascript/chapter-1-execution-contexts
Andrew Hedges
20

Geralmente, isso é apenas um problema se você está passando informações de avaliação de usuários.

Mark Biek
fonte
16

Principalmente, é muito mais difícil de manter e depurar. É como um goto. Você pode usá-lo, mas torna mais difícil encontrar problemas e mais difícil para as pessoas que precisam fazer alterações mais tarde.

Brian
fonte
O Eval pode ser usado para substituir os recursos de metaprogramação ausentes, como modelos. Gosto de gerador compacto muito mais do que uma lista interminável de funções sobre funções.
weaknespase
Contanto que a string não venha do usuário ou esteja limitada ao navegador que você puder. O JavaScript tem muito poder de metaprogramação usando coisas como alterar protótipos, obj [membro], Proxy, json.parse, window, funções de decorador (advérbios) em que newf = decorador (oldf), função de ordem superior como Array.prototype.map (f) , passando argumentos para outras funções, argumentos de palavras-chave via {}. Você pode me dizer um caso de uso em que não pode fazer isso em vez de avaliar?
aoeu256 19/07/19
13

Uma coisa a ter em mente é que você pode usar eval () para executar código em um ambiente restrito - sites de redes sociais que bloqueiam funções JavaScript específicas às vezes podem ser enganados dividindo-os em um bloco eval -

eval('al' + 'er' + 't(\'' + 'hi there!' + '\')');

Portanto, se você estiver olhando para executar algum código JavaScript onde, de outra forma, não seria permitido ( Myspace , estou olhando para você ...), eval () pode ser um truque útil.

No entanto, por todos os motivos mencionados acima, você não deve usá-lo para o seu próprio código, onde você tem controle total - isso não é necessário e a melhor situação é relegada à prateleira 'hacks JavaScript complicados'.

math lohkamp
fonte
1
Apenas atualizando o código acima .. - aqui está! - precisa estar entre aspas, pois é uma sequência de caracteres. eval ('al' + 'er' + 't (' + '"olá, lá!"' + ')');
Mahesh
2
[]["con"+"struc"+"tor"]["con"+"struc"+"tor"]('al' + 'er' + 't(\'' + 'hi there!' + '\')')()
21914 Konrad Borowski
4
Caramba, havia sites de redes sociais que restringiam alert () mas permitiam eval () ?!
joshden
12

A menos que você permita a eval () um conteúdo dinâmico (por meio de cgi ou entrada), ele é tão seguro e sólido quanto todos os outros JavaScript da sua página.

Thevs
fonte
Embora isso seja verdade - se seu conteúdo não é dinâmico, que motivo existe para usar o eval? Você pode simplesmente colocar o código em uma função e chamá-lo!
Periata Breatta
Apenas por exemplo - para analisar o valor retornado (como JSON, cadeias definidas pelo servidor etc.) provenientes da chamada do Ajax.
Thevs
2
Ah eu vejo. Eu chamaria isso de dinâmico porque o cliente não sabe antecipadamente o que é, mas entendo o que você quer dizer agora.
Periata Breatta
7

Juntamente com o restante das respostas, não acho que as declarações de avaliação possam ter minimização avançada.

Paul Mendoza
fonte
6

É um possível risco à segurança, possui um escopo de execução diferente e é bastante ineficiente, pois cria um ambiente de script totalmente novo para a execução do código. Veja aqui mais informações: eval .

É bastante útil, porém, e usado com moderação pode adicionar muitas boas funcionalidades.

Tom
fonte
5

A menos que você tenha 100% de certeza de que o código que está sendo avaliado é de uma fonte confiável (geralmente seu próprio aplicativo), é uma maneira infalível de expor seu sistema a um ataque de script entre sites.

John Topley
fonte
1
Somente se sua segurança do lado do servidor for ruim. A segurança do cliente é um absurdo direto.
doubleOrt
5

Eu sei que essa discussão é antiga, mas eu realmente gosto disso abordagem do Google e queria compartilhar esse sentimento com outras pessoas;)

A outra coisa é que quanto melhor você fica, mais você tenta entender e, finalmente, você simplesmente não acredita que algo seja bom ou ruim, apenas porque alguém disse isso :) Este é um vídeo muito inspirador que me ajudou a pensar mais sozinho :) BOAS PRÁTICAS são boas, mas não as use sem pensar :)

op1ekun
fonte
1
Sim. Eu encontrei, até agora pelo menos no Chrome, um caso de uso que parece ser mais eficiente. Execute um RAF que avalie uma sequência de caracteres em uma determinada variável a cada iteração. Use um setInterval para definir apenas coisas com orientação gráfica, como definir transformações etc. nessa sequência. Eu tentei muitas outras abordagens, como repetir funções em uma matriz ou usar uma variável para definir apenas transformações para elementos que são alterados, mas até agora isso parece ser mais eficiente. Quando se trata de animação, o verdadeiro teste de bancada são os seus olhos.
jdmayfield
5

Não é necessariamente tão ruim, desde que você saiba em que contexto o está usando.

Se seu aplicativo estiver usando eval()para criar um objeto a partir de algum JSON que retornou de um XMLHttpRequest para o seu próprio site, criado pelo seu código confiável do lado do servidor, provavelmente não é um problema.

O código JavaScript não confiável do lado do cliente não pode fazer tanto assim. Desde que o que você esteja executando eval()tenha vindo de uma fonte razoável, você estará bem.

MarkR
fonte
3
O uso de eval não é mais lento do que apenas analisar o JSON?
Brendan Long
@Qix - executar esse teste no meu navegador (Chrome 53) mostra eval como um pouco mais rápido do que analisar .
Periata Breatta
@PeriataBreatta Huh, estranho. Eu quero saber porque. Na época, comentei que não era o caso. No entanto, não é algo inédito para o Chrome obter estranhos aumentos de desempenho em determinadas áreas do tempo de execução de versão para versão.
Qix - MONICA FOI ERRADA EM 26/10
Um tópico antigo aqui, mas pelo que eu li - não afirmando que eu mesmo o rastreei - o JSON.parse, de fato, eval é sua entrada no estágio final. Portanto, em termos de eficiência, é preciso mais trabalho / tempo. Mas em termos de segurança, por que não apenas analisar? eval é uma ferramenta incrível. Use-o para coisas que não têm outra maneira. Para passar funções pelo JSON, existe uma maneira de fazê-lo sem avaliação. Esse segundo parâmetro no JSON.stringify permite colocar um retorno de chamada em execução que você pode verificar via typeof se é uma função. Em seguida, obtenha a função .toString (). Existem alguns bons artigos sobre isso, se você pesquisar.
Jdmayfield
4

Isso reduz bastante o seu nível de confiança sobre segurança.

David Plumpton
fonte
4

Se você deseja que o usuário insira algumas funções lógicas e avalie para AND o OR, a função JavaScript eval é perfeita. Eu posso aceitar duas cordas e eval(uate) string1 === string2etc.

Ian
fonte
Você também pode usar Function () {}, mas tenha cuidado ao usá-las no servidor, a menos que queira que os usuários assumam o controle do servidor hahahah.
aoeu256 19/07/19
3

Se você detectar o uso de eval () em seu código, lembre-se do mantra "eval () é mau".

Essa função pega uma sequência arbitrária e a executa como código JavaScript. Quando o código em questão é conhecido antecipadamente (não determinado em tempo de execução), não há razão para usar eval (). Se o código é gerado dinamicamente no tempo de execução, geralmente há uma maneira melhor de atingir a meta sem eval (). Por exemplo, apenas usar a notação de colchete para acessar propriedades dinâmicas é melhor e mais simples:

// antipattern
var property = "name";
alert(eval("obj." + property));

// preferred
var property = "name";
alert(obj[property]);

O uso eval()também tem implicações de segurança, porque você pode estar executando um código (por exemplo, proveniente da rede) que foi violado. Este é um antipadrão comum ao lidar com uma resposta JSON de uma solicitação Ajax. Nesses casos, é melhor usar os métodos internos dos navegadores para analisar a resposta JSON para garantir que ela seja segura e válida. Para navegadores que não suportamJSON.parse() nativo, você pode usar uma biblioteca do JSON.org.

Também é importante lembrar que as cordas que passam a setInterval(), setTimeout()e, o Function()construtor é, em sua maior parte, semelhante ao uso eval()e, portanto, deve ser evitado.

Nos bastidores, o JavaScript ainda precisa avaliar e executar a string que você passa como código de programação:

// antipatterns
setTimeout("myFunc()", 1000);
setTimeout("myFunc(1, 2, 3)", 1000);

// preferred
setTimeout(myFunc, 1000);
setTimeout(function () {
myFunc(1, 2, 3);
}, 1000);

O uso do novo construtor Function () é semelhante ao eval () e deve ser abordado com cuidado. Pode ser uma construção poderosa, mas geralmente é mal utilizada. Se você absolutamente deve usareval() , considere usar a nova Function ().

Há um pequeno benefício em potencial porque o código avaliado em new Function () será executado em um escopo de função local, portanto, quaisquer variáveis ​​definidas com var no código que está sendo avaliado não se tornarão globais automaticamente.

Outra maneira de impedir globals automáticos é envolver a eval()chamada em uma função imediata.

12345678
fonte
Você pode sugerir como eu posso avaliar um nome de variável dinâmica local da função sem avaliação? As funções eval (e similares) são os últimos recursos na maioria dos idiomas que as contêm, mas às vezes são necessárias. No caso de obter o nome de uma variável dinâmica, existe alguma solução mais segura? De qualquer forma, o próprio javascript não é para segurança real (o lado do servidor é obviamente a principal defesa). Se você estiver interessado, aqui está o meu caso de uso do eval, que eu adoraria mudar: stackoverflow.com/a/48294208
Regular Joe
2

Além dos possíveis problemas de segurança, se você estiver executando um código enviado pelo usuário, na maioria das vezes há uma maneira melhor que não envolve a análise do código toda vez que ele é executado. Funções anônimas ou propriedades de objetos podem substituir a maioria dos usos de avaliação e são muito mais seguras e rápidas.

Matthew Crumley
fonte
2

Isso pode se tornar mais um problema, pois a próxima geração de navegadores sai com algum sabor de um compilador JavaScript. O código executado através do Eval pode não ter um desempenho tão bom quanto o restante do JavaScript nesses navegadores mais recentes. Alguém deve fazer alguns perfis.

Brian
fonte
2

Este é um dos bons artigos falando sobre eval e como ele não é um mal: http://www.nczonline.net/blog/2013/06/25/eval-isnt-evil-just-misunderstood/

Não estou dizendo que você deve sair correndo e começar a usar eval () em todos os lugares. De fato, existem muito poucos casos de uso bons para executar eval (). Definitivamente, existem preocupações com a clareza do código, a depuração e certamente o desempenho que não deve ser negligenciado. Mas você não deve ter medo de usá-lo quando tiver um caso em que eval () faça sentido. Tente não usá-lo primeiro, mas não deixe que ninguém o assuste pensando que seu código é mais frágil ou menos seguro quando eval () for usado adequadamente.

Amr Elgarhy
fonte
2

eval () é muito poderoso e pode ser usado para executar uma instrução JS ou avaliar uma expressão. Mas a questão não é sobre o uso de eval (), mas vamos apenas dizer como a string que você está executando com eval () é afetada por uma parte mal-intencionada. No final, você estará executando um código malicioso. Com poder vem uma grande responsabilidade. Portanto, use-o com sabedoria se você estiver usando. Isso não está muito relacionado à função eval (), mas este artigo tem informações muito boas: http://blogs.popart.com/2009/07/javascript-injection-attacks/ Se você está procurando os conceitos básicos de eval () veja aqui: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval

Phi
fonte
2

O JavaScript Engine possui diversas otimizações de desempenho que são executadas durante a fase de compilação. Algumas delas se resumem a ser capaz de analisar estaticamente o código conforme ele é lexical e determinar previamente onde estão todas as declarações de variáveis ​​e funções, para que seja necessário menos esforço para resolver identificadores durante a execução.

Mas se o Mecanismo encontrar um eval (..) no código, ele deve essencialmente assumir que toda a sua percepção da localização do identificador pode ser inválida, porque não pode saber no momento do lexing exatamente qual código você pode passar para o eval (..) para modificar o escopo lexical ou o conteúdo do objeto ao qual você pode passar para criar um novo escopo lexical a ser consultado.

Em outras palavras, no sentido pessimista, a maioria dessas otimizações seria inútil se eval (..) estivesse presente; portanto, simplesmente não realiza as otimizações.

Isso explica tudo.

Referência:

https://github.com/getify/You-Dont-Know-JS/blob/master/scope%20&%20closures/ch2.md#eval

https://github.com/getify/You-Dont-Know-JS/blob/master/scope%20&%20closures/ch2.md#performance

hkasera
fonte
Nenhum mecanismo javascript não pode encontrar e avaliar no código com 100% de garantia. Portanto, ele deve estar pronto para isso a qualquer momento.
Jack Giffin
2

Nem sempre é uma má ideia. Tomemos, por exemplo, geração de código. Recentemente, escrevi uma biblioteca chamada Hyperbars, que preenche a lacuna entre o virtual-dom e o guidão . Isso é feito analisando um modelo de guidão e convertendo-o em hiperescrito, que é posteriormente usado pelo virtual-dom. O hiperescrito é gerado como uma string primeiro e, antes de devolvê-lo, eval()transforma-o em código executável. Eu encontrei eval()nessa situação em particular o exato oposto do mal.

Basicamente de

<div>
    {{#each names}}
        <span>{{this}}</span>
    {{/each}}
</div>

Para isso

(function (state) {
    var Runtime = Hyperbars.Runtime;
    var context = state;
    return h('div', {}, [Runtime.each(context['names'], context, function (context, parent, options) {
        return [h('span', {}, [options['@index'], context])]
    })])
}.bind({}))

O desempenho de eval()não é um problema em uma situação como essa, porque você só precisa interpretar a sequência gerada uma vez e, em seguida, reutilizar a saída executável várias vezes.

Você pode ver como a geração de código foi alcançada se você estiver curioso aqui .

Wikened
fonte
2

Eu diria que isso realmente não importa se você usa eval()javascript que é executado em navegadores. * (Ressalva)

Todos os navegadores modernos têm um console de desenvolvedor onde você pode executar javascript arbitrário de qualquer maneira e qualquer desenvolvedor semi-inteligente pode examinar sua fonte JS e colocar os bits necessários no console de desenvolvimento para fazer o que quiser.

* Desde que os pontos de extremidade do servidor tenham a validação e higienização corretas dos valores fornecidos pelo usuário, não importa o que é analisado e avaliado no javascript do lado do cliente.

eval()No entanto, se você perguntar se é adequado usar no PHP, a resposta é NÃO , a menos que você coloque na lista branca quaisquer valores que possam ser passados ​​para sua declaração de avaliação.

Adam Copley
fonte
além de haver um console de desenvolvedor, você também pode digitar javascript: code na barra de URL para criar seu próprio console de desenvolvedor na página, se não houver, como é o caso de navegadores e dispositivos móveis antigos do IE.
Dmitry
1

Não tentarei refutar nada do que foi dito até agora, mas vou oferecer esse uso de eval () que (tanto quanto eu sei) não pode ser feito de outra maneira. Provavelmente existem outras maneiras de codificar isso, e provavelmente maneiras de otimizá-lo, mas isso é feito à mão e sem sinos e assobios, para fins de clareza, para ilustrar o uso de eval que realmente não tem outras alternativas. Ou seja: nomes de objetos dinâmicos (ou mais precisamente) criados por programa (em oposição a valores).

//Place this in a common/global JS lib:
var NS = function(namespace){
    var namespaceParts = String(namespace).split(".");
    var namespaceToTest = "";
    for(var i = 0; i < namespaceParts.length; i++){
        if(i === 0){
            namespaceToTest = namespaceParts[i];
        }
        else{
            namespaceToTest = namespaceToTest + "." + namespaceParts[i];
        }

        if(eval('typeof ' + namespaceToTest) === "undefined"){
            eval(namespaceToTest + ' = {}');
        }
    }
    return eval(namespace);
}


//Then, use this in your class definition libs:
NS('Root.Namespace').Class = function(settings){
  //Class constructor code here
}
//some generic method:
Root.Namespace.Class.prototype.Method = function(args){
    //Code goes here
    //this.MyOtherMethod("foo"));  // => "foo"
    return true;
}


//Then, in your applications, use this to instantiate an instance of your class:
var anInstanceOfClass = new Root.Namespace.Class(settings);

EDIT: a propósito, eu não sugeriria (por todas as razões de segurança apontadas até agora) que você baseie seus nomes de objetos na entrada do usuário. Não consigo imaginar nenhuma boa razão para você querer fazer isso. Ainda assim, pensei em ressaltar que não seria uma boa ideia :)

Carnix
fonte
3
isso pode ser feito com namespaceToTest[namespaceParts[i]], não há necessidade de eval aqui, então a if(typeof namespaceToTest[namespaceParts[i]] === 'undefined') { namespaceToTest[namespaceParts[i]] = {};única diferença para oelse namespaceToTest = namespaceToTest[namespaceParts[i]];
user2144406
1

Coleta de lixo

A coleta de lixo dos navegadores não tem idéia se o código avaliado pode ser removido da memória, mantendo-o armazenado até que a página seja recarregada. Não é tão ruim se seus usuários estão apenas na sua página em breve, mas pode ser um problema para os aplicativos da web.

Aqui está um script para demonstrar o problema

https://jsfiddle.net/CynderRnAsh/qux1osnw/

document.getElementById("evalLeak").onclick = (e) => {
  for(let x = 0; x < 100; x++) {
    eval(x.toString());
  }
};

Algo tão simples quanto o código acima faz com que uma pequena quantidade de memória seja armazenada até que o aplicativo morra. Isso é pior quando o script avaliado é uma função gigante e é chamado em intervalo.

JD
fonte