Question

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

我想了解更多关于我的用户如何编写JavaScript代码的信息，方法是构建一个常见的JavaScript内在函数（内置对象）的地图，该地图显示用户生成的代码中每个代码的出现。

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

Main.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的知识。

使用Esprima计算内在函数的出现次数

0 个答案: