Respuestas:
Con eval("my script here")
funcion.
Puedes ejecutarlo usando una función. Ejemplo:
var theInstructions = "alert('Hello World'); var x = 100";
var F=new Function (theInstructions);
return(F());
var F=function(){eval(theInstructions);};
?
new Function("alert('Hello World');")()
La eval
función evaluará una cadena que se le pasa.
Pero el uso de eval
puede ser peligroso , así que úselo con precaución.
Editar: annakata tiene un buen punto: no solo es eval
peligroso , es lento . Esto se debe a que el código a evaluar debe analizarse en el acto, por lo que se necesitarán algunos recursos informáticos.
eval()
es peligroso. ¿Hay alguna alternativa?
Usa eval ().
Visita a las escuelas W3 de eval . El sitio tiene algunos ejemplos utilizables de eval. La documentación de Mozilla cubre esto en detalle.
Probablemente recibirá muchas advertencias sobre el uso seguro de esto. NO permita que los usuarios inyecten NADA en eval () ya que es un gran problema de seguridad.
También querrá saber que eval () tiene un alcance diferente .
eval
mejor que ese artículo de W3Schools. Algo legible con una buena explicación y ejemplos sería developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… . Y no, no estoy bjorninge
Prueba esto:
var script = "<script type='text/javascript'> content </script>";
//using jquery next
$('body').append(script);//incorporates and executes inmediatelly
Personalmente, no lo probé pero parece funcionar.
Un poco como lo que dijo @Hossein Hajizadeh alerady, aunque con más detalle:
Hay una alternativa a eval()
.
La función setTimeout()
está diseñada para ejecutar algo después de un intervalo de milisegundos, y el código que se ejecutará está formateado como una cadena.
Funcionaría así:
ExecuteJavascriptString(); //Just for running it
function ExecuteJavascriptString()
{
var s = "alert('hello')";
setTimeout(s, 1);
}
1
significa que esperará 1 milisegundo antes de ejecutar la cadena.
Puede que no sea la forma más correcta de hacerlo, pero funciona.
setTimeout
? Tenga en cuenta que en cualquier caso hará que la ejecución sea asíncrona. Significa que todo el código que sigue a la setTimeout
llamada se invocará antes de que el código pase setTimeout
(incluso si se llama con 0 (cero)).
Use eval como a continuación. Eval debe usarse con precaución, una simple búsqueda sobre " eval is evil " debería arrojar algunos indicadores.
function ExecuteJavascriptString()
{
var s = "alert('hello')";
eval(s);
}
Si desea ejecutar un comando específico (que es una cadena) después de un tiempo específico - cmd = su código - InterVal = retraso para ejecutar
function ExecStr(cmd, InterVal) {
try {
setTimeout(function () {
var F = new Function(cmd);
return (F());
}, InterVal);
} catch (e) { }
}
//sample
ExecStr("alert(20)",500);
Val
en InterVal
mayúscula?
Para los usuarios que usan node y que están preocupados por las implicaciones de contexto de las eval()
ofertas de nodejs vm
. Crea una máquina virtual V8 que puede aislar la ejecución de su código en un contexto separado.
Llevar las cosas un paso más allá es lo vm2
que endurece vm
permitiendo que el vm ejecute código no confiable.
https://nodejs.org/api/vm.html - Nodojs / vm oficial
https://github.com/patriksimek/vm2 - Extended vm2
const vm = require('vm');
const x = 1;
const sandbox = { x: 2 };
vm.createContext(sandbox); // Contextify the sandbox.
const code = 'x += 40; var y = 17;';
// `x` and `y` are global variables in the sandboxed environment.
// Initially, x has the value 2 because that is the value of sandbox.x.
vm.runInContext(code, sandbox);
console.log(sandbox.x); // 42
console.log(sandbox.y); // 17
console.log(x); // 1; y is not defined.
eval(s);
Pero esto puede ser peligroso si está tomando datos de los usuarios, aunque supongo que si ellos bloquean su propio navegador ese es su problema.
eval
es el código de los usuarios, lo que podría, por ejemplo, permitir a los usuarios robar las cuentas de otros usuarios sin que lo sepan simplemente cargando la página.
No estoy seguro si esto es trampa o no:
window.say = function(a) { alert(a); };
var a = "say('hello')";
var p = /^([^(]*)\('([^']*)'\).*$/; // ["say('hello')","say","hello"]
var fn = window[p.exec(a)[1]]; // get function reference by name
if( typeof(fn) === "function")
fn.apply(null, [p.exec(a)[2]]); // call it with params
Nueva función y apply () juntos también funcionan
var a=new Function('alert(1);')
a.apply(null)
eval()
. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
Estaba respondiendo una pregunta similar y tuve otra idea de cómo lograr esto sin usar eval()
:
const source = "alert('test')";
const el = document.createElement("script");
el.src = URL.createObjectURL(new Blob([source], { type: 'text/javascript' }));
document.head.appendChild(el);
En el código anterior, básicamente crea Blob, que contiene su script, para crear la URL del objeto (representación del objeto File u Blob en la memoria del navegador). Como tiene una src
propiedad en la <script>
etiqueta, el script se ejecutará de la misma manera que si se cargara desde cualquier otra URL.
eval debería hacerlo.
eval(s);
eval(s);
Sin embargo, recuerde que eval es muy poderoso y bastante inseguro. Será mejor que esté seguro de que el script que está ejecutando es seguro e inmutable para los usuarios.
Uno puede usar mathjs
Fragmento del enlace anterior:
// evaluate expressions
math.evaluate('sqrt(3^2 + 4^2)') // 5
math.evaluate('sqrt(-4)') // 2i
math.evaluate('2 inch to cm') // 5.08 cm
math.evaluate('cos(45 deg)') // 0.7071067811865476
// provide a scope
let scope = {
a: 3,
b: 4
}
math.evaluate('a * b', scope) // 12
math.evaluate('c = 2.3 + 4.5', scope) // 6.8
scope.c
scope
Es cualquier objeto. Entonces, si pasa el alcance global a la función de evaluación, es posible que pueda ejecutar alert () dinámicamente.
También mathjs es una opción mucho mejor que eval () porque se ejecuta en un sandbox.
Un usuario podría intentar inyectar código JavaScript malicioso a través del analizador de expresiones. El analizador de expresiones de mathjs ofrece un entorno de espacio aislado para ejecutar expresiones que deberían hacer esto imposible. Sin embargo, es posible que existan vulnerabilidades de seguridad desconocidas, por lo que es importante tener cuidado, especialmente cuando se permite la ejecución de expresiones arbitrarias en el servidor.
Las versiones más recientes de mathjs no usan eval () o Function ().
El analizador impide activamente el acceso a la evaluación interna de JavaScripts y a la nueva función, que son la causa principal de los ataques de seguridad. Mathjs versiones 4 y posteriores no utilizan la evaluación de JavaScript bajo el capó. La versión 3 y anteriores usaban eval para el paso de compilación. Esto no es directamente un problema de seguridad, pero da como resultado una mayor superficie de ataque posible.
Usar tanto evaluar como crear una nueva Función para ejecutar javascript conlleva muchos riesgos de seguridad.
const script = document.createElement("script");
const stringJquery = '$("#button").on("click", function() {console.log("hit")})';
script.text = stringJquery;
document.body.appendChild(script);
Prefiero este método para ejecutar el Javascript que recibo como una cadena.