【第1362期】微信小程序30分钟从陌生到熟悉(上)

2018-10-22 07:49:09 织梦安装使用
  • 文章介绍
叶小钗 前端早读课

前言

看到这个,一看就不是30分钟就能完的,有点长,慢一点看。今日早读文章由@叶小钗分享。

正文从这开始~

首先我们来一言以蔽之,什么是微信小程序?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>

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

  • 这段代码可以是最终打包构建形成的代码,但是我这里的完成度只有百分之一,后续需要大量的构建相关介入

  • 这篇文章目的还是接受开发基础,而本章模拟实现太过复杂,如果篇幅大了会主旨不清

  • 这个是最重要的点,我一时也写不出来啊!!!,所以各位等下个长篇,小程序前端框架模拟实现吧

  • 如果继续实现,这里马上要遇到组件处理、事件模型、分文件构建等高端知识,时间会拉得很长


    阅读原文
    阅读原文

    上一篇: 小程序入门 之 Markdown

    下一篇: 工地搞成这样,是要相亲啊! ..

    相关文档推荐

    精品模板推荐

     2020-07-29   18166  0金币下载

     2020-07-27   65338  0金币下载

     2020-07-27   65333  0金币下载

     2020-06-22   57995  0金币下载

     2020-06-13   62585  0金币下载

     2020-06-13   62587  0金币下载

    专业的织梦模板定制下载站,在线购买后即可下载!

    商业源码

    跟版网模板,累计帮助5000+客户企业成功建站,为草根创业提供助力!

    立刻开启你的建站之旅
    
    QQ在线客服

    服务热线

    织梦建站咨询