前端工程师须要掌握的 Babel 知识

时间  2019-11-18
标签 前端 工程师 须要 掌握 babel 知识 繁體版
原文   原文链接

在前端圈子里，对于 Babel，你们确定都比较熟悉了。若是哪天少了它，对于前端工程师来讲确定是个噩梦。Babel 的工做原理是怎样的可能了解的人就不太多了。
本文将主要介绍 Babel 的工做原理以及怎么写一个 Babel 插件。前端

Babel 是怎么工做的

Babel 是一个 JavaScript 编译器。node

作与不作

注意很重要的一点就是，Babel 只是转译新标准引入的语法，好比：react

  • 箭头函数
  • let / const
  • 解构

哪些在 Babel 范围外？对于新标准引入的全局变量、部分原生对象新增的原型链上的方法，Babel 表示超纲了。express

  • 全局变量
  • Promise
  • Symbol
  • WeakMap
  • Set
  • includes
  • generator 函数

对于上面的这些 API，Babel 是不会转译的，须要引入 polyfill 来解决。npm

Babel 编译的三个阶段

Babel 的编译过程和大多数其余语言的编译器类似，能够分为三个阶段：编程

  • 解析（Parsing）：将代码字符串解析成抽象语法树。
  • 转换（Transformation）：对抽象语法树进行转换操做。
  • 生成（Code Generation）: 根据变换后的抽象语法树再生成代码字符串。


 

 



为了理解 Babel，咱们从最简单一句 console 命令下手数组

解析（Parsing）

Babel 拿到源代码会把代码抽象出来，变成 AST （抽象语法树），学过编译原理的同窗应该都听过这个词，全称是 Abstract Syntax Tree。抽象语法树是源代码的抽象语法结构的树状表示，树上的每一个节点都表示源代码中的一种结构，只因此说是抽象的，是由于抽象语法树并不会表示出真实语法出现的每个细节，好比说，嵌套括号被隐含在树的结构中，并无以节点的形式呈现，它们主要用于源代码的简单转换。console.log('zcy')； 的 AST 长这样：babel

{
  "type": "Program",
  "body": [
    {
      "type": "ExpressionStatement",
      "expression": {
        "type": "CallExpression",
        "callee": {
          "type": "MemberExpression",
          "computed": false,
          "object": {
            "type": "Identifier",
            "name": "console"
          },
          "property": {
            "type": "Identifier",
            "name": "log"
          }
        },
        "arguments": [
          {
          "type": "Literal",
          "value": "zcy",
          "raw": "'zcy'"
          }
        ]
      }
    }
  ],
  "sourceType": "script"
}

 

上面的 AST 描述了源代码的每一个部分以及它们之间的关系。前端工程师

AST 是怎么来的？

整个解析过程分为两个步骤：antd

  • 分词：将整个代码字符串分割成语法单元数组
  • 语法分析：创建分析语法单元之间的关系


分词语法单元通俗点说就是代码中的最小单元，不能再被分割，就像原子是化学变化中的最小粒子同样。Javascript 代码中的语法单元主要包括如下这么几种：

  • 关键字：const、 let、  var 等
  • 标识符：多是一个变量，也多是 if、else 这些关键字，又或者是 true、false 这些常量
  • 运算符
  • 数字
  • 空格
  • 注释：对于计算机来讲，知道是这段代码是注释就好了，不关心其具体内容

其实分词说白了就是简单粗暴地对字符串一个个遍历。为了模拟分词的过程，写了一个简单的 Demo，仅仅适用于和上面同样的简单代码。Babel 的实现比这要复杂得多，可是思路大致上是相同的。

 

function tokenizer(input) {
  const tokens = [];
  const punctuators = [',', '.', '(', ')', '=', ';'];

  let current = 0;
  while (current < input.length) {

    let char = input[current];

    if (punctuators.indexOf(char) !== -1) {

      tokens.push({
        type: 'Punctuator',
        value: char,
      });
      current++;
      continue;
    }
    // 检查空格，连续的空格放到一块儿
    let WHITESPACE = /\s/;
    if (WHITESPACE.test(char)) {
      current++;
      continue;
    }

    // 标识符是字母、$、_开始的
    if (/[a-zA-Z\$\_]/.test(char)) {
      let value = '';

      while(/[a-zA-Z0-9\$\_]/.test(char)) {
        value += char;
        char = input[++current];
      }
      tokens.push({ type: 'Identifier', value });
      continue;
    }

    // 数字从0-9开始，不止一位
    const NUMBERS = /[0-9]/;
    if (NUMBERS.test(char)) {
      let value = '';
      while (NUMBERS.test(char)) {
        value += char;
        char = input[++current];
      }
      tokens.push({ type: 'Numeric', value });
      continue;
    }

    // 处理字符串
    if (char === '"') {
      let value = '';
      char = input[++current];

      while (char !== '"') {
        value += char;
        char = input[++current];
      }

      char = input[++current];

      tokens.push({ type: 'String', value });

      continue;
    }
    // 最后遇到不认识到字符就抛个异常出来
    throw new TypeError('Unexpected charactor: ' + char);
  }

  return tokens;
}

const input = `console.log("zcy");`

console.log(tokenizer(input));

 

 


结果以下：

[ 
  { 
    "type" :  "Identifier" , 
    "value" :  "console"
   }, 
  { 
    "type" :  "Punctuator" , 
    "value" :  "."
   }, 
  { 
    "type" :  "Identifier" , 
    "value" :  "log"
   }, 
  { 
    "type" :  "Punctuator" , 
    "value" :  "("
   }, 
  { 
    "type" :  "String" ,
    "value" :  "'zcy'"
   }, 
  { 
    "type" : "Punctuator" , 
    "value" :  ")"
   }, 
  { 
    "type" :  "Punctuator" , 
    "value" :  ";"
   } 
]

 

 

 

 

语法分析语义分析则是将获得的词汇进行一个立体的组合，肯定词语之间的关系。考虑到编程语言的各类从属关系的复杂性，语义分析的过程又是在遍历获得的语法单元组，相对而言就会变得更复杂。简单来讲语法分析是对语句和表达式识别，这是个递归过程，在解析中，Babel  会在解析每一个语句和表达式的过程当中设置一个暂存器，用来暂存当前读取到的语法单元，若是解析失败，就会返回以前的暂存点，再按照另外一种方式进行解析，若是解析成功，则将暂存点销毁，不断重复以上操做，直到最后生成对应的语法树。

转换（Transformation）

Plugins

插件应用于 babel 的转译过程，尤为是第二个阶段 Transformation，若是这个阶段不使用任何插件，那么 babel 会原样输出代码。

Presets

Babel 官方帮咱们作了一些预设的插件集，称之为 Preset，这样咱们只须要使用对应的 Preset 就能够了。每一年每一个 Preset 只编译当年批准的内容。而 babel-preset-env 至关于 ES2015 ，ES2016 ，ES2017 及最新版本。

Plugin/Preset 路径

若是 Plugin 是经过 npm 安装，能够传入 Plugin 名字给 Babel，Babel 将检查它是否安装在 node_modules 中。

"plugins": ["babel-plugin-myPlugin"]

也能够指定你的 Plugin/Preset 的相对或绝对路径。

"plugins": ["./node_modules/asdf/plugin"]
Plugin/Preset 排序

若是两次转译都访问相同的节点，则转译将按照 Plugin 或 Preset 的规则进行排序而后执行。

  • Plugin 会运行在 Preset 以前。
  • Plugin 会从第一个开始顺序执行。
  • Preset 的顺序则恰好相反(从最后一个逆序执行)。

例如：

{
  "plugins": [
    "transform-decorators-legacy",
    "transform-class-properties"
  ]
}

将先执行 transform-decorators-legacy 再执行 transform-class-properties但 preset 是反向的

{
  "presets": [
    "es2015",
    "react",
    "stage-2"
  ]
}

会按如下顺序运行:  stage-2， react， 最后 es2015。
那么问题来了，若是 presets 和 plugins 同时存在，那执行顺序又是怎样的呢？答案是先执行 plugins 的配置，再执行 presets 的配置。因此如下代码的执行顺序为

  1. @babel/plugin-proposal-decorators
  2. @babel/plugin-proposal-class-properties
  3. @babel/plugin-transform-runtime
  4. @babel/preset-env



// .babelrc 文件
{
  "presets": [
    [
      "@babel/preset-env"
    ]
  ],
  "plugins": [
    ["@babel/plugin-proposal-decorators", { "legacy": true }],
    ["@babel/plugin-proposal-class-properties", { "loose": true }],
    "@babel/plugin-transform-runtime",
  ]
}
 
生成（Code Generation）

用 babel-generator 经过 AST 树生成 ES5 代码。

如何编写一个 Babel 插件

基础的东西讲了些，下面说下具体如何写插件，只作简单的介绍，感兴趣的同窗能够看 Babel 官方的介绍。

插件格式

先从一个接收了当前 Babel 对象做为参数的 Function 开始。

export default function(babel) {
  // plugin contents
}

咱们常常会这样写

export default function({ types: t }) {
    //
}

接着返回一个对象，其 visitor 属性是这个插件的主要访问者。

export default function({ types: t }) {
  return {
    visitor: {
      // visitor contents
    }
  };
};

visitor 中的每一个函数接收 2 个参数：path 和 state

export default function({ types: t }) {
  return {
    visitor: {
      CallExpression(path, state) {}
    }
  };
};

写一个简单的插件

咱们先写一个简单的插件，把全部定义变量名为 a 的换成 b ，先看下 var a = 1的 AST

{
  "type": "Program",
  "start": 0,
  "end": 10,
  "body": [
    {
      "type": "VariableDeclaration",
      "start": 0,
      "end": 9,
      "declarations": [
        {
          "type": "VariableDeclarator",
          "start": 4,
          "end": 9,
          "id": {
            "type": "Identifier",
            "start": 4,
            "end": 5,
            "name": "a"
          },
          "init": {
            "type": "Literal",
            "start": 8,
            "end": 9,
            "value": 1,
            "raw": "1"
          }
        }
      ],
      "kind": "var"
    }
  ],
  "sourceType": "module"
}

 

 

从这里看，要找的节点类型就是 VariableDeclarator ，下面开始撸代码

export default function({ types: t }) {
  return {
    visitor: {
      VariableDeclarator(path, state) {
        if (path.node.id.name == 'a') {
          path.node.id = t.identifier('b')
        }
      }
    }
  }
}

 

 

咱们要把 id 属性是 a 的替换成 b 就行了。可是这里不能直接 path.node.id.name = 'b' 。若是操做的是Object，就没问题，可是这里是 AST 语法树，因此想改变某个值，就是用对应的 AST 来替换，如今咱们用新的标识符来替换这个属性。最后测试一下

import * as babel from '@babel/core';
const c = `var a = 1`;

const { code } = babel.transform(c, {
  plugins: [
    function({ types: t }) {
      return {
        visitor: {
          VariableDeclarator(path, state) {
            if (path.node.id.name == 'a') {
              path.node.id = t.identifier('b')
            }
          }
        }
      }
    }
  ]
})

console.log(code); // var b = 1

 

 

实现一个简单的按需打包功能

例如咱们要实现把 import { Button } from 'antd' 转成 import Button from 'antd/lib/button'经过对比 AST 发现，specifiers  里的 type 和 source 不一样。

// import { Button } from 'antd'
"specifiers": [
    {
        "type": "ImportSpecifier",
        ...
    }
]
// import Button from 'antd/lib/button'
"specifiers": [
    {
        "type": "ImportDefaultSpecifier",
        ...
    }
]
import * as babel from '@babel/core';
const c = `import { Button } from 'antd'`;

const { code } = babel.transform(c, {
  plugins: [
    function({ types: t }) {
      return {
        visitor: {
          ImportDeclaration(path) {
            const { node: { specifiers, source } } = path;
            if (!t.isImportDefaultSpecifier(specifiers[0])) { // 对 specifiers 进行判断，是否默认倒入
              const newImport = specifiers.map(specifier => (
                t.importDeclaration(
                  [t.ImportDefaultSpecifier(specifier.local)],
                  t.stringLiteral(`${source.value}/lib/${specifier.local.name}`)
                )
              ))
              path.replaceWithMultiple(newImport)
            }
          }
        }
      }
    }
  ]
})

console.log(code); // import Button from "antd/lib/Button";

 

固然 babel-plugin-import 这个插件是有配置项的，咱们能够对代码作如下更改。

export default function({ types: t }) {
  return {
    visitor: {
      ImportDeclaration(path, { opts }) {
        const { node: { specifiers, source } } = path;
        if (source.value === opts.libraryName) {
          // ...
        }
      }
    }
  }
}

 

至此，这个插件咱们就编写完成了。

 

 

Babel 经常使用 API

@babel/core

Babel 的编译器，核心 API 都在这里面，好比常见的 transform、parse。

@babel/cli

cli 是命令行工具,  安装了 @babel/cli 就可以在命令行中使用 babel  命令来编译文件。固然咱们通常不会用到，打包工具已经帮咱们作好了。

@babel/node

直接在 node 环境中，运行 ES6 的代码。

babylon

Babel 的解析器。

babel-traverse

用于对 AST 的遍历，维护了整棵树的状态，而且负责替换、移除和添加节点。

babel-types

用于 AST 节点的 Lodash 式工具库, 它包含了构造、验证以及变换 AST 节点的方法，对编写处理 AST 逻辑很是有用。

babel-generator

Babel 的代码生成器，它读取 AST 并将其转换为代码和源码映射（sourcemaps）。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程