精华内容
下载资源
问答
  • ast

    2020-05-26 11:20:22
    聊一聊 Javascript 中的 AST 百度百科是这么解释的: 在计算机科学中,抽象语法树(Abstract Syntax Tree,AST),或简称语法树(Syntax tree),是源代码语法结构的一种抽象表示。它以树状的形式表现编程语言的语法...

    聊一聊 Javascript 中的 AST

    百度百科是这么解释的:

    在计算机科学中,抽象语法树(Abstract Syntax Tree,AST),或简称语法树(Syntax tree),是源代码语法结构的一种抽象表示。它以树状的形式表现编程语言的语法结构,树上的每个节点都表示源代码中的一种结构。

    听起来还是很绕,没关系,你可以简单理解为 它就是你所写代码的的树状结构化表现形式

    有了这棵树,我们就可以通过操纵这颗树,精准的定位到声明语句、赋值语句、运算语句等等,实现对代码的分析、优化、变更等操作。

    AST在日常业务中也许很难涉及到,有可能你还没有听过,但其实很多时候你已经在使用它了,只是没有太多关注而已,现在流行的 webpackeslint 等很多插件或者包都有涉及~

    抽象语法树能做什么?

    聊到AST的用途,其应用非常广泛,下面我简单罗列了一些:

    • IDE的错误提示、代码格式化、代码高亮、代码自动补全等
    • JSLintJSHint对代码错误或风格的检查等
    • webpackrollup进行代码打包等
    • CoffeeScriptTypeScriptJSX等转化为原生Javascript

    其实它的用途,还不止这些,如果说你已经不满足于实现枯燥的业务功能,想写出类似reactvue这样的牛逼框架,或者想自己搞一套类似webpackrollup这样的前端自动化打包工具,那你就必须弄懂AST

    如何生成AST?

    在了解如何生成AST之前,有必要了解一下Parser(常见的Parseresprimatraceuracornshift等)

    JS Parser其实是一个解析器,它是将js源码转化为抽象语法树(AST)的解析器。

    整个解析过程主要分为以下两个步骤:

    • 分词:将整个代码字符串分割成最小语法单元数组
    • 语法分析:在分词基础上建立分析语法单元之间的关系

    什么是语法单元?

    语法单元是被解析语法当中具备实际意义的最小单元,简单的来理解就是自然语言中的词语。

    举个例子来说,下面这段话:

    “2019年是祖国70周年”

    我们可以把这句话拆分成最小单元,即:2019年、是、祖国、70、周年。

    这就是我们所说的分词,也是最小单元,因为如果我们把它再拆分出去的话,那就没有什么实际意义了。

    Javascript 代码中的语法单元主要包括以下这么几种:

    • 关键字:例如 varletconst
    • 标识符:没有被引号括起来的连续字符,可能是一个变量,也可能是 ifelse 这些关键字,又或者是 truefalse 这些内置常量
    • 运算符: +-*/
    • 数字:像十六进制,十进制,八进制以及科学表达式等语法
    • 字符串:因为对计算机而言,字符串的内容会参与计算或显示
    • 空格:连续的空格,换行,缩进等
    • 注释:行注释或块注释都是一个不可拆分的最小语法单元
    • 其他:大括号、小括号、分号、冒号等

    如果我们以最简单的复制语句为例的话,如下?

        var a = 1;
    

    通过分词,我们可以得到如下结果:

    [
        {
            "type": "Keyword",
            "value": "var"
        },
        {
            "type": "Identifier",
            "value": "a"
        },
        {
            "type": "Punctuator",
            "value": "="
        },
        {
            "type": "Numeric",
            "value": "1"
        },
        {
            "type": "Punctuator",
            "value": ";"
        }
    ]
    

    为了方便,我直接在 esprima/parser 这个网站生成分词的~

    什么是语法分析?

    上面我们已经得到了我们分词的结果,需要将词汇进行一个立体的组合,确定词语之间的关系,确定词语最终的表达含义。

    简单来说语法分析是对语句和表达式识别,确定之前的关系,这是个递归过程。

    上面我们通过语法分析,可以得到如下结果:

    {
        "type": "Program",
        "body": [
            {
                "type": "VariableDeclaration",
                "declarations": [
                    {
                        "type": "VariableDeclarator",
                        "id": {
                            "type": "Identifier",
                            "name": "a"
                        },
                        "init": {
                            "type": "Literal",
                            "value": 1,
                            "raw": "1"
                        }
                    }
                ],
                "kind": "var"
            }
        ],
        "sourceType": "script"
    }
    

    这就是 var a = 1 所转换的 AST

    这里推荐一下astexplorer AST的可视化工具,astexplorer,可以直接进行对代码进行AST转换~

    AST 到底怎么用?

    上面画了很大篇幅聊了聊AST是什么以及它是如何生成的,说到底,还是不知道AST这玩意有啥用,到底怎么使用。。

    ok~ 接下来我们来一起见证奇迹。

    我相信大部分同学对 babel 这个库不陌生,现在的做前端模块化开发过程中中一定少不了它,因为它可以帮你将 ECMAScript 2015+ 版本的代码转换为向后兼容的 JavaScript 语法,以便能够运行在当前和旧版本的浏览器或其他环境中,你不用为新语法的兼容性考虑~

    而实际上呢,babel 中的很多功能都是靠修改 AST 实现的。

    首先,我们来看一个简单的例子,我们如何将 es6 中的 箭头函数 转换成 es5 中的 普通函数,即:

    const sum=(a,b)=>a+b;
    

    我们如何将上面简单的 sum 箭头函数转换成下面的形式:

    const sum = function(a,b){
        return a+b;
    }
    

    想想看,有什么思路?

    如果说你不了解 AST 的话,这无疑是一个很困难的问题,根本无从下手,如果你了解 AST 的话,这将是一个非常 easy 的例子。

    接下来我们看看如何实现?

    安装依赖

    需要操作 AST 代码,这里,我们需要借助两个库,分别是 @babel/corebabel-types

    其中 @babel/corebabel 的核心库,用来实现核心转换引擎,babel-types 类型判断,用于生成AST零部件

    cd 到一个你喜欢的目录,通过 npm -y init 初始化操作后,通过 npm i @babel/core babel-types -D 安装依赖

    目标分析

    要进行转换之前,我们需要进行分析,首先我们先通过 astexplorer 查看目标代码跟我们现在的代码有什么区别。

    源代码的 AST 结构如下:

    // 源代码的 AST
    {
        "type": "Program",
        "start": 0,
        "end": 21,
        "body": [
            {
                "type": "VariableDeclaration",
                "start": 0,
                "end": 21,
                "declarations": [
                    {
                        "type": "VariableDeclarator",
                        "start": 6,
                        "end": 20,
                        "id": {
                            "type": "Identifier",
                            "start": 6,
                            "end": 9,
                            "name": "sum"
                        },
                        "init": {
                            "type": "ArrowFunctionExpression",
                            "start": 10,
                            "end": 20,
                            "id": null,
                            "expression": true,
                            "generator": false,
                            "async": false,
                            "params": [
                                {
                                    "type": "Identifier",
                                    "start": 11,
                                    "end": 12,
                                    "name": "a"
                                },
                                {
                                    "type": "Identifier",
                                    "start": 13,
                                    "end": 14,
                                    "name": "b"
                                }
                            ],
                            "body": {
                                "type": "BinaryExpression",
                                "start": 17,
                                "end": 20,
                                "left": {
                                    "type": "Identifier",
                                    "start": 17,
                                    "end": 18,
                                    "name": "a"
                                },
                                "operator": "+",
                                "right": {
                                    "type": "Identifier",
                                    "start": 19,
                                    "end": 20,
                                    "name": "b"
                                }
                            }
                        }
                    }
                ],
                "kind": "const"
            }
        ],
        "sourceType": "module"
    }
    

    目标代码的 AST 结构如下:

    // 目标代码的 `AST`
    {
        "type": "Program",
        "start": 0,
        "end": 48,
        "body": [
            {
                "type": "VariableDeclaration",
                "start": 0,
                "end": 48,
                "declarations": [
                    {
                        "type": "VariableDeclarator",
                        "start": 6,
                        "end": 47,
                        "id": {
                            "type": "Identifier",
                            "start": 6,
                            "end": 9,
                            "name": "sum"
                        },
                        "init": {
                            "type": "FunctionExpression",
                            "start": 12,
                            "end": 47,
                            "id": null,
                            "expression": false,
                            "generator": false,
                            "async": false,
                            "params": [
                                {
                                    "type": "Identifier",
                                    "start": 22,
                                    "end": 23,
                                    "name": "a"
                                },
                                {
                                    "type": "Identifier",
                                    "start": 25,
                                    "end": 26,
                                    "name": "b"
                                }
                            ],
                            "body": {
                                "type": "BlockStatement",
                                "start": 28,
                                "end": 47,
                                "body": [
                                    {
                                        "type": "ReturnStatement",
                                        "start": 32,
                                        "end": 45,
                                        "argument": {
                                            "type": "BinaryExpression",
                                            "start": 39,
                                            "end": 44,
                                            "left": {
                                                "type": "Identifier",
                                                "start": 39,
                                                "end": 40,
                                                "name": "a"
                                            },
                                            "operator": "+",
                                            "right": {
                                                "type": "Identifier",
                                                "start": 43,
                                                "end": 44,
                                                "name": "b"
                                            }
                                        }
                                    }
                                ]
                            }
                        }
                    }
                ],
                "kind": "const"
            }
        ],
        "sourceType": "module"
    }
    

    其中里面的 startend 我们不用在意,其只是为了标记其所在代码的位置。

    我们关心的是 body 里面的内容,通过对比,我们发现主要不同就在于 init 这一段,一个是 ArrowFunctionExpression , 另一个是 FunctionExpression , 我们只需要将 ArrowFunctionExpression 下的内容改造成跟 FunctionExpression 即可。

    小试牛刀

    我们建一个 arrow.js 的文件,引入上面的两个库,即

    //babel 核心库,用来实现核心转换引擎
    const babel = require('@babel/core')
    //类型判断,生成AST零部件
    const types = require('babel-types')
    

    //源代码
    const code = <span class="token keyword">const</span> sum<span class="token operator">=</span><span class="token punctuation">(</span>a<span class="token punctuation">,</span>b<span class="token punctuation">)</span><span class="token operator">=</span><span class="token operator">&gt;</span>a<span class="token operator">+</span>b<span class="token punctuation">;</span> //目标代码 const sum = function(a,b){ return a + b }

    这里我们需要用到 babel 中的 transform 方法,它可以将 js 代码转换成 AST ,过程中可以通过使用 pluginsAST 进行改造,最终生成新的 ASTjs 代码,其整个过程用网上一个比较贴切的图就是:

    关于 babel transform 详细用法,这里不多做讨论,感兴趣的话可以去官网了解~

    其主要用法如下:

    //transform方法转换code
    //babel先将代码转换成ast,然后进行遍历,最后输出code
    

    let result = babel.transform(code,{
    plugins:[
    {
    visitor
    }
    ]
    })

    其核心在于插件 visitor 的实现。

    它是一个插件对象,可以对特定类型的节点进行处理,这里我们需要处理的节点是ArrowFunctionExpression,它常见的配置方式有两种:

    一种是单一处理,结构如下,其中 path 代表当前遍历的路径 path.node 代表当前变量的节点

    let visitor = {
        ArrowFunctionExpression(path){
    
    }
    

    }

    另一种是用于输入和输出双向处理,结构如下,参数 node 表示当前遍历的节点

    let visitor = {
         ArrowFunctionExpression : {
            enter(node){
    
        },
        leave(node){
            
        }
    }
    

    }

    这里我们只需要处理一次,所以采用第一种方式。

    通过分析目标代码的 AST,我们发现,需要一个 FunctionExpression , 这时候我们就需要用到 babel-types ,它的作用就是帮助我们生产这些节点

    我们通过其 npm 包的文档查看,构建一个 FunctionExpression 需要的参数如下:

    functionExpression

    参照 AST 我们可以看到其 idnullparams 是原 ArrowFunctionExpression 中的 paramsbody 是一个blockStatement,我们也可以通过查看 babel-types 文档,用 t.blockStatement(body, directives) 来创建,依次类推,照猫画虎,最终得到的结果如下:

        //原 params
        let params = path.node.params;
        //创建一个blockStatement
        let blockStatement = types.blockStatement([
            types.returnStatement(types.binaryExpression(
                '+',
                types.identifier('a'),
                types.identifier('b')
            ))
        ]);
        //创建一个函数
        let func = types.functionExpression(null, params, blockStatement, false, false);
    

    最后通过 path.replaceWith(func); 将其替换即可;

    完成代码如下:

    //babel 核心库,用来实现核心转换引擎
    const babel = require('@babel/core')
    //类型判断,生成AST零部件
    const types = require('babel-types')
    

    //源代码
    const code = <span class="token keyword">const</span> sum<span class="token operator">=</span><span class="token punctuation">(</span>a<span class="token punctuation">,</span>b<span class="token punctuation">)</span><span class="token operator">=&gt;</span>a<span class="token operator">+</span>b<span class="token punctuation">;</span> //目标代码 const sum = function(a,b){ return a + b }

    //插件对象,可以对特定类型的节点进行处理
    let visitor = {
    //代表处理 ArrowFunctionExpression 节点
    ArrowFunctionExpression(path){
    let params = path.node.params;
    //创建一个blockStatement
    let blockStatement = types.blockStatement([
    types.returnStatement(types.binaryExpression(
    ‘+’,
    types.identifier(‘a’),
    types.identifier(‘b’)
    ))
    ]);
    //创建一个函数
    let func = types.functionExpression(null, params, blockStatement, false, false);
    //替换
    path.replaceWith(func);
    }
    }

    //transform方法转换code
    //babel先将代码转换成ast,然后进行遍历,最后输出code
    let result = babel.transform(code,{
    plugins:[
    {
    visitor
    }
    ]
    })

    console.log(result.code);

    执行代码,打印结果如下:

    result

    至此,我们的函数转换完成,达到预期效果。

    怎么样,有没有很神奇!!

    其实也没那么复杂,主要是要分析其 AST 的结构,只要弄懂我们需要干什么,那么放手去做就是~

    pass:细心的同学发现,上面的代码其实可以优化的,因为我们的 returnStatement 其实也是跟源代码的 returnStatement 是一致的,我们只需要拿来复用即可,因此上述的代码还可以改成下面这样:

        let blockStatement = types.blockStatement([
            types.returnStatement(path.node.body)
        ]);
    

    趁热打铁

    上面刚刚认识了如何使用 AST 进行代码改造,不妨趁热打铁,再来试试下面这个问题。

    如何将 es6 中的 class 改造成 es5function 形式~

    源代码

    // 源代码
    class Person {
      constructor(name) {
          this.name=name;
      }
      sayName() {
          return this.name;
      }
    }
    

    目标代码

    // 目标代码
    

    function Person(name) {
    this.name = name;
    }

    Person.prototype.getName = function () {
    return this.name;
    };

    有了上面的基础,照猫画虎即可,这里我将不在赘述,过程很重要,这里我仅粘贴核心的转换代码,以供参考。

    ClassDeclaration (path) {
        let node = path.node; //当前节点
        let id = node.id;   //节点id
        let methods = node.body.body; // 方法数组
        let constructorFunction = null; // 构造方法
        let functions = []; // 目标方法
    
    methods<span class="token punctuation">.</span><span class="token function">forEach</span><span class="token punctuation">(</span>method <span class="token operator">=&gt;</span> <span class="token punctuation">{</span>
        <span class="token comment">//如果是构造方法</span>
        <span class="token keyword">if</span> <span class="token punctuation">(</span> method<span class="token punctuation">.</span>kind <span class="token operator">==</span><span class="token operator">=</span> <span class="token string">'constructor'</span> <span class="token punctuation">)</span> <span class="token punctuation">{</span>
            constructorFunction <span class="token operator">=</span> types<span class="token punctuation">.</span><span class="token function">functionDeclaration</span><span class="token punctuation">(</span>id<span class="token punctuation">,</span> method<span class="token punctuation">.</span><span class="token keyword">params</span><span class="token punctuation">,</span> method<span class="token punctuation">.</span>body<span class="token punctuation">,</span> <span class="token keyword">false</span><span class="token punctuation">,</span> <span class="token keyword">false</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
            functions<span class="token punctuation">.</span><span class="token function">push</span><span class="token punctuation">(</span>constructorFunction<span class="token punctuation">)</span>
        <span class="token punctuation">}</span> <span class="token keyword">else</span> <span class="token punctuation">{</span>
            <span class="token comment">//普通方法</span>
            <span class="token keyword">let</span> memberExpression <span class="token operator">=</span> types<span class="token punctuation">.</span><span class="token function">memberExpression</span><span class="token punctuation">(</span>types<span class="token punctuation">.</span><span class="token function">memberExpression</span><span class="token punctuation">(</span>id<span class="token punctuation">,</span> types<span class="token punctuation">.</span><span class="token function">identifier</span><span class="token punctuation">(</span><span class="token string">'prototype'</span><span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token keyword">false</span><span class="token punctuation">)</span><span class="token punctuation">,</span> method<span class="token punctuation">.</span>key<span class="token punctuation">,</span> <span class="token keyword">false</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
            <span class="token keyword">let</span> functionExpression <span class="token operator">=</span> types<span class="token punctuation">.</span><span class="token function">functionExpression</span><span class="token punctuation">(</span><span class="token keyword">null</span><span class="token punctuation">,</span> method<span class="token punctuation">.</span><span class="token keyword">params</span><span class="token punctuation">,</span> method<span class="token punctuation">.</span>body<span class="token punctuation">,</span> <span class="token keyword">false</span><span class="token punctuation">,</span> <span class="token keyword">false</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
            <span class="token keyword">let</span> assignmentExpression <span class="token operator">=</span> types<span class="token punctuation">.</span><span class="token function">assignmentExpression</span><span class="token punctuation">(</span><span class="token string">'='</span><span class="token punctuation">,</span> memberExpression<span class="token punctuation">,</span> functionExpression<span class="token punctuation">)</span><span class="token punctuation">;</span>
            functions<span class="token punctuation">.</span><span class="token function">push</span><span class="token punctuation">(</span>types<span class="token punctuation">.</span><span class="token function">expressionStatement</span><span class="token punctuation">(</span>assignmentExpression<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
        <span class="token punctuation">}</span>
    <span class="token punctuation">}</span><span class="token punctuation">)</span>
    <span class="token comment">//判断,replaceWithMultiple用于多重替换</span>
    <span class="token keyword">if</span><span class="token punctuation">(</span>functions<span class="token punctuation">.</span>length <span class="token operator">==</span><span class="token operator">=</span> <span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">{</span>
        path<span class="token punctuation">.</span><span class="token function">replaceWith</span><span class="token punctuation">(</span>functions<span class="token punctuation">[</span><span class="token number">0</span><span class="token punctuation">]</span><span class="token punctuation">)</span>
    <span class="token punctuation">}</span><span class="token keyword">else</span><span class="token punctuation">{</span>
        path<span class="token punctuation">.</span><span class="token function">replaceWithMultiple</span><span class="token punctuation">(</span>functions<span class="token punctuation">)</span>
    <span class="token punctuation">}</span>
    

    }

    总结

    日常工作中,我们大多数时候关注的只是 js 代码本身,而没有通过 AST 去重新认识和诠释自己的代码~

    本文也只是通过对 AST 的一些介绍,起一个抛砖引玉的作用,让你对它 有一个初步的认识,对它不在感觉那么陌生。

    对代码的追求和探索是无止境的~

    如果你愿意,你可以通过它构建任何你想要的js代码~

    加油!

    4人点赞
    "如果觉得我的文章对您有用,请随意赞赏。您的支持将鼓励我继续创作!"
    赞赏支持还没有人赞赏,支持一下
    CrypticTalk is cheap. Show me the code. github : http...
    总资产16 (约1.57元)共写了6.7W字获得658个赞共492个粉丝
    关注
    展开全文
  • AST

    2017-12-11 11:49:00
    AST的结构定义在ast这个包中。 接下来,要把AST转移成执行计划,这个步骤在Compile进行处理的。最终的执行计划是一个物理计划(physical plan),由一系列的物理逻辑操作符组成。 最后,执行执行计划,这块以后...

    DDL

    以select语句为例,入口在session.go中的Execute方法。

    首先,sql需要解析成AST,这个步骤是通过ParseSQL进行处理的,这块需要了解一下lex+yacc原理,看得懂parser.y中的规则定义。AST的结构定义在ast这个包中。

    接下来,要把AST转移成执行计划,这个步骤在Compile进行处理的。最终的执行计划是一个物理计划(physical plan),由一系列的物理逻辑操作符组成。

    最后,执行执行计划,这块以后再说。

    下面主要关注这个Compile的过程,见compile.go的Compile方法。分为几个步骤: 预处理、生成逻辑计划、生成物理计划。

    预处理比较简单,就是检查一些简单的语法,例如表名是否合法,字段是否合法等,都是简单的校验。见plan/preprocess.go

    逻辑计划和物理计划有什么区别?这个真有点蒙头,可以看看一下这篇论文脑补一下。

    http://oai.dtic.mil/oai/oai?verb=getRecord&metadataPrefix=html&identifier=ADA450829 The Volcano Optimizer Generator

    转载于:https://my.oschina.net/bonyfish/blog/1587797

    展开全文
  • AST Matcher Pharo ASTAST匹配器
  • 美国传感器科技公司(AST)日前推出新系列介质隔离式液压传感器AST4500和AST4510。该系列产品通过采用已经的整块单件不锈钢全密封外壳,适用于本质安全IS区域。AST4500和AST4510传感器已通过UL/cUL913(CSA)Class 1 Div...
  • 【Eclipse ASTASTASTView简介
                   

           要想自己设计并实现一个代码自动分析、优化和重构工具,得先理解代码;要想理解代码,得先用一个好的数据结构来存储和表示所读取的代码。基于程序代码本身的层次结构,用树状结构来表示是再好不过的微笑

           抽象语法树(Abstract Syntax Tree, AST)使用树状结构来表示源代码的抽象语法结构,树上的每一个节点都对应源代码中的一种结构,它作为程序代码的一种中间表示形式,在代码分析、代码重构、语言翻译等领域得到广泛的应用。现有的一些相关工具中,都会存在自行将源代码转换为抽象语法树的模块。至于将哪些语法节点进行转换,不同的工具会有不同的定义。

           在图1中,对于Java程序中一个for循环片段,使用抽象语法树进行简单的转换/分解,以便于大家可以简单直观地感受到抽象语法树中所展示的字、词、句、段、篇,图1的分解所依据的是Eclipse JDT中Eclipse AST对抽象语法树的定义。

    图1 抽象语法树Java程序片段实例

           根据Eclipse AST的定义,图中每一个节点对应一个节点名,每一个子节点也在其依附的父节点中扮演着一个角色(身份),并且叶子节点基本为名称、操作符和字面量。表1给出了图1中的for循环节点(ForStatement)的四个子节点的节点名和依附于父节点的角色。

    子节点

    子节点名

    依附于父节点的角色

     int i = 1

     VariableDeclarationExpression

    INITIALIZERS 

    i <= 10 

    InfixExpression 

    EXPRESSION 

     i++

     PostExpression

    UPDATERS 

    {

       count = count + 1;

    }

    Block 

    BODY

           为了更直观地阅读和理解AST,可以使用ASTView等工具。ASTView(http://www.eclipse.org/jdt/ui/astview/)是一款Eclipse官方提供的抽象语法树浏览插件,可用来浏览Eclipse编辑器中的代码对应的抽象语法树。在官方网站下载插件后放入Eclipse安装目录下的dropins文件夹中(Eclipse 3.4 M3以下版本放入plugins文件夹中),打开Eclipse后在Window-Show View下找到ASTView点击(如图2),即可打开ASTView视图(如图3)。

    图2 打开ASTView

     

    图3 ASTView视图

            下面是一个完整的Java类的源代码: 

    package com.ast.usecase;public class ClassDemo {       private  String text = "Hello World!";       public  void print(int value) {              System.out.println(value);       }}

           从ASTView的显示结果来看,这货生成的抽象语法树居然有32个节点!大笑

    图4 ASTView显示结果

           ASTView中所展示的除了抽象语法树的节点外,还显示相关的属性,因此哪怕只是一个小而简单的类,一眼看遍整棵树还是不太现实的。

    图5 ASTView常用功能按钮 

           图5是ASTView的一组常用功能按钮,从左到右依次为:

    • Show AST of active editor:展示编辑器光标当前所在位置的节点
    • Refresh AST:当编辑器中代码有所改动后,点击刷新抽象语法树
    • Clear AST and release memory:关闭当前抽象语法树的显示
    • Home:与Back和Go Into配合使用,返回全局根节点,查看子树
    • Back:与Home和Go Into配合使用,返回父节点,并以父节点为根节点,查看其子树
    • Go Into:与Home和Back配合使用,以当前所在节点为根节点,查看其子树
    • Expand Selected Node:展开当前所选节点,以查看其子节点
    • Collapse Selected Node:折叠当前所选节点
    • Link With Editor:关联ASTView与编辑器,动态显示光标所在的节点

           双击ASTView中的任一节点,可以在编辑器中看到对应的代码片段被高亮显示。配合以上功能按钮的使用能够非常直观、方便的浏览代码的抽象语法结构。

    图6 ASTView双击节点高亮显示代码

           代码虽小,五脏俱全。图7是这个小而简单的类所包含的32个节点以节点名和节点内容的形式制作成的树状图【PS:韬韬童鞋画这个图可是费了大力气的,偷笑】,大家可以认真感受一下(对照源代码和抽象语法树)。

     

    图7 示例类ClassDemo所对应的完整抽象语法树

           了解了抽象语法树和Java程序的语法结构后,接下来我们将学习如何使用Eclipse AST操作和生成Java源代码,欲知详情,请听下回分解!微笑

     

    本文作者:刘伟,刘宏韬  http://blog.csdn.net/lovelion

               
    展开全文
  • 美国传感器科技公司(AST)日前推出新系列介质隔离式液压传感器AST4500和AST4510。该系列产品通过采用已经认证的整块单件不锈钢全密封外壳,适用于本质安全IS区域。AST4500和AST4510传感器已通过UL/cUL913(CSA)Class 1...
  • add ast, _ast

    2020-11-30 18:54:45
    <div><p>add typechecking for asd, _ast</p><p>该提问来源于开源项目:python/typeshed</p></div>
  • AST Explorer

    2020-12-29 05:06:11
    It is a very basic concept of AST panel as following as <a href="http://forivall.com/astexplorer/">AST explorer</a>. <p>Except for an auto focusing option in AST explorer, on/off methods, empty keys ...
  • XON AST(开发中) XON AST是一个解析XON代码并为其生成抽象语法树的库 使用范例 npm i -S @xon/ast index.js import { evalExpression , parseExpression } from '@xon/ast' ; const code = '2 + 2 |x: x^x + x ...
  • ast_study AST 结构在线解析 AST 参考文章 AST 常用节点类型对照表 序号 类型原名称 中文名称 描述 1 Program 程序主体 整段代码的主体 2 VariableDeclaration 变量声明 声明一个变量,例如 var let const 3 ...
  • AST transformers

    2020-12-30 11:44:00
    <div><p>[] Now that <code>ceylon.ast</code> is ready, I propose that we define a ~~macro~~ system of <em>AST transformers</em> for Ceylon. This would be the ability to write a Ceylon module that is ...
  • astAST-AT&T软件技术
  • AST解析器 $ npm i ast-parser -D const { parse : babelParse } = require ( "@babel/parser" ) ; const { parse : astParse , find , findInfo } = require ( "ast-parser" ) ; function getNode ( code ) { ...
  • ast_viewer.cr:通过ASTNode对象,源文件或源代码字符串可视化AST结构
  • learn_ast AST 操作示例代码 演示 在各个子目录 README.md 查看操作方法 简单 babel 转换示例: eslint 校验规则: jsx babel plugin 示例:
  • Improvements to Ast::AstNode

    2021-01-09 03:36:33
    <p>1.) We rename Ast::AstNode to Ast::Node so that it's in line with its mother ::Parser::AST::Node. The slightly different naming is tripping me up all the time. <p>2.) We get rid of everything ...
  • AST3310-源码

    2021-02-24 02:06:31
    AST3310
  • Generic AST

    2021-01-02 09:11:47
    <div><p>Refactor all the AST types to use Cow<'a, str> instead of String. <p>This allows using the Ast both in a borrowed style, and a owned style with Cow<'static, str> <p>This ...
  • AST optimizations

    2021-01-11 06:29:15
    ve just realized that we need an intermediate phase after building AST and generating JS code. <p>Lets make a list of handy optimizations the AST post-processor could make for us.</p><p>该提问来源于...
  • Go ast

    2021-04-08 11:02:19
    AST是抽象语法树(Abstract Syntax Tree)的简称,AST以树状形式表现编程语言的语法结构,树上每个节点都表示源代码中的一种结构。之所以说语法是“抽象”的,是因为这里的语法并不会表示出真实语法中出现的每个细节。...

    AST是抽象语法树(Abstract Syntax Tree)的简称,AST以树状形式表现编程语言的语法结构,树上每个节点都表示源代码中的一种结构。之所以说语法是“抽象”的,是因为这里的语法并不会表示出真实语法中出现的每个细节。

    ast包声明了用于表示Go包的语法树的类型

    ast.Node

    Golang会将所有可以识别的token抽象成为ast.Node,通过接口方式组织在一起。

    AST节点实现了ast.Node接口,返回AST中的一个位置。

    type Node interface {
        Pos() token.Pos // 开始位置
        End() token.Pos // 结束位置
    }

    整个AST语法树由不同的节点组成,节点可分为三种,均会实现ast.Node接口。

    • ast.Expr 代表表达式和类型的节点
    type Expr interface {
        Node
        exprNode()
    }
    • ast.Stmt 代表表节点
    type Stmt interface {
        Node
        stmtNode()
    }
    • ast.Decl 代表声明节点
    type Decl interface {
        Node
        declNode()
    }
    ast.Node

    示例

    使用ast.Node表示结构体
    package test
    
    import (
        "go/ast"
        "go/parser"
        "go/token"
        "testing"
    )
    
    func TestAst(t *testing.T) {
        src := `
    package main
    func main(){
        println("hello world")
    }
        `
        //创建用于解析源文件的对象
        fileset := token.NewFileSet()
        //解析源文件,返回ast.File原始文档类型的结构体。
        astfile, err := parser.ParseFile(fileset, "", src, 0)
        if err != nil {
            panic(err)
        }
        //查看日志打印
        ast.Print(fileset, astfile)
    }
    0  *ast.File {
    1  .  Package: 2:1
    2  .  Name: *ast.Ident {
    3  .  .  NamePos: 2:9
    4  .  .  Name: "main"
    5  .  }
    6  .  Decls: []ast.Decl (len = 1) {
    7  .  .  0: *ast.FuncDecl {
    8  .  .  .  Name: *ast.Ident {
    9  .  .  .  .  NamePos: 3:6
    10  .  .  .  .  Name: "main"
    11  .  .  .  .  Obj: *ast.Object {
    12  .  .  .  .  .  Kind: func
    13  .  .  .  .  .  Name: "main"
    14  .  .  .  .  .  Decl: *(obj @ 7)
    15  .  .  .  .  }
    16  .  .  .  }
    17  .  .  .  Type: *ast.FuncType {
    18  .  .  .  .  Func: 3:1
    19  .  .  .  .  Params: *ast.FieldList {
    20  .  .  .  .  .  Opening: 3:10
    21  .  .  .  .  .  Closing: 3:11
    22  .  .  .  .  }
    23  .  .  .  }
    24  .  .  .  Body: *ast.BlockStmt {
    25  .  .  .  .  Lbrace: 3:12
    26  .  .  .  .  List: []ast.Stmt (len = 1) {
    27  .  .  .  .  .  0: *ast.ExprStmt {
    28  .  .  .  .  .  .  X: *ast.CallExpr {
    29  .  .  .  .  .  .  .  Fun: *ast.Ident {
    30  .  .  .  .  .  .  .  .  NamePos: 4:2
    31  .  .  .  .  .  .  .  .  Name: "println"
    32  .  .  .  .  .  .  .  }
    33  .  .  .  .  .  .  .  Lparen: 4:9
    34  .  .  .  .  .  .  .  Args: []ast.Expr (len = 1) {
    35  .  .  .  .  .  .  .  .  0: *ast.BasicLit {
    36  .  .  .  .  .  .  .  .  .  ValuePos: 4:10
    37  .  .  .  .  .  .  .  .  .  Kind: STRING
    38  .  .  .  .  .  .  .  .  .  Value: "\"hello world\""
    39  .  .  .  .  .  .  .  .  }
    40  .  .  .  .  .  .  .  }
    41  .  .  .  .  .  .  .  Ellipsis: -
    42  .  .  .  .  .  .  .  Rparen: 4:23
    43  .  .  .  .  .  .  }
    44  .  .  .  .  .  }
    45  .  .  .  .  }
    46  .  .  .  .  Rbrace: 5:1
    47  .  .  .  }
    48  .  .  }
    49  .  }
    50  .  Scope: *ast.Scope {
    51  .  .  Objects: map[string]*ast.Object (len = 1) {
    52  .  .  .  "main": *(obj @ 11)
    53  .  .  }
    54  .  }
    55  .  Unresolved: []*ast.Ident (len = 1) {
    56  .  .  0: *(obj @ 29)
    57  .  }
    58  }

    分析方式

    按照深度优先的顺序遍历AST节点,通过递归调用ast.Inspect()方法来逐一打印每个节点。
    如果直接打印AST则会看到一些无法被人类阅读的东西。为了防止这种情况的发生,使用ast.Print()来实现对AST的人工读取。

    func TestAst(t *testing.T) {
        abspath, err := filepath.Abs("./demo.go")
        if err != nil {
            panic(abspath)
        }
        //创建用于解析源文件的对象
        fset := token.NewFileSet()
        //解析源文件,返回ast.File原始文档类型的结构体。
        f, err := parser.ParseFile(fset, abspath, nil, parser.AllErrors)
        if err != nil {
            panic(err)
        }
        //递归调用逐一打印节点
        ast.Inspect(f, func(n ast.Node) bool {
            ast.Print(fset, n)
            return true
        })
    }

    ast.File

    • ast.File是所有AST节点的根,仅实现ast.Node接口。
    type File struct {
        Doc        *CommentGroup   // associated documentation; or nil
        Package    token.Pos       // position of "package" keyword
        Name       *Ident          // package name
        Decls      []Decl          // top-level declarations; or nil
        Scope      *Scope          // package scope (this file only)
        Imports    []*ImportSpec   // imports in this file
        Unresolved []*Ident        // unresolved identifiers in this file
        Comments   []*CommentGroup // list of all comments in the source file
    }
    • ast.File具有引用包名、导入声明、函数声明子节点。
    ast.File
    子节点 包名 描述
    ast.Indent Package Name 包名
    ast.GenDecl Import Declaration 导入声明
    ast.FuncDecl Func Declaration 函数声明

    ast.Indent

    • 一个包名可以使用AST节点类型*ast.Indent来表示
    • ast.Indent实现了ast.Expr接口
    • 所有标识符都由ast.Indent结构来表示,主要包含了包的名称和在文件集中的源位置。
    *ast.Ident {
     NamePos: dummy.go:1:9
     Name: "hello"
    }

    例如:

    2  .  Name: *ast.Ident {
    3  .  .  NamePos: 2:9
    4  .  .  Name: "main"
    5  .  }

    Golang具有一个scope的概念,即源文件的scope,其中标识符表示指定的常量、类型、变量、函数、标签、包。

    8  .  .  .  Name: *ast.Ident {
    9  .  .  .  .  NamePos: 3:6
    10  .  .  .  .  Name: "main"
    11  .  .  .  .  Obj: *ast.Object {
    12  .  .  .  .  .  Kind: func
    13  .  .  .  .  .  Name: "main"
    14  .  .  .  .  .  Decl: *(obj @ 7)
    15  .  .  .  .  }
    16  .  .  .  }

    ast.GenDecl

    • ast.GenDecl表示除函数以外的所有导入声明,即importconstvartype
    • Tok代表一个词性标识,用于指明声明的内容。
    *ast.GenDecl {
     TokPos: dummy.go:3:1
     Tok: import
     Lparen: -
     Specs: []ast.Spec (len = 1) {
        0: *ast.ImportSpec {/* Omission */}
      }
      Rparen: -
    }

    ast.ImportSpec

    • 一个ast.ImportSpec节点对应一个导入声明。
    • ast.ImportSpec实现了ast.Spec接口,访问路径可以让导入路径更有意义。
    *ast.ImportSpec {
      Path: *ast.BasicLit {/* Omission */}
      EndPos: -
    }

    ast.BasicLit

    • 一个ast.BasicLit节点表示一个基本类型的文字,实现了ast.Expr接口。
    • ast.BasicLit包含一个token类型,可使用token.INITtoken.FLOATtoken.IMAGtoken.CHARtoken.STRING
    *ast.BasicLit {
      ValuePos: dummy.go:3:8
      Kind: STRING
      Value: "\"fmt\""
    }

    ast.FuncDecl

    • 一个ast.FuncDecl节点代表一个函数声明,仅实现了ast.Node接口。

    ast.FuncType

    • 一个ast.FuncType包含一个函数签名,包括参数、结果和func关键字的位置。

    ast.FieldList

    • ast.FieldList节点表示一个Field的咧白哦,使用括号或大括号起来。
    • 列表字段是*ast.Field的一个切片,包含一对标识符和类型。

    ast.BlockStmt

    • 一个ast.BlockStmt节点表示一个括号内的语句列表,实现了ast.Stmt接口。

    ast.ExprStmt

    • ast.ExprStmt在语句列表中表示一个表达式,实现了ast.Stmt接口,并包含一个ast.Expr

    ast.CallExpr

    • ast.CallExpr表示一个调用函数的表达式,要查看的字段是:Fun、要调用的函数和Args、要传递给它的参数列表。

    ast.SelectorExpr

    • ast.SelectorExpr表示一个带有选择器的表达式
    展开全文
  • 小马AST资源管理器 一个GDB插件,用于交互式浏览 AST。 要求 具有Python支持的GDB(Python> = 3.8) 如何使用 首先,在GDB会话中加载资源管理器: source /path/to/checkout/ast_explorer.py 如果脚本成功加载,则...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,904
精华内容 6,761
关键字:

ast