Question

我知道很多人都认为“eval是邪恶的”，但是我必须完成某些事情，而且我没有找到如何在没有eval（）的情况下做到这一点。

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

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

如果我eval（）这个，我可以解析foo ['KEY']并完成它。在没有eval（）的情况下我能想到的唯一方法就是使用一堆烦人的替换（），这似乎不太好。我错过了一些明显的方法吗？大多数“你不必使用eval（）”替代方案，我通常认为我可以完全控制所有内容，但在这种情况下，我必须解决这个现有代码。

编辑：我应该补充说，这段代码是通过代理脚本（跨域内容）的AJAX调用获得的，因此没有任何变量可以访问。如果他们是，我显然只能解析foo ['KEY']并且快乐。

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

Answer 1

外部代码更好地发回有效的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。没有评估，如果失败，它只会忽略无效块。成功？好的，它将返回它找到的有效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...
    }
}

Live test case，使用示例代码的固定版本。

Answer 2

使用eval的一个更安全的替代方法是创建new Function并将其传递给字符串函数体。这样（除非某些内容明确地访问了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建议在documentation for eval中执行的操作：

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

Answer 3

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

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

Answer 4

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

window["fooFunction"](foo)

有没有办法在不使用eval（）的情况下操作包含的JS？

4 个答案: