有没有办法在没有 eval(） 的情况下操作包含的 JS

Is there a way to manipulate included JS without eval()?

本文关键字：情况下 操作包 JS eval 有没有      更新时间：2023-09-26

我知道很多人认为"eval 是邪恶的"，但我必须完成一些事情，而且我很难弄清楚如何在没有 eval（） 的情况下做到这一点。

情况是这样的：一个外部文件（我无法控制它 - 编辑：但它不是用户生成的。它来自一个值得信赖的来源！我想这很重要）是吐出JavaScript供我使用。这个JavaScript包含一些不错的JSON数据（这是我需要得到的），但它的两侧是普通的JavaScript语句，声明变量和调用函数等。它看起来有点像这样：

var foo = new Object();
foo['KEY'] = {Field1: 'Value1', Field2: 'Value2'};
eval('fooFunction(foo)');

如果我 eval（） 这个，我可以解析 foo['KEY'] 并完成它。我能想到的没有 eval（） 的唯一方法是使用一堆烦人的 replace（）ments，这似乎几乎没有更好。我是否缺少一些明显的方法来做到这一点？我通常看到的大多数"您不必使用 eval（）"替代方案都假设我可以完全控制一切，但在这种情况下，我必须绕过这个现有的代码。

编辑：我应该补充一点，这段代码是通过代理脚本（跨域的东西）的AJAX调用获得的，所以没有一个变量是可访问的。如果是这样，我显然只能解析 foo['KEY'] 并快乐。

第二次编辑：还没有结论！我危险地接近得出结论，eval（）是要走的路。你能忍受这个结果吗？我即将屈服于邪恶（）。有人阻止我，因为这看起来是唯一的方法。

外部代码最好发回有效的 JSON。示例中的值不是有效的 JSON，因为键必须用双引号括起来。

我想出了一个小的纯JavaScript解析器，它可以通过自己添加双引号来处理简单的无效JSON。它目前不支持非字符串值。

function ParseRawJSON(rawCode) {
    var arrCandidates = [];
    var lastOpenBracketIndex = -1;
    for (var i = 0; i < rawCode.length; i++) {
        var curChar = rawCode.charAt(i);
        if (curChar === "}") {
            if (lastOpenBracketIndex >= 0) {
                arrCandidates.push(rawCode.substr(lastOpenBracketIndex, i - lastOpenBracketIndex + 1));
                lastOpenBracketIndex = -1;
            }
        } else if (curChar === "{") {
            lastOpenBracketIndex = i;
        }
    }
    var arrJsonObjects = [];
    for (var i = 0; i < arrCandidates.length; i++) {
        var currentJSON = null;
        try {
            currentJSON = JSON.parse(arrCandidates[i]);
        } catch (e) {
            //try fixing
            var fixedCandidate = TryFixJSON(arrCandidates[i]);
            if (fixedCandidate) {
                try {
                    currentJSON = JSON.parse(fixedCandidate);
                } catch (e) {
                    currentJSON = null;
                }
            }
        }
        if (currentJSON != null) {
            var keys = [];
            for (var key in currentJSON)
                keys.push(key);
            if (keys.length > 0)
                arrJsonObjects.push(currentJSON);
        }
    }
    return arrJsonObjects;
    function Trim(s, c) {
        if (c instanceof Array) {
            for (var i = 0; i < c.length; i++)
                s = Trim(s, c[i]);
            return s;
        }
        if (typeof c === "undefined")
            c = " ";
        while (s.length > 0 && s.charAt(0) === c)
            s = s.substr(1, s.length - 1);
        while (s.length > 0 && s.charAt(s.length - 1) === c)
            s = s.substr(0, s.length - 1);
        return s;
    }
    function TryFixJSON(strBlock) {
        if (strBlock.indexOf(":") <= 0)
            return false;
        strBlock = strBlock.replace("{", "").replace("}", "");
        var mainParts = strBlock.split(",");
        for (var i = 0; i < mainParts.length; i++) {
            var currentPart = Trim(mainParts[i]);
            if (currentPart.indexOf(":") <= 0)
                return false;
            var subParts = currentPart.split(":");
            if (subParts.length !== 2)
                return false;
            var currentKey = Trim(subParts[0], [" ", "'", "'""]);
            var currentValue = Trim(subParts[1], [" ", "'", "'""]);
            if (currentKey.length === 0)
                return false;
            subParts[0] = "'"" + currentKey + "'"";
            subParts[1] = "'"" + currentValue + "'"";
            mainParts[i] = subParts.join(":");
        }
        return "{" + mainParts.join(", ") + "}";
    }
}

这将只查找 { 和 } 之间的任何内容，并尝试解析为 JSON。没有 eval，如果失败，它只会忽略无效块。成功？太好了，它将返回它找到的有效 JSON 的纯数组。

使用示例：

var rawCode = "var foo = new Object(); { dummy here }}} function boo() {}" + 
"foo['KEY'] = { '"Field1'": '"Value1'", '"Field2'": '"Value2'"}; hello {'"foo'": '"bar'"} and it's over ";
var jsonObjects = ParseRawJSON(rawCode);
for (var i = 0; i < jsonObjects.length; i++) {
    for (var key in jsonObjects[i]) {
        var value = jsonObjects[i][key];
        //got key and value...
    }
}

实时测试用例，使用示例代码的固定版本。

使用

eval 通常更安全的替代方法是创建一个新函数并向其传递字符串函数体。这样（除非某些东西显式访问window对象），您将无法访问全局作用域，并且可以将其封装在函数作用域中。

假设示例代码的前两行是您要评估的 JavaScript，如果您知道要作为 JSON 对象检索的变量的名称，您可以在创建的函数末尾返回它，然后调用它：

var js = "var foo = {}; foo['KEY'] = {Field1: 'Value1', Field2: 'Value2'};";
var fn = new Function(js + ';return foo;');
var result = fn();
console.log(JSON.stringify(result));

这也是 MDN 在 eval 文档中建议做的事情：

更重要的是，第三方代码可以看到调用 eval（） 的范围，这可能导致可能的攻击，而类似的函数不容易受到攻击。

如果 JSON 只包含数据而不是函数，您可以使用JSON.parse()

有关更多详细信息，请参阅 https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse。

由于该方法已放入全局，因此您可以执行

window["fooFunction"](foo)
相关文章：