玉缜作者

不同前端框架下的代码转换

背景

整个前端领域在这几年迅速发展,前端框架也在不断变化,各团队选择的解决方案都不太一致,此外像小程序这种跨端场景和以往的研发方式也不太一样。在日常开发中往往会因为投放平台的不一样需要进行重新编码。

前段时间我们需要在淘宝页面上投放闲鱼组件,淘宝前端研发DSL(React/Rax)和闲鱼前端研发DSL(Vue/Weex)不一致,有没有办法直接将已有的Vue组件转化为React组件呢,闲鱼技术团队从代码编译的角度提出了一种解决方案。

编译器的工作原理

日常工作中我们接触最多的编译器就是Babel,Babel可以将最新的Javascript语法编译成当前浏览器兼容的JavaScript代码,Babel工作流程分为三个步骤,由下图所示:0抽象语法树AST是什么

在计算机科学中,抽象语法树(Abstract Syntax Tree,AST),或简称语法树(Syntax tree),是源代码语法结构的一种抽象表示。它以树状的形式表现编程语言的语法结构,树上的每个节点都表示源代码中的一种结构,详见维基百科。这里以 consta=1转成 vara=1操作为例看下Babel是如何工作的。

0将代码解析成抽象语法树

Babel提供了@babel/parser将代码解析成AST。

  1. const parse = require('@babel/parser').parse;

  2. const ast = parse('const a = 1');

0经过遍历和分析转换对AST进行处理

Babel提供了@babel/traverse对解析后的AST进行处理。 @babel/traverse能够接收AST以及visitor两个参数,AST是上一步parse得到的抽象语法树,visitor提供访问不同节点的能力,当遍历到一个匹配的节点时,能够调用具体方法对于节点进行处理。@babel/types用于定义AST节点,在visitor里做节点处理的时候用于替换等操作。在这个例子中,我们遍历上一步得到的AST,在匹配到变量声明( VariableDeclaration)的时候判断是否 const操作时进行替换成 vart.variableDeclaration(kind,declarations)接收两个参数 kinddeclarations,这里kind设为 var,将 consta=1解析得到的AST里的 declarations直接设置给 declarations

  1. const traverse = require('@babel/traverse').default;

  2. const t = require('@babel/types');

  3. traverse(ast, {

  4. VariableDeclaration: function(path) { //识别在变量声明的时候

  5. if (path.node.kind === 'const') { //只有const的时候才处理

  6. path.replaceWith(

  7. t.variableDeclaration('var', path.node.declarations) //替换成var

  8. );

  9. }

  10. path.skip();

  11. }

  12. });

0将最终转换的AST重新生成代码

Babel提供了@babel/generator将AST再还原成代码。

  1. const generate = require('@babel/generator').default;

  2. let code = generate(ast).code;

Vue和React的异同

我们来看下Vue和React的异同,如果需要做转化需要有哪些处理,Vue的结构分为style、script、template三部分

0style

样式这部分不用去做特别的转化,Web下都是通用的

0script

Vue某些属性的名称和React不太一致,但是功能上是相似的。例如 data需要转化为 stateprops需要转化为 defaultPropspropTypescomponents的引用需要提取到组件声明以外, methods里的方法需要提取到组件的属性上。还有一些属性比较特殊,比如 computed,React里是没有这个概念的,我们可以考虑将 computed里的值转化成函数方法,上面示例中的 length,可以转化为 length()这样的函数调用,在React的 render()方法以及其他方法中调用。

Vue的生命周期和React的生命周期有些差别,但是基本都能映射上,下面列举了部分生命周期的映射

  • created -> componentWillMount

  • mounted -> componentDidMount

  • updated -> componentDidUpdate

  • beforeDestroy -> componentWillUnmount 

    在Vue内函数的属性取值是通过 this.xxx的方式,而在Rax内需要判断是否 stateprops还是具体的方法,会转化成 this.statethis.props或者 this.xxx的方式。因此在对Vue特殊属性的处理中,我们对于 datapropsmethods需要额外做标记。

0template


针对文本节点和元素节点处理不一致,文本节点需要对内容 {{title}}进行处理,变为 {title}

Vue里有大量的增强指令,转化成React需要额外做处理,下面列举了部分指令的处理方式

  • 事件绑定的处理, @click -> onClick

  • 逻辑判断的处理, v-if="item.show" -> {item.show&&……}

  • 动态参数的处理, :title="title" -> title={title}

还有一些是正常的html属性,但是React下是不一样的,例如 style -> className。 指令里和 model里的属性值需要特殊处理,这部分的逻辑其实和script里一样,例如需要 {{title}}转变成 {this.props.title}

Vue代码的解析

以下面的Vue代码为例

  1. <template>

  2. <div>

  3. <p class="title" @click="handleClick">{{title}}</p>

  4. <p class="name" v-if="show">{{name}}</p>

  5. </div>

  6. </template>

  7. <style>

  8. .title {font-size: 28px;color: #333;}

  9. .name {font-size: 32px;color: #999;}

  10. </style>

  11. <script>

  12. export default {

  13. props: {

  14. title: {

  15. type: String,

  16. default: "title"

  17. }

  18. },

  19. data() {

  20. return {

  21. show: true,

  22. name: "name"

  23. };

  24. },

  25. mounted() {

  26. console.log(this.name);

  27. },

  28. methods: {

  29. handleClick() {}

  30. }

  31. };

  32. </script>

我们需要先解析Vue代码变成AST值。这里使用了Vue官方的 vue-template-compiler来分别提取Vue组件代码里的template、style、script,考虑其他DSL的通用性后续可以迁移到更加适用的html解析模块,例如 parse5等。通过 vue-template-compilerparseComponent方法得到了分离的template、style、script。 style不用额外解析成AST了,可以直接用于React代码。template可以通过 vue-template-compilercompile方法转化为AST值。script用 @babel/parser来处理,对于script的解析不仅仅需要获得整个script的AST值,还需要分别将 datapropscomputedcomponentsmethods参数提取出来,以便后面在转化的时候区分具体属于哪个属性。以 data的处理为例:

  1. const traverse = require('@babel/traverse').default;

  2. const t = require('@babel/types');

  3. const analysis = (body, data, isObject) => {

  4. data._statements = [].concat(body); // 整个表达式的AST值

  5. let propNodes = [];

  6. if (isObject) {

  7. propNodes = body;

  8. } else {

  9. body.forEach(child => {

  10. if (t.isReturnStatement(child)) { // return表达式的时候

  11. propNodes = child.argument.properties;

  12. data._statements = [].concat(child.argument.properties); // 整个表达式的AST值

  13. }

  14. });

  15. }

  16. propNodes.forEach(propNode => {

  17. data[propNode.key.name] = propNode; // 对data里的值进行提取,用于后续的属性取值

  18. });

  19. };

  20. const parse = (ast) => {

  21. let data = {

  22. };

  23. traverse(ast, {

  24. ObjectMethod(path) {

  25. /*

  26. 对象方法

  27. data() {return {}}

  28. */

  29. const parent = path.parentPath.parent;

  30. const name = path.node.key.name;

  31. if (parent && t.isExportDefaultDeclaration(parent)) {

  32. if (name === 'data') {

  33. const body = path.node.body.body;

  34. analysis(body, data);

  35. path.stop();

  36. }

  37. }

  38. },

  39. ObjectProperty(path) {

  40. /*

  41. 对象属性,箭头函数

  42. data: () => {return {}}

  43. data: () => ({})

  44. */

  45. const parent = path.parentPath.parent;

  46. const name = path.node.key.name;

  47. if (parent && t.isExportDefaultDeclaration(parent)) {

  48. if (name === 'data') {

  49. const node = path.node.value;

  50. if (t.isArrowFunctionExpression(node)) {

  51. /*

  52. 箭头函数

  53. () => {return {}}

  54. () => {}

  55. */

  56. if (node.body.body) {

  57. analysis(node.body.body, data);

  58. } else if (node.body.properties) {

  59. analysis(node.body.properties, data, true);

  60. }

  61. }

  62. path.stop();

  63. }

  64. }

  65. }

  66. });

  67. /*

  68. 最终得到的结果

  69. {

  70. _statements, //data解析AST值

  71. list //data.list解析AST值

  72. }

  73. */

  74. return data;

  75. };

  76. module.exports = parse;

最终处理之后得到这样一个结构:

  1. app: {

  2. script: {

  3. ast,

  4. components,

  5. computed,

  6. data: {

  7. _statements, //data解析AST值

  8. list //data.list解析AST值

  9. },

  10. props,

  11. methods

  12. },

  13. style, // style字符串值

  14. template: {

  15. ast // template解析AST值

  16. }

  17. }

React代码的转化

最终转化的React代码会包含两个文件(css和js文件)。用style字符串直接生成index.css文件,index.js文件结构如下图, transform指将Vue AST值转化成React代码的伪函数。

  1. import { createElement, Component, PropTypes } from 'React';

  2. import './index.css';

  3. export default class Mod extends Component {

  4. ${transform(Vue.script)}

  5. render() {

  6. ${transform(Vue.template)}

  7. }

  8. }

script AST值的转化不一一说明,思路基本都一致,这里主要针对Vue data继续说明如何转化成React state,最终解析Vue data得到的是 {_statements:AST}这样的一个结构,转化的时候只需要执行如下代码

  1. const t = require('@babel/types');

  2. module.exports = (app) => {

  3. if (app.script.data && app.script.data._statements) {

  4. // classProperty 类属性 identifier 标识符 objectExpression 对象表达式

  5. return t.classProperty(t.identifier('state'), t.objectExpression(app.script.data._statements));

  6. } else {

  7. return null;

  8. }

  9. };

针对template AST值的转化,我们先看下Vue template AST的结构:

  1. {

  2. tag: 'div',

  3. children: [{

  4. tag: 'text'

  5. },{

  6. tag: 'div',

  7. children: [……]

  8. }]

  9. }

转化的过程就是遍历上面的结构针对每一个节点生成渲染代码,这里以 v-if的处理为例说明下节点属性的处理,实际代码中会有两种情况:

  • 不包含 v-else的情况, <divv-if="xxx"/>转化为 {xxx&&<div/>}

  • 包含 v-else的情况, <divv-if="xxx"/><textv-else/>转化为 {xxx?<div/>:<text/>}

经过 vue-template-compiler解析后的template AST值里会包含 ifConditions属性值,如果 ifConditions的长度大于1,表明存在 v-else,具体处理的逻辑如下:

  1. if (ast.ifConditions && ast.ifConditions.length > 1) {

  2. // 包含v-else的情况

  3. let leftBlock = ast.ifConditions[0].block;

  4. let rightBlock = ast.ifConditions[1].block;

  5. let left = generatorJSXElement(leftBlock); //转化成JSX元素

  6. let right = generatorJSXElement(rightBlock); //转化成JSX元素

  7. child = t.jSXExpressionContainer( //JSX表达式容器

  8. // 转化成条件表达式

  9. t.conditionalExpression(

  10. parseExpression(value),

  11. left,

  12. right

  13. )

  14. );

  15. } else {

  16. // 不包含v-else的情况

  17. child = t.jSXExpressionContainer( //JSX表达式容器

  18. // 转化成逻辑表达式

  19. t.logicalExpression('&&', parseExpression(value), t.jsxElement(

  20. t.jSXOpeningElement(

  21. t.jSXIdentifier(tag), attrs),

  22. t.jSXClosingElement(t.jSXIdentifier(tag)),

  23. children

  24. ))

  25. );

  26. }

template里引用的属性/方法提取,在AST值表现上都是标识符( Identifier),可以在traverse的时候将 Identifier提取出来。这里用了一个比较取巧的方法,在template AST值转化的时候我们不对这些标识符做判断,而在最终转化的时候在render return之前插入一段引用。以下面的代码为例

  1. <text class="title" @click="handleClick">{{title}}</text>

  2. <text class="list-length">list length:{{length}}</text>

  3. <div v-for="(item, index) in list" class="list-item" :key="`item-${index}`">

  4. <text class="item-text" @click="handleClick" v-if="item.show">{{item.text}}</text>

  5. </div>

我们能解析出template里的属性/方法以下面这样一个结构表示:

  1. {

  2. title,

  3. handleClick,

  4. length,

  5. list,

  6. item,

  7. index

  8. }

在转化代码的时候将它与app.script.data、app.script.props、app.script.computed和app.script.computed分别对比判断,能得到title是props、list是state、handleClick是methods,length是computed,最终我们在return前面插入的代码如下:

  1. let {title} = this.props;

  2. let {state} = this.state;

  3. let {handleClick} = this;

  4. let length = this.length();

最终示例代码的转化结果

  1. import { createElement, Component, PropTypes } from 'React';

  2. export default class Mod extends Component {

  3. static defaultProps = {

  4. title: 'title'

  5. }

  6. static propTypes = {

  7. title: PropTypes.string

  8. }

  9. state = {

  10. show: true,

  11. name: 'name'

  12. }

  13. componentDidMount() {

  14. let {name} = this.state;

  15. console.log(name);

  16. }

  17. handleClick() {}

  18. render() {

  19. let {title} = this.props;

  20. let {show, name} = this.state;

  21. let {handleClick} = this;

  22. return (

  23. <div>

  24. <p className="title" onClick={handleClick}>{title}</p>

  25. {show && (

  26. <p className="name">{name}</p>

  27. )}

  28. </div>

  29. );

  30. }

  31. }

总结与展望

本文从Vue组件转化为React组件的具体案例讲述了一种通过代码编译的方式进行不同前端框架代码的转化的思路。我们在生产环境中已经将十多个之前的Vue组件直接转成React组件,但是实际使用过程中研发同学的编码习惯差别也比较大,需要处理很多特殊情况。

这套思路也可以用于小程序互转等场景,减少编码的重复劳动,但是在这类跨端的非保准Web场景需要考虑更多,例如小程序环境特有的组件以及API等,闲鱼技术团队也会持续在这块做尝试。

闲鱼技术
闲鱼技术

加入闲鱼,一起玩些酷的。(阿里巴巴集团闲鱼官方技术号,欢迎同道者技术交流。) 简历投递:guicai.gxy@alibaba-inc.com

工程ReactVue代码框架前端开发抽象语法树
1
相关数据
参数技术

在数学和统计学裡,参数(英语:parameter)是使用通用变量来建立函数和变量之间关系(当这种关系很难用方程来阐述时)的一个数量。

映射技术

映射指的是具有某种特殊结构的函数,或泛指类函数思想的范畴论中的态射。 逻辑和图论中也有一些不太常规的用法。其数学定义为:两个非空集合A与B间存在着对应关系f,而且对于A中的每一个元素x,B中总有有唯一的一个元素y与它对应,就这种对应为从A到B的映射,记作f:A→B。其中,y称为元素x在映射f下的象,记作:y=f(x)。x称为y关于映射f的原象*。*集合A中所有元素的象的集合称为映射f的值域,记作f(A)。同样的,在机器学习中,映射就是输入与输出之间的对应关系。

逻辑技术

人工智能领域用逻辑来理解智能推理问题;它可以提供用于分析编程语言的技术,也可用作分析、表征知识或编程的工具。目前人们常用的逻辑分支有命题逻辑(Propositional Logic )以及一阶逻辑(FOL)等谓词逻辑。

暂无评论
暂无评论~