专栏首页grain先森前端-30分钟熟悉微信小程序

前端-30分钟熟悉微信小程序

作者:叶小钗  www.cnblogs.com/yexiaochai/p/9431816.html

首先我们来一言以蔽之,什么是微信小程序?PS:这个问题问得好像有些扯:)

小程序是一个不需要下载安装就可使用的应用,它实现了应用触手可及的梦想,用户扫一扫或者搜一下即可打开应用。也体现了用完即走的理念,用户不用关心是否安装太多应用的问题。应用将无处不在,随时可用,但又无需安装卸载。从字面上看小程序具有类似Web应用的热部署能力,在功能上又接近于原生APP。

所以说,其实微信小程序是一套超级Hybrid的解决方案,现在看来,小程序应该是应用场景最广,也最为复杂的解决方案了。

很多公司都会有自己的Hybrid平台,我这里了解到比较不错的是携程的Hybrid平台、阿里的Weex、百度的糯米,但是从应用场景来说都没有微信来得丰富,这里根本的区别是:

微信小程序是给各个公司开发者接入的,其他公司平台多是给自己业务团队使用,这一根本区别,就造就了我们看到的很多小程序不一样的特性:

  • 小程序定义了自己的标签语言WXML
  • 小程序定义了自己的样式语言WXSS
  • 小程序提供了一套前端框架包括对应Native API
  • 禁用浏览器Dom API(这个区别,会影响我们的代码方式)

只要了解到这些区别就会知道为什么小程序会这么设计:

因为小程序是给各个公司的开发做的,其他公司的Hybrid方案是给公司业务团队用的,一般拥有Hybrid平台的公司实力都不错。但是开发小程序的公司实力良莠不齐,所以小程序要做绝对的限制,最大程度的保证框架层(小程序团队)对程序的控制。因为毕竟程序运行在微信这种体量的APP中

之前我也有一个疑惑为什么微信小程序会设计自己的标签语言,也在知乎看到各种各样的回答,但是如果出于设计层面以及应用层面考虑的话:这样会有更好的控制,而且我后面发现微信小程序事实上依旧使用的是webview做渲染(这个与我之前认为微信是NativeUI是向左的),但是如果我们使用的微信限制下面的标签,这个是有限的标签,后期想要换成NativeUI会变得更加轻易:

另一方面,经过之前的学习,我这边明确可以得出一个感受:

  • 小程序的页面核心是标签,标签是不可控制的(我暂时没用到js操作元素的方法),只能按照微信给的玩法玩,标签控制显示是我们的view
  • 标签的展示只与data有关联,和js是隔离的,没有办法在标签中调用js的方法
  • 而我们的js的唯一工作便是根据业务改变data,重新引发页面渲染,以后别想操作DOM,别想操作Window对象了,改变开发方式,改变开发方式,改变开发方式!

this.setData({'wxml': `   <my-component>   <view>动态插入的节点</view>   </my-component> `});

然后可以看到这个是一个MVC模型

每个页面的目录是这个样子的:

project ├── pages |   ├── index |   |   ├── index.json  index 页面配置 |   |   ├── index.js    index 页面逻辑 |   |   ├── index.wxml  index 页面结构 |   |   └── index.wxss  index 页面样式表 |   └── log |       ├── log.json    log 页面配置 |       ├── log.wxml    log 页面逻辑 |       ├── log.js      log 页面结构 |       └── log.wxss    log 页面样式表 ├── app.js              小程序逻辑 ├── app.json            小程序公共设置 └── app.wxss            小程序公共样式表

每个组件的目录也大概是这个样子的,大同小异,但是入口是Page层。

小程序打包后的结构(这里就真的不懂了,引用:小程序底层框架实现原理解析):

所有的小程序基本都最后都被打成上面的结构

1、WAService.js 框架JS库,提供逻辑层基础的API能力

2、WAWebview.js 框架JS库,提供视图层基础的API能力

3、WAConsole.js 框架JS库,控制台

4、app-config.js 小程序完整的配置,包含我们通过app.json里的所有配置,综合了默认配置型

5、app-service.js 我们自己的JS代码,全部打包到这个文件

6、page-frame.html 小程序视图的模板文件,所有的页面都使用此加载渲染,且所有的WXML都拆解为JS实现打包到这里

7、pages 所有的页面,这个不是我们之前的wxml文件了,主要是处理WXSS转换,使用js插入到header区域

从设计的角度上说,小程序采用的组件化开发的方案,除了页面级别的标签,后面全部是组件,而组件中的标签view、data、js的关系应该是与page是一致的,这个也是我们平时建议的开发方式,将一根页面拆分成一个个小的业务组件或者UI组件:

所有的小程序基本都最后都被打成上面的结构

  • WAService.js 框架JS库,提供逻辑层基础的API能力
  • WAWebview.js 框架JS库,提供视图层基础的API能力
  • WAConsole.js 框架JS库,控制台
  • app-config.js 小程序完整的配置,包含我们通过app.json里的所有配置,综合了默认配置型
  • app-service.js 我们自己的JS代码,全部打包到这个文件
  • page-frame.html 小程序视图的模板文件,所有的页面都使用此加载渲染,且所有的WXML都拆解为JS实现打包到这里
  • pages 所有的页面,这个不是我们之前的wxml文件了,主要是处理WXSS转换,使用js插入到header区域

从设计的角度上说,小程序采用的组件化开发的方案,除了页面级别的标签,后面全部是组件,而组件中的标签view、data、js的关系应该是与page是一致的,这个也是我们平时建议的开发方式,将一根页面拆分成一个个小的业务组件或者UI组件:

从我写业务代码过程中,觉得整体来说还是比较顺畅的,小程序是有自己一套完整的前端框架的,并且释放给业务代码的主要就是page,而page只能使用标签和组件,所以说框架的对业务的控制力度很好。

最后我们从工程角度来看微信小程序的架构就更加完美了,小程序从三个方面考虑了业务者的感受:

  • 开发工具+调试工具
  • 开发基本模型(开发基本标准WXML、WXSS、JS、JSON)
  • 完善的构建(对业务方透明)
  • 自动化上传离线包(对业务费透明离线包逻辑)
  • 监控统计逻辑

所以,微信小程序从架构上和使用场景来说是很令人惊艳的,至少惊艳了我……所以我们接下来在开发层面对他进行更加深入的剖析,我们这边最近一直在做基础服务,这一切都是为了完善技术体系,这里对于前端来说便是我们需要做一个Hybrid体系,如果做App,React Native也是不错的选择,但是一定要有完善的分层:

  • 底层框架解决开发效率,将复杂的部分做成一个黑匣子,给页面开发展示的只是固定的三板斧,固定的模式下开发即可
  • 工程部门为业务开发者封装最小化开发环境,最优为浏览器,确实不行便为其提供一个类似浏览器的调试环境

如此一来,业务便能快速迭代,因为业务开发者写的代码大同小异,所以底层框架配合工程团队(一般是同一个团队),便可以在底层做掉很多效率性能问题。

稍微大点的公司,稍微宽裕的团队,还会同步做很多后续的性能监控、错误日志工作,如此形成一套文档->开发->调试->构建->发布->监控、分析 为一套完善的技术体系

如果形成了这么一套体系,那么后续就算是内部框架更改、技术革新,也是在这个体系上改造,这块微信小程序是做的非常好的。但很可惜,很多其他公司团队只会在这个路径上做一部分,后面由于种种原因不在深入,有可能是感觉没价值,而最恐怖的行为是,自己的体系没形成就贸然的换基础框架,戒之慎之啊!好了闲话少说,我们继续接下来的学习。

微信小程序的执行流程

微信小程序为了对业务方有更强的控制,App层做的工作很有限,我后面写demo的时候根本没有用到app.js,所以我这里认为app.js只是完成了一个路由以及初始化相关的工作,这个是我们看得到的,我们看不到的是底层框架会根据app.json的配置将所有页面js都准备好。

我这里要表达的是,我们这里配置了我们所有的路由:

"pages":[   "pages/index/index",   "pages/list/list",   "pages/logs/logs" ],

微信小程序一旦载入,会开3个webview,装载3个页面的逻辑,完成基本的实例化工作,只显示首页!这个是小程序为了优化页面打开速度所做的工作,也势必会浪费一些资源,所以到底是全部打开或者预加载几个,详细底层Native会根据实际情况动态变化,我们也可以看到,从业务层面来说,要了解小程序的执行流程,其实只要能了解Page的流程就好了,关于Page生命周期,除了释放出来的API:onLoad -> onShow -> onReady -> onHide等,官方还出了一张图进行说明:

Native层在载入小程序时候,起了两个线程一个的view Thread一个是AppService Thread,我这边理解下来应该就是程序逻辑执行与页面渲染分离,小程序的视图层目前使用 WebView 作为渲染载体,而逻辑层是由独立的 JavascriptCore 作为运行环境。在架构上,WebView 和 JavascriptCore 都是独立的模块,并不具备数据直接共享的通道。当前,视图层和逻辑层的数据传输,实际上通过两边提供的 evaluateJavascript 所实现。即用户传输的数据,需要将其转换为字符串形式传递,同时把转换后的数据内容拼接成一份 JS 脚本,再通过执行 JS 脚本的形式传递到两边独立环境。而 evaluateJavascript 的执行会受很多方面的影响,数据到达视图层并不是实时的。

因为之前我认为页面是使用NativeUI做渲染跟Webview没撒关系,便觉得这个图有问题,但是后面实际代码看到了熟悉的shadow-dom以及Android可以看到哪部分是Web的,其实小程序主体还是使用的浏览器渲染的方式,还是webview装载HTML和CSS的逻辑,最后我发现这张图是没有问题的,有问题的是我的理解,哈哈,这里我们重新解析这张图:

WXML先会被编译成JS文件,引入数据后在WebView中渲染,这里可以认为微信载入小程序时同时初始化了两个线程,分别执行彼此逻辑:

  • WXML&CSS编译形成的JS View实例化结束,准备结束时向业务线程发送通知
  • 业务线程中的JS Page部分同步完成实例化结束,这个时候接收到View线程部分的等待数据通知,将初始化data数据发送给View
  • View线程接到数据,开始渲染页面,渲染结束执行通知Page触发onReady事件

这里翻开源码,可以看到,应该是全局控制器完成的Page实例化,完成后便会执行onLoad事件,但是在执行前会往页面发通知:

__appServiceSDK__.invokeWebviewMethod({     name: "appDataChange",     args: o({}, e, {         complete: n     }),     webviewIds: [t] })

真实的逻辑是这样的,全局控制器会完成页面实例化,这个是根据app.json中来的,全部完成实例化存储起来然后选择第一个page实例执行一些逻辑,然后通知view线程,即将执行onLoad事件,因为view线程和业务线程是两个线程,所以不会造成阻塞,view线程根据初始数据完成渲染,而业务线程继续后续逻辑,执行onLoad,如果onLoad中有setData,那么会进入队列继续通知view线程更新。

所以我个人感觉微信官网那张图不太清晰,我这里重新画了一个图:

再引用一张其他地方的图:

模拟实现

都这个时候了,不来个简单的小程序框架实现好像有点不对,我们做小程序实现的主要原因是想做到一端代码三端运行:web、小程序、Hybrid甚至Servce端

我们这里没有可能实现太复杂的功能,这里想的是就实现一个基本的页面展示带一个最基本的标签即可,只做Page一块的简单实现,让大家能了解到小程序可能的实现,以及如何将小程序直接转为H5的可能走法

<view>   <!-- 以下是对一个自定义组件的引用 -->   <my-component inner-text="组件数据"></my-component>   <view>{{pageData}}</view> </view>

Page({   data: {     pageData: '页面数据'   },   onLoad: function () {     console.log('onLoad')   }, })

<!-- 这是自定义组件的内部WXML结构 --> <view class="inner">   {{innerText}} </view> <slot></slot>

Component({   properties: {     // 这里定义了innerText属性,属性值可以在组件使用时指定     innerText: {       type: String,       value: 'default value',     }   },   data: {     // 这里是一些组件内部数据     someData: {}   },   methods: {     // 这里是一个自定义方法     customMethod: function () { }   } })

我们直接将小程序这些代码拷贝一份到我们的目录:

我们需要做的就是让这段代码运行起来,而这里的目录是我们最终看见的目录,真实运行的时候可能不是这个样,运行之前项目会通过我们的工程构建,变成可以直接运行的代码,而我这里思考的可以运行的代码事实上是一个模块,所以我们这里从最终结果反推、分拆到开发结构目录,我们首先将所有代码放到index.html,可能是这样的:

<!DOCTYPE html> <html lang="en"> <head>   <meta charset="UTF-8">   <title>Title</title> </head> <body> <script type="text/javascript" src="libs/zepto.js" ></script> <script type="text/javascript">   class View {     constructor(opts) {       this.template = '<view>{{pageShow}}</view><view class="ddd" is-show="{{pageShow}}" >{{pageShow}}<view class="c1">{{pageData}}</view></view>';       //由控制器page传入的初始数据或者setData产生的数据       this.data = {         pageShow: 'pageshow',         pageData: 'pageData',         pageShow1: 'pageShow1'       };       this.labelMap = {         'view': 'div',         '#text': 'span'       };       this.nodes = {};       this.nodeInfo = {};     }     /*       传入一个节点,解析出一个节点,并且将节点中的数据以初始化数据改变       并且将其中包含{{}}标志的节点信息记录下来     */     _handlerNode (node) {       let reg = /{{([sS]+?)}}/;       let result, name, value, n, map = {};       let attrs , i, len, attr;       name = node.nodeName;       attrs = node.attributes;       value = node.nodeValue;       n = document.createElement(this.labelMap[name.toLowerCase()] || name);       //说明是文本,需要记录下来了       if(node.nodeType === 3) {         n.innerText =  this.data[value] || '';         result =  reg.exec(value);         if(result) {           n.innerText =  this.data[result[1]] || '';           if(!map[result[1]]) map[result[1]] = [];           map[result[1]].push({             type: 'text',             node: n           });         }       }       if(attrs) {         //这里暂时只处理属性和值两种情况,多了就复杂10倍了         for (i = 0, len = attrs.length; i < len; i++) {           attr = attrs[i];           result = reg.exec(attr.value);           n.setAttribute(attr.name, attr.value);           //如果有node需要处理则需要存下来标志           if (result) {             n.setAttribute(attr.name, this.data[result[1]] || '');             //存储所有会用到的节点,以便后面动态更新             if (!map[result[1]]) map[result[1]] = [];             map[result[1]].push({               type: 'attr',               name: attr.name,               node: n             });           }         }       }       return {         node: n,         map: map       }     }     //遍历一个节点的所有子节点,如果有子节点继续遍历到没有为止     _runAllNode(node, map, root) {       let nodeInfo = this._handlerNode(node);       let _map = nodeInfo.map;       let n = nodeInfo.node;       let k, i, len, children = node.childNodes;       //先将该根节点插入到上一个节点中       root.appendChild(n);       //处理map数据,这里的map是根对象,最初的map       for(k in _map) {         if(map[k]) {           map[k].push(_map[k]);         } else {           map[k] = _map[k];         }       }       for(i = 0, len = children.length; i < len; i++) {         this._runAllNode(children[i], map, n);       }     }     //处理每个节点,翻译为页面识别的节点,并且将需要操作的节点记录     splitTemplate () {       let nodes = $(this.template);       let map = {}, root = document.createElement('div');       let i, len;       for(i = 0, len = nodes.length; i < len; i++) {         this._runAllNode(nodes[i], map, root);       }       window.map = map;       return root     }       //拆分目标形成node,这个方法过长,真实项目需要拆分     splitTemplate1 () {       let template = this.template;       let node = $(this.template)[0];       let map = {}, n, name, root = document.createElement('div');       let isEnd = false, index = 0, result;       let attrs, i, len, attr;       let reg = /{{([sS]+?)}}/;       window.map = map;       //开始遍历节点,处理       while (!isEnd) {         name = node.localName;         attrs = node.attributes;         value = node.nodeValue;         n = document.createElement(this.labelMap[name] || name);         //说明是文本,需要记录下来了         if(node.nodeType === 3) {           n.innerText =  this.data[value] || '';           result =  reg.exec(value);           if(result) {             n.innerText =  this.data[value] || '';             if(!map[value]) map[value] = [];             map[value].push({               type: 'text',               node: n             });           }         }         //这里暂时只处理属性和值两种情况,多了就复杂10倍了         for(i = 0, len = attrs.length; i < len; i++) {           attr = attrs[i];           result =  reg.exec(attr.value);           n.setAttribute(attr.name, attr.value);           //如果有node需要处理则需要存下来标志           if(result) {             n.setAttribute(attr.name, this.data[result[1]] || '');             //存储所有会用到的节点,以便后面动态更新             if(!map[result[1]]) map[result[1]] = [];             map[result[1]].push({               type: 'attr',               name: attr.name,               node: n             });           }         } debugger         if(index === 0) root.appendChild(n);         isEnd = true;         index++;       }       return root;       console.log(node)     }   }   let view = new View();   document.body.appendChild(window.node) </script> </body> </html>

这段代码,非常简单:

① 设置了一段模板,甚至,我们这里根本不关系其格式化状态,直接写成一行方便处理

this.template = '<view>{{pageShow}}</view><view class="ddd" is-show="{{pageShow}}" >{{pageShow}}<view class="c1">{{pageData}}</view></view>';

② 然后我们将这段模板转为node节点(这里可以不用zepto,但是模拟实现怎么简单怎么来吧),然后遍历处理所有节点,我们就可以处理我们的数据了,最终形成了这个html:

<div><div><span>ffsd</span></div><div class="ddd" is-show="pageshow"><span>pageshow</span><div class="c1"><span>pageData</span></div></div></div>

③ 与此同时,我们存储了一个对象,这个对象包含所有与之相关的节点:

这个对象是所有setData会影响到node的一个映射表,后面调用setData的时候,便可以直接操作对应的数据了,这里我们分拆我们代码,形成了几个关键部分,首先是View类,这个对应我们的模板,是核心类:

//View为模块的实现,主要用于解析目标生产node class View {   constructor(template) {     this.template = template;     //由控制器page传入的初始数据或者setData产生的数据     this.data = {};     this.labelMap = {       'view': 'div',       '#text': 'span'     };     this.nodes = {};     this.root = {};   }   setInitData(data) {     this.data = data;   }   //数据便会引起的重新渲染   reRender(data, allData) {     this.data = allData;     let k, v, i, len, j, len2, v2;     //开始重新渲染逻辑,寻找所有保存了的node     for(k in data) {       if(!this.nodes[k]) continue;       for(i = 0, len = this.nodes[k].length; i < len; i++) {         for(j = 0; j < this.nodes[k][i].length; j++) {           v = this.nodes[k][i][j];           if(v.type === 'text') {             v.node.innerText = data[k];           } else if(v.type === 'attr') {             v.node.setAttribute(v.name, data[k]);           }         }       }     }   }   /*     传入一个节点,解析出一个节点,并且将节点中的数据以初始化数据改变     并且将其中包含{{}}标志的节点信息记录下来   */   _handlerNode (node) {     let reg = /{{([sS]+?)}}/;     let result, name, value, n, map = {};     let attrs , i, len, attr;     name = node.nodeName;     attrs = node.attributes;     value = node.nodeValue;     n = document.createElement(this.labelMap[name.toLowerCase()] || name);     //说明是文本,需要记录下来了     if(node.nodeType === 3) {       n.innerText =  this.data[value] || '';       result =  reg.exec(value);       if(result) {         n.innerText =  this.data[result[1]] || '';         if(!map[result[1]]) map[result[1]] = [];         map[result[1]].push({           type: 'text',           node: n         });       }     }     if(attrs) {       //这里暂时只处理属性和值两种情况,多了就复杂10倍了       for (i = 0, len = attrs.length; i < len; i++) {         attr = attrs[i];         result = reg.exec(attr.value);         n.setAttribute(attr.name, attr.value);         //如果有node需要处理则需要存下来标志         if (result) {           n.setAttribute(attr.name, this.data[result[1]] || '');           //存储所有会用到的节点,以便后面动态更新           if (!map[result[1]]) map[result[1]] = [];           map[result[1]].push({             type: 'attr',             name: attr.name,             node: n           });         }       }     }     return {       node: n,       map: map     }   }   //遍历一个节点的所有子节点,如果有子节点继续遍历到没有为止   _runAllNode(node, map, root) {     let nodeInfo = this._handlerNode(node);     let _map = nodeInfo.map;     let n = nodeInfo.node;     let k, i, len, children = node.childNodes;     //先将该根节点插入到上一个节点中     root.appendChild(n);     //处理map数据,这里的map是根对象,最初的map     for(k in _map) {       if(!map[k]) map[k] = [];       map[k].push(_map[k]);     }     for(i = 0, len = children.length; i < len; i++) {       this._runAllNode(children[i], map, n);     }   }   //处理每个节点,翻译为页面识别的节点,并且将需要操作的节点记录   splitTemplate () {     let nodes = $(this.template);     let map = {}, root = document.createElement('div');     let i, len;     for(i = 0, len = nodes.length; i < len; i++) {       this._runAllNode(nodes[i], map, root);     }     this.nodes = map;     this.root = root;   }   render() {     let i, len;     this.splitTemplate();     for(i = 0, len = this.root.childNodes.length; i< len; i++)       document.body.appendChild(this.root.childNodes[0]);   } }

这个类主要完成的工作是:

  • 接受传入的template字符串(直接由index.wxml读出)
  • 解析template模板,生成字符串和兼职与node映射表,方便后期setData导致的改变
  • 渲染和再次渲染工作

然后就是我们的Page类的实现了,这里反而比较简单(当然这里的实现是不完善的):

//这个为js罗杰部分实现,后续会释放工厂方法 class PageClass {   //构造函数,传入对象   constructor(opts) {     //必须拥有的参数     this.data = {};     Object.assign(this, opts);   }   //核心方法,每个Page对象需要一个模板实例   setView(view) {     this.view = view;   }   //核心方法,设置数据后会引发页面刷新   setData(data) {     Object.assign(this.data, data);     //只影响改变的数据     this.view.reRender(data, this.data)   }   render() {     this.view.setInitData(this.data);     this.view.render();     if(this.onLoad) this.onLoad();   } }

现在轮着我们实际调用方,Page方法出场了:

function Page (data) {   let page = new PageClass(data);   return page; }

基本上什么都没有干的感觉,调用层代码这样写:

function main() {   let view = new View('<view>{{pageShow}}</view><view class="ddd" is-show="{{pageShow}}" >{{pageShow}}<view class="c1">{{pageData}}</view></view>');   let page = Page({     data: {       pageShow: 'pageshow',       pageData: 'pageData',       pageShow1: 'pageShow1'     },     onLoad: function () {       this.setData({         pageShow: '我是pageShow啊'       });     }   });   page.setView(view);   page.render(); } main();

于是,我们可以看到页面的变化,由开始的初始化页面到执行onLoad时候的变化:

这里是最终完整的代码:

<!DOCTYPE html> <html lang="en"> <head>   <meta charset="UTF-8">   <title>Title</title> </head> <body> <script type="text/javascript" src="libs/zepto.js" ></script> <script type="text/javascript"> //这个为js罗杰部分实现,后续会释放工厂方法 class PageClass {   //构造函数,传入对象   constructor(opts) {     //必须拥有的参数     this.data = {};     Object.assign(this, opts);   }   //核心方法,每个Page对象需要一个模板实例   setView(view) {     this.view = view;   }   //核心方法,设置数据后会引发页面刷新   setData(data) {     Object.assign(this.data, data);     //只影响改变的数据     this.view.reRender(data, this.data)   }   render() {     this.view.setInitData(this.data);     this.view.render();     if(this.onLoad) this.onLoad();   } } //View为模块的实现,主要用于解析目标生产node class View {   constructor(template) {     this.template = template;     //由控制器page传入的初始数据或者setData产生的数据     this.data = {};     this.labelMap = {       'view': 'div',       '#text': 'span'     };     this.nodes = {};     this.root = {};   }   setInitData(data) {     this.data = data;   }   //数据便会引起的重新渲染   reRender(data, allData) {     this.data = allData;     let k, v, i, len, j, len2, v2;     //开始重新渲染逻辑,寻找所有保存了的node     for(k in data) {       if(!this.nodes[k]) continue;       for(i = 0, len = this.nodes[k].length; i < len; i++) {         for(j = 0; j < this.nodes[k][i].length; j++) {           v = this.nodes[k][i][j];           if(v.type === 'text') {             v.node.innerText = data[k];           } else if(v.type === 'attr') {             v.node.setAttribute(v.name, data[k]);           }         }       }     }   }   /*     传入一个节点,解析出一个节点,并且将节点中的数据以初始化数据改变     并且将其中包含{{}}标志的节点信息记录下来   */   _handlerNode (node) {     let reg = /{{([sS]+?)}}/;     let result, name, value, n, map = {};     let attrs , i, len, attr;     name = node.nodeName;     attrs = node.attributes;     value = node.nodeValue;     n = document.createElement(this.labelMap[name.toLowerCase()] || name);     //说明是文本,需要记录下来了     if(node.nodeType === 3) {       n.innerText =  this.data[value] || '';       result =  reg.exec(value);       if(result) {         n.innerText =  this.data[result[1]] || '';         if(!map[result[1]]) map[result[1]] = [];         map[result[1]].push({           type: 'text',           node: n         });       }     }     if(attrs) {       //这里暂时只处理属性和值两种情况,多了就复杂10倍了       for (i = 0, len = attrs.length; i < len; i++) {         attr = attrs[i];         result = reg.exec(attr.value);         n.setAttribute(attr.name, attr.value);         //如果有node需要处理则需要存下来标志         if (result) {           n.setAttribute(attr.name, this.data[result[1]] || '');           //存储所有会用到的节点,以便后面动态更新           if (!map[result[1]]) map[result[1]] = [];           map[result[1]].push({             type: 'attr',             name: attr.name,             node: n           });         }       }     }     return {       node: n,       map: map     }   }   //遍历一个节点的所有子节点,如果有子节点继续遍历到没有为止   _runAllNode(node, map, root) {     let nodeInfo = this._handlerNode(node);     let _map = nodeInfo.map;     let n = nodeInfo.node;     let k, i, len, children = node.childNodes;     //先将该根节点插入到上一个节点中     root.appendChild(n);     //处理map数据,这里的map是根对象,最初的map     for(k in _map) {       if(!map[k]) map[k] = [];       map[k].push(_map[k]);     }     for(i = 0, len = children.length; i < len; i++) {       this._runAllNode(children[i], map, n);     }   }   //处理每个节点,翻译为页面识别的节点,并且将需要操作的节点记录   splitTemplate () {     let nodes = $(this.template);     let map = {}, root = document.createElement('div');     let i, len;     for(i = 0, len = nodes.length; i < len; i++) {       this._runAllNode(nodes[i], map, root);     }     this.nodes = map;     this.root = root;   }   render() {     let i, len;     this.splitTemplate();     for(i = 0, len = this.root.childNodes.length; i< len; i++)       document.body.appendChild(this.root.childNodes[0]);   } } function Page (data) {   let page = new PageClass(data);   return page; } function main() {   let view = new View('<view>{{pageShow}}</view><view class="ddd" is-show="{{pageShow}}" >{{pageShow}}<view class="c1">{{pageData}}</view></view>');   let page = Page({     data: {       pageShow: 'pageshow',       pageData: 'pageData',       pageShow1: 'pageShow1'     },     onLoad: function () {       this.setData({         pageShow: '我是pageShow啊'       });     }   });   page.setView(view);   page.render(); } main(); </script> </body> </html>

我们简单的模拟便先到此结束,这里结束的比较仓促有一些原因:

  • 这段代码可以是最终打包构建形成的代码,但是我这里的完成度只有百分之一,后续需要大量的构建相关介入
  • 这篇文章目的还是接受开发基础,而本章模拟实现太过复杂,如果篇幅大了会主旨不清
  • 这个是最重要的点,我一时也写不出来啊!!!,所以各位等下个长篇,小程序前端框架模拟实现吧
  • 如果继续实现,这里马上要遇到组件处理、事件模型、分文件构建等高端知识,时间会拉得很长

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • JS实现简单的Vue

    vue的使用相信大家都很熟练了,使用起来简单。但是大部分人不知道其内部的原理是怎么样的,今天我们就来一起实现一个简单的vue。

    grain先森
  • 前端-微信小程序开发(6):一个业务页面的完成

    github地址:https://github.com/yexiaochai/wxdemo

    grain先森
  • JS 继承的多种方法

    学过java的同学应该都知道,继承是java的重要特点之一,许多面向对象的语言都支持两种继承方式:接口继承和实现继承,接口继承只继承方法签名,而实现继承则继承实...

    grain先森
  • Go 语言基础--map 浅析

    map通常是一种无序键值对的集合,map存在的意义主要是利用map的结构根据key来快速检索数据,在go中也是这样的。 map 也是一种集合,我们可以像遍历数...

    邹志全
  • Go基础——Map

    map声明语法为map[K]V,其中K和V分别对应key和value。map中所有的key都有相同的类型,所有的value也有着相同的类型,但是key和valu...

    羊羽shine
  • python3的一个奇怪设计--map

    这个改动真是太不正常了,ruby、js和lisp都没这么干的。我也没搞懂这样做有什么好处?

    py3study
  • map 学习(上)——C++中 map 的使用

    map 学习(上)——C++中 map 的使用 欠下数据结构的债,迟早是要还的…… 最近写毕业论文过程中,需要用到哈希表的数据结构,此外空闲时间在刷 Leetc...

    剑影啸清寒
  • Basemap工具函数(1)

    添加一个经度值到经度数组中,并且添加一列值到数据数组中。当数据覆盖全部经度时,非常有利于添加缺省值。

    bugsuse
  • 程序eclipse下run和debug不一致问题

        公司核心代码,这里不上了,主要将如何发现问题、如何排查问题和如何解决问题。

    尚浩宇
  • go语言map

    map是一种常用的数据存储结构,也叫HashMap, 散列表,字典等。通过键,可以快速的访问所存储的值。

    暮雨

扫码关注云+社区

领取腾讯云代金券