Ejecuta código JavaScript almacenado como una cadena

¿Cómo ejecuto un JavaScript que es una cadena?

function ExecuteJavascriptString()
{
    var s = "alert('hello')";
    // how do I get a browser to alert('hello')?
}

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

La evalfunción evaluará una cadena que se le pasa.

Pero el uso de evalpuede 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.

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 .

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.

new Function('alert("Hello")')();

Creo que esta es la mejor manera.

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

Comprueba esto en muchos scripts complejos y ofuscados:

var js = "alert('Hello, World!');" // put your JS code here
var oScript = document.createElement("script");
var oScriptText = document.createTextNode(js);
oScript.appendChild(oScriptText);
document.body.appendChild(oScript);

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

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 vm2que endurece vmpermitiendo 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.

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)

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 srcpropiedad en la <script>etiqueta, el script se ejecutará de la misma manera que si se cargara desde cualquier otra URL.

function executeScript(source) {
    var script = document.createElement("script");
    script.onload = script.onerror = function(){ this.remove(); };
    script.src = "data:text/plain;base64," + btoa(source);
    document.body.appendChild(script);
}

executeScript("alert('Hello, World!');");

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                                

scopeEs 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.