这篇文章主要记录学习 JS 双向绑定过程中的一些概念与具体的实现
MVVM 具体概念
MVVM 中有一些概念是通用的，具体如下
Directive （指令）
自定义的执行函数，例如 Vue 中的 v-click、v-bind 等。这些函数封装了 DOM 的一些基本可复用函数API。
Filter （过滤器）
用户希望对传入的初始数据进行处理，然后将处理结果交给 Directive 或者下一个 Filter。例如：v-bind=”time | formatTime”。formatTime 是将 time 转换成指定格式的 Filter 函数。
表达式
类似前端普通的页面模板表达式，作用是控制页面内容安装具体的条件显示。例如：if…else 等
ViewModel
传入的 Model 数据在内存中存放，提供一些基本的操作 API 给开发者，使其能够对数据进行读取与修改
双向绑定（数据变更检测）
View 层的变化改变 Model：通过给元素添加 onchange 事件来触发对 Model 数据进行修改
Model 层的变化改变 View：
实现方式
手动触发绑定
即 Model 对象改变之后，需要显示的去触发 View 的更新
首先编写 HTML 页面
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| <!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>Two way binding</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body>
<input q-value="value" type="text" id="input">
<span q-text="value" id="el"></span>
</body>
<script src="way_1.js"></script>
</html>
|
编写实现 MVVM 的 代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
let elems = [document.getElementById('el'), document.getElementById('input')]
let data = {
value: 'hello'
}
let directive = {
text: function(text) {
this.innerHTML = text
},
value: function(value) {
this.setAttribute('value', value)
this.value = value
}
}
function scan() {
for (let elem of elems) {
elem.directive = []
for (let attr of elem.attributes) {
if (attr.nodeName.indexOf('q-') >= 0) {
directive[attr.nodeName.slice(2)].call(elem, data[attr.nodeValue])
elem.directive.push(attr.nodeName.slice(2))
}
}
}
}
function ViewModelSet(key, value) {
data[key] = value
scan()
}
elems[1].addEventListener('keyup', function(e) {
ViewModelSet('value', e.target.value)
}, false)
scan()
setTimeout(() => {
ViewModelSet('value', 'hello world')
}, 1000);
|
数据劫持
数据劫持是目前比较广泛的方式，Vue 的双向绑定就是通过数据劫持实现。实现方式是通过 Object.defineProperty 和 Object.defineProperies 方法对 Model 对象的 get 和 set 函数进行监听。当有数据读取或赋值操作时，扫描（或者通知）对应的元素执行 Directive 函数，实现 View 的刷新。
HTML 的代码不变，js 代码如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
let elems = [document.getElementById('el'), document.getElementById('input')]
let data = {
value: 'hello'
}
let directive = {
text: function(text) {
this.innerHTML = text
},
value: function(value) {
this.setAttribute('value', value)
this.value = value
}
}
function defineGetAndSet(obj, propName) {
let bValue
Object.defineProperty(obj, propName, {
get: function() {
return bValue
},
set: function(value) {
bValue = value
scan()
},
enumerable: true,
configurable: true
})
}
elems[1].addEventListener('keyup', function(e) {
data.value = e.target.value
}, false)
function scan() {
for (let elem of elems) {
elem.directive = []
for (let attr of elem.attributes) {
if (attr.nodeName.indexOf('q-') >= 0) {
directive[attr.nodeName.slice(2)].call(elem, data[attr.nodeValue])
elem.directive.push(attr.nodeName.slice(2))
}
}
}
}
scan()
defineGetAndSet(data, 'value')
setTimeout(() => {
data.value = 'Hello world'
}, 1000);
|
基于 Proxy 的实现
Proxy 是 ES6 中的新特性。可以在已有的对象基础上定义一个新对象，并重新定义对象原型上的方法。例如 get 和 set 方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
let elems = [document.getElementById('el'), document.getElementById('input')]
let directive = {
text: function(text) {
this.innerHTML = text
},
value: function(value) {
this.setAttribute('value', value)
this.value = value
}
}
let data = new Proxy({}, {
get: function(target, key, receiver) {
return target.value
},
set: function (target, key, value, receiver) {
target.value = value
scan()
return target.value
}
})
elems[1].addEventListener('keyup', function(e) {
data.value = e.target.value
}, false)
function scan() {
for (let elem of elems) {
elem.directive = []
for (let attr of elem.attributes) {
if (attr.nodeName.indexOf('q-') >= 0) {
directive[attr.nodeName.slice(2)].call(elem, data[attr.nodeValue])
elem.directive.push(attr.nodeName.slice(2))
}
}
}
}
data['value'] = 'Hello'
scan()
setTimeout(() => {
data.value = 'Hello world'
}, 1000);
|
脏数据监测
基本原理是在 Model 对象的属性值发生变化的时候找到与该属性值相关的所有元素，然后判断数据是否发生变化，若变化则更新 View。
编写页面代码如下：
1
2
3
4
5
6
7
8
9
10
11
12
| <!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>Two way binding</title>
</head>
<body>
<input q-event="value" q-bind="value" type="text" id="input">
<span q-event="text" q-bind="value" id="el"></span>
</body>
<script src="way_2.js"></script>
</html>
|
js 代码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
let elems = [document.getElementById('el'), document.getElementById('input')]
let data = {
value: 'hello'
}
let directive = {
text: function(text) {
this.innerHTML = text
},
value: function(value) {
this.setAttribute('value', value)
this.value = value
}
}
function digest(elems) {
for (let elem of elems) {
if (elem.directive === undefined) {
elem.directive = {}
}
for (let attr of elem.attributes) {
if (attr.nodeName.indexOf('q-event') >= 0) {
let dataKey = elem.getAttribute('q-bind') || undefined
if (elem.directive[attr.nodeValue] !== data[dataKey]) {
directive[attr.nodeValue].call(elem, data[dataKey])
elem.directive[attr.nodeValue] = data[dataKey]
}
}
}
}
}
function $digest(value) {
let list = document.querySelectorAll('[q-bind=' + value + ']')
digest(list)
}
elems[1].addEventListener('keyup', function(e) {
data.value = e.target.value
$digest(e.target.getAttribute('q-bind'))
}, false)
$digest('value')
setTimeout(() => {
data.value = "Hello world"
$digest('value')
}, 1000);
|
总结
上面只是简单地实现了双向绑定，但实际上一个完整的 MVVM 框架要考虑很多东西。在上面的实现中数据劫持的方法更新View 是使用了 Scan 函数，但实际的实现中（比如 Vue）是使用了发布订阅的模式。它只会去更新那些与该 Model 数据绑定的元素，而不会去扫描所有元素。而在脏数据检测中，它去找到了所有绑定的元素，然后判断数据是否发生变化，这种方式只有一定的性能开销的。
参考
《现代前端技术解析》
代码下载