Exécuter le code JavaScript stocké sous forme de chaîne

Comment exécuter du JavaScript qui est une chaîne?

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

Avec eval("my script here")fonction.

Vous pouvez l'exécuter à l'aide d'une fonction. Exemple:

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

var F=new Function (theInstructions);

return(F());

La evalfonction évaluera une chaîne qui lui est passée.

Mais l'utilisation de evalpeut être dangereuse , alors utilisez-la avec prudence.

Edit: annakata a un bon point - Non seulement est eval dangereux , il est lent . En effet, le code à évaluer doit être analysé sur place, ce qui nécessitera des ressources informatiques.

Utilisez eval ().

Visite des écoles W3 d'Eval . Le site a quelques exemples utilisables de eval. La documentation de Mozilla couvre cela en détail.

Vous recevrez probablement de nombreux avertissements concernant son utilisation en toute sécurité. N'autorisez PAS les utilisateurs à injecter RIEN dans eval () car c'est un énorme problème de sécurité.

Vous voudrez également savoir que eval () a une portée différente .

Essaye ça:

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

Personnellement, je ne l'ai pas testé mais semble fonctionner.

Un peu comme ce que disait @Hossein Hajizadeh alerady, mais plus en détail:

Il existe une alternative à eval().

La fonction setTimeout() est conçue pour exécuter quelque chose après un intervalle de millisecondes, et le code à exécuter se trouve être formaté sous forme de chaîne.

Cela fonctionnerait comme ceci:

ExecuteJavascriptString(); //Just for running it

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

1 signifie qu'il attendra 1 milliseconde avant d'exécuter la chaîne.

Ce n'est peut-être pas la manière la plus correcte de le faire, mais cela fonctionne.

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

Je pense que c'est la meilleure façon.

Utilisez eval comme ci-dessous. Eval doit être utilisé avec précaution, une simple recherche sur " eval is evil " devrait lancer quelques pointeurs.

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

Vérifié cela sur de nombreux scripts complexes et obscurcis:

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 vous souhaitez exécuter une commande spécifique (c'est-à-dire une chaîne) après un temps spécifique - cmd = votre code - InterVal = délai d'exécution

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

Pour les utilisateurs qui utilisent node et qui sont concernés par les implications contextuelles des eval()offres nodejs vm. Il crée une machine virtuelle V8 qui peut sandbox l'exécution de votre code dans un contexte distinct.

Pousser les choses un peu plus loin est vm2ce qui renforce vmpermettant à la VM d'exécuter du code non approuvé.

• https://nodejs.org/api/vm.html - nodejs / vm officiel

• https://github.com/patriksimek/vm2 - Vm2 étendu

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

Mais cela peut être dangereux si vous prenez des données d'utilisateurs, bien que je suppose que s'ils plantent leur propre navigateur, c'est leur problème.

Je ne sais pas si c'est de la triche ou non:

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

La nouvelle fonction et apply () fonctionnent ensemble aussi

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

Je répondais à une question similaire et j'ai eu encore une autre idée comment y parvenir sans utiliser eval():

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

Dans le code ci-dessus, vous créez essentiellement un Blob, contenant votre script, afin de créer une URL d'objet (représentation de l'objet File ou Blob dans la mémoire du navigateur). Puisque vous avez une srcpropriété sur la <script>balise, le script sera exécuté de la même manière que s'il avait été chargé depuis n'importe quelle autre 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 devrait le faire.

eval(s);

eval(s);

Rappelez-vous cependant que cette évaluation est très puissante et peu sûre. Il vaut mieux être sûr que le script que vous exécutez est sûr et non modifiable par les utilisateurs.

On peut utiliser mathjs

Extrait du lien ci-dessus:

// 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                                

scopeest n'importe quel objet. Donc, si vous passez la portée globale à la fonction evalute, vous pourrez peut-être exécuter alert () dynamiquement.

Mathjs est également une bien meilleure option que eval () car il fonctionne dans un bac à sable.

Un utilisateur peut essayer d'injecter du code JavaScript malveillant via l'analyseur d'expression. L'analyseur d'expression de mathjs offre un environnement sandbox pour exécuter des expressions qui devraient rendre cela impossible. Il est possible cependant qu'il existe des vulnérabilités de sécurité inconnues, il est donc important d'être prudent, en particulier lorsque vous autorisez l'exécution côté serveur d'expressions arbitraires.

Les nouvelles versions de mathjs n'utilisent ni eval () ni Function ().

L'analyseur empêche activement l'accès à l'évaluation interne de JavaScripts et à la nouvelle fonction, qui sont la principale cause d'attaques de sécurité. Les versions 4 et plus récentes de Mathjs n'utilisent pas l'évaluation de JavaScript sous le capot. Les versions 3 et antérieures utilisaient eval pour l'étape de compilation. Ce n'est pas directement un problème de sécurité, mais il en résulte une plus grande surface d'attaque possible.

Utiliser à la fois eval et créer une nouvelle fonction pour exécuter javascript comporte de nombreux risques de sécurité.

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

Je préfère cette méthode pour exécuter le Javascript que je reçois sous forme de chaîne.