0

我正在开发一个允许用户提交的带有嵌入 JavaScript 代码的网页的应用程序。

我想通过构建常见 JavaScript 内在函数（内置对象）的映射来了解更多关于我的用户如何编写他们的 JavaScript 代码的信息，该映射显示用户生成的代码中每个内在函数的出现。

假设我有一个来自用户网页的 JS 文件：

主.js

for (let i = 0; i < 10; i++) { myArrs.push(new Array()); }
let myObj = new Object();

我想要一个可以生成以下输出的脚本：

Array: 10
Object: 1

我尝试使用正则表达式和字符串遍历来做到这一点，但这并没有考虑到在迭代中使用项目的情况。简单的字符串遍历会给我带来：

Array: 1
Object: 1

这是不正确的。

Esprima 似乎为此提供了一个解决方案，因为它可以执行语法分析，因为它是一个 JS 解析器。我试图用来esprima.parseScript(input, config, delegate)生成一棵树而不是遍历树，但输出仍然没有考虑迭代。

这是我尝试使用 Esprima 解析此信息的输出：

{
    "type": "Program",
    "body": [
        {
            "type": "ForStatement",
            "init": {
                "type": "VariableDeclaration",
                "declarations": [
                    {
                        "type": "VariableDeclarator",
                        "id": {
                            "type": "Identifier",
                            "name": "i"
                        },
                        "init": {
                            "type": "Literal",
                            "value": 0,
                            "raw": "0"
                        }
                    }
                ],
                "kind": "let"
            },
            "test": {
                "type": "BinaryExpression",
                "operator": "<",
                "left": {
                    "type": "Identifier",
                    "name": "i"
                },
                "right": {
                    "type": "Literal",
                    "value": 10,
                    "raw": "10"
                }
            },
            "update": {
                "type": "UpdateExpression",
                "operator": "++",
                "argument": {
                    "type": "Identifier",
                    "name": "i"
                },
                "prefix": false
            },
            "body": {
                "type": "BlockStatement",
                "body": [
                    {
                        "type": "ExpressionStatement",
                        "expression": {
                            "type": "CallExpression",
                            "callee": {
                                "type": "MemberExpression",
                                "computed": false,
                                "object": {
                                    "type": "Identifier",
                                    "name": "myArrs"
                                },
                                "property": {
                                    "type": "Identifier",
                                    "name": "push"
                                }
                            },
                            "arguments": [
                                {
                                    "type": "NewExpression",
                                    "callee": {
                                        "type": "Identifier",
                                        "name": "Array"
                                    },
                                    "arguments": []
                                }
                            ]
                        }
                    }
                ]
            }
        },
        {
            "type": "VariableDeclaration",
            "declarations": [
                {
                    "type": "VariableDeclarator",
                    "id": {
                        "type": "Identifier",
                        "name": "myObj"
                    },
                    "init": {
                        "type": "NewExpression",
                        "callee": {
                            "type": "Identifier",
                            "name": "Object"
                        },
                        "arguments": []
                    }
                }
            ],
            "kind": "let"
        }
    ],
    "sourceType": "script"
}

我已经无法在 SO 上找到这个答案 - 这似乎是一个需要解决的有用问题，但需要对 Esprima 等词法分析工具有一些了解。

4

0 回答 0