Esegue il codice JavaScript archiviato come stringa

Come eseguo JavaScript che è una stringa?

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

Con la eval("my script here")funzione.

Puoi eseguirlo usando una funzione. Esempio:

var theInstructions = "alert('Hello World'); var x = 100";

var F=new Function (theInstructions);

return(F());

La evalfunzione valuterà una stringa che le viene passata.

Ma l'uso di evalpuò essere pericoloso , quindi usalo con cautela.

Modifica: annakata ha un buon punto - Non solo è eval pericoloso , è lento . Questo perché il codice da valutare deve essere analizzato sul posto, in modo da richiedere alcune risorse di elaborazione.

Usa eval ().

W3 Schools tour of eval . Il sito ha alcuni esempi utilizzabili di eval.La documentazione di Mozilla tratta questo in dettaglio.

Probabilmente riceverai molti avvisi sull'utilizzo sicuro di questo. NON consentire agli utenti di iniettare NIENTE in eval () poiché si tratta di un enorme problema di sicurezza.

Ti consigliamo anche di sapere che eval () ha un ambito diverso .

Prova questo:

  var script = "<script type='text/javascript'> content </script>";
  //using jquery next
  $('body').append(script);//incorporates and executes inmediatelly

Personalmente, non l'ho provato ma sembra funzionare.

Un po 'come quello di @Hossein Hajizadeh detto alerady, anche se in modo più dettagliato:

C'è un'alternativa a eval() .

La funzione setTimeout() è progettata per eseguire qualcosa dopo un intervallo di millisecondi e il codice da eseguire in questo modo sembra essere formattato come una stringa.

Funzionerebbe così:

ExecuteJavascriptString(); //Just for running it

function ExecuteJavascriptString()
{
    var s = "alert('hello')";
    setTimeout(s, 1);
}

1 significa che attenderà 1 millisecondo prima di eseguire la stringa.

Potrebbe non essere il modo più corretto per farlo, ma funziona.

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

Penso che questo sia il modo migliore.

Usa eval come di seguito. Eval dovrebbe essere usato con cautela, una semplice ricerca su " eval is evil " dovrebbe dare alcuni suggerimenti.

function ExecuteJavascriptString()
{
    var s = "alert('hello')";
    eval(s);
}

Controllato questo su molti script complessi e offuscati:

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

Se si desidera eseguire un comando specifico (ovvero stringa) dopo un tempo specifico - cmd = il codice - InterVal = ritardo per l'esecuzione

 function ExecStr(cmd, InterVal) {
    try {
        setTimeout(function () {
            var F = new Function(cmd);
            return (F());
        }, InterVal);
    } catch (e) { }
}
//sample
ExecStr("alert(20)",500);

Per gli utenti che utilizzano il nodo e che si occupano delle implicazioni di contesto delle eval()offerte nodejs vm. Crea una macchina virtuale V8 in grado di eseguire il sandbox dell'esecuzione del codice in un contesto separato.

Fare un ulteriore passo avanti è quello vm2che indurisce vmconsentendo a vm di eseguire codice non attendibile.

• https://nodejs.org/api/vm.html - Nodojs / vm ufficiale

• https://github.com/patriksimek/vm2 - Vm2 esteso

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

Ma questo può essere pericoloso se stai prendendo i dati dagli utenti, anche se suppongo che il loro problema sia l'arresto anomalo del proprio browser.

Non sono sicuro se questo è barare 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

New Function e apply () insieme funzionano anche

var a=new Function('alert(1);')
a.apply(null)

Stavo rispondendo a una domanda simile e ho avuto ancora un'altra idea su come raggiungere questo obiettivo senza usare eval():

const source = "alert('test')";
const el = document.createElement("script");
el.src = URL.createObjectURL(new Blob([source], { type: 'text/javascript' }));
document.head.appendChild(el);

Nel codice sopra puoi fondamentalmente creare BLOB, contenente il tuo script, al fine di creare l'URL oggetto (rappresentazione di oggetto File o BLOB nella memoria del browser). Poiché hai la srcproprietà sul <script>tag, lo script verrà eseguito come se fosse caricato da qualsiasi altro 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 dovrebbe farlo.

eval(s);

eval(s);

Ricorda, però, che Eval è molto potente e abbastanza pericoloso. È meglio essere sicuri che lo script che si sta eseguendo sia sicuro e inamovibile dagli utenti.

Si possono usare i mathjs

Snippet dal link sopra:

// 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è qualsiasi oggetto. Pertanto, se si passa l'ambito globale alla funzione di valutazione, potrebbe essere possibile eseguire alert () in modo dinamico.

Anche mathjs è un'opzione molto migliore di eval () perché funziona in un sandbox.

Un utente potrebbe provare a iniettare codice JavaScript dannoso tramite il parser di espressioni. Il parser di espressioni di mathjs offre un ambiente sandbox per eseguire espressioni che dovrebbero renderlo impossibile. È possibile tuttavia che vi siano vulnerabilità di sicurezza sconosciute, quindi è importante fare attenzione, soprattutto quando si consente l'esecuzione lato server di espressioni arbitrarie.

Le versioni più recenti di mathjs non usano eval () o Function ().

Il parser impedisce attivamente l'accesso all'eval interno di JavaScripts e alla nuova funzione che sono la causa principale degli attacchi alla sicurezza. Le versioni 4 e successive di Mathjs non utilizzano il codice JavaScript sotto il cofano. La versione 3 e precedenti hanno usato eval per la fase di compilazione. Questo non è direttamente un problema di sicurezza ma si traduce in una superficie di attacco possibile più ampia.

L'uso di eval e la creazione di una nuova funzione per eseguire javascript comporta molti rischi per la sicurezza.

const script = document.createElement("script");
const stringJquery = '$("#button").on("click", function() {console.log("hit")})';
script.text = stringJquery;
document.body.appendChild(script);

Preferisco questo metodo per eseguire il Javascript che ricevo come stringa.