vue数据双向绑定

发表于

前段时间的react项目，通过最近的闲暇时间，重构了一版vue的PC版本，备用链接,对于vue的数据双向绑定产生，探讨一下。

几种绑定方式

发布者-订阅者模式（backbone.js）

通过自定义的data属性在HTML代码中指明绑定。所有绑定起来的JavaScript对象以及DOM元素都将“订阅”一个发布者对象。任何时候如果JavaScript对象或者一个HTML输入字段被侦测到发生了变化，我们将代理事件到发布者-订阅者模式，这会反过来将变化广播并传播到所有绑定的对象和元素。

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
<input type="text" data-bind-123="name" />
<div  data-bind-123="name"></div>

<script>
function DataBinder(object_id){
    //创建一个简单地PubSub对象
    var pubSub = {
        callbacks: {},

        // 订阅事件
        on:function(msg, callback){
            this.callbacks[msg] = this.callbacks[msg] || [];
            this.callbacks[msg].push(callback);
        },

        // 发布事件
        publish: function(msg){
            this.callbacks[msg] = this.callbacks[msg] || [];
            for(var i=0, len=this.callbacks[msg].length; i<len; i++){
                this.callbacks[msg][i].apply(this,arguments);
            }
        }
    },

    data_attr = "data-bind-" + object_id,
    message = object_id + ":input",

  changeHandler = function(evt){
    var target = evt.target || evt.srcElemnt, //IE8兼容
    prop_name = target.getAttribute(data_attr);

    if(prop_name && prop_name !== ""){
      pubSub.publish(message, prop_name, target.value);
    }
  };

  //监听变化事件并代理到PubSub
  if(document.addEventListener){
    document.addEventListener("input",changeHandler,false);
  }

  //PubSub将变化传播到所有绑定元素
  pubSub.on(message,function(vet,prop_name,new_val){
    var elements = document.querySelectorAll("[" + data_attr + "=" + prop_name + "]"),
    tah_name;

    for(var i = 0,len =elements.length; i < len; i++){
      tag_name = elements[i].tagName.toLowerCase();

      if(tag_name === "input" || tag_name === "textarea" || tag_name === "select"){
        elements[i].value = new_val;
      }else{
        elements[i].innerHTML = new_val;
      }
    }
  });

  return pubSub;
}

function User(uid){
 var binder = new DataBinder(uid),
  user = {
   atttibutes: {},

   //属性设置器使用数据绑定器PubSub来发布变化
   set: function(attr_name,val){
    this.atttibutes[attr_name] = val;
    //使用“publish”方法
    binder.publish(uid+ ":input", attr_name, val,this);
   },

   get: function(attr_name){
    return this.atttibutes[attr_name];
   },

   binder: binder
  };

 binder.on(uid +":input",function(vet,attr_name,new_val,initiator){
  if(initiator !== user){
   user.set(attr_name,new_val);
  }
 })

 return user;
}

var user = new User(123);
user.set("name","Wolfgang");
</script>

脏值检查（angular.js）

angular.js 是通过脏值检测的方式比对数据是否有变更，来决定是否更新视图，最简单的方式就是通过 setInterval() 定时轮询检测数据变动，angular只有在指定的事件触发时进入脏值检测，大致如下：

  • DOM事件，譬如用户输入文本，点击按钮等。( ng-click )
  • XHR响应事件 ( $http )
  • 浏览器Location变更事件 ( $location )
  • Timer事件( $timeout , $interval )
  • 执行 $digest() 或 $apply()

数据劫持（Vue.js）

vue.js 则是采用数据劫持结合发布者-订阅者模式的方式，通过Object.defineProperty()来劫持各个属性的setter，getter，在数据变动时发布消息给订阅者，触发相应的监听回调。

官方介绍

vue当前使用的版本为v2.5.2，官方文档的相关内容是关于深入响应式原理。

当你把一个普通的 JavaScript 对象传给 Vue 实例的 data 选项，Vue 将遍历此对象所有的属性，并使用 Object.defineProperty 把这些属性全部转为 getter/setter。Object.defineProperty 是 ES5 中一个无法 shim 的特性，这也就是为什么 Vue 不支持 IE8 以及更低版本浏览器。
这些 getter/setter 对用户来说是不可见的，但是在内部它们让 Vue 追踪依赖，在属性被访问和修改时通知变化。这里需要注意的问题是浏览器控制台在打印数据对象时 getter/setter 的格式化并不同，所以你可能需要安装 vue-devtools 来获取更加友好的检查接口。
每个组件实例都有相应的 watcher 实例对象，它会在组件渲染的过程中把属性记录为依赖，之后当依赖项的 setter 被调用时，会通知 watcher 重新计算，从而致使它关联的组件得以更新。

vue_data.png

实现

原理实现

当EventListener监听的事件触发，状态发生改变时，通过Object.defineProperty的get/set拦截事件，从而实现数据的双向绑定。

关于Object.defineProperty可在高程笔记-对象1有简单介绍，也可在MDN查看。

1
2
3
4
5
6
<body>
    <input type="text" id="input" />
    <div id="output"></div>

    <script src="app.js"></script>
</body>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/* app.js */
var obj = {}
Object.defineProperty(obj, "data", {
    get: function () {
        console.log("get")
    },
    set: function (newValue) {
        console.log("set:"+newValue)
        document.getElementById("input").value = newValue
        document.getElementById("output").innerText = newValue
    }
})
document.getElementById("input").addEventListener('keyup', function (event) {
    obj.data = event.target.value
})

简单实现

实现双向绑定，需要实现

  • 数据监听器Observer，能够对数据对象的所有属性进行监听，如有变动可拿到最新值并通知订阅者
  • 指令解析器Compile，对每个元素节点的指令进行扫描和解析，根据指令模板替换数据，以及绑定相应的更新函数
  • Watcher，作为连接Observer和Compile的桥梁，能够订阅并收到每个属性变动的通知，执行指令绑定的相应回调函数，从而更新视图
  • 入口函数
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
<!DOCTYPE html>
  <head  lang="en">
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>simple vue</title>
  </head>
  <body>
  <div id="app">
    <input type="text" v-model="text">
    {{text}}
  </div>
  <script type="text/javascript">
　　function Compile(node, vm) {
      if(node) {
        this.$frag = this.nodeToFragment(node, vm);
        return this.$frag;
      }
    }
    Compile.prototype = {
      nodeToFragment: function(node, vm) {
        var self = this;
        var frag = document.createDocumentFragment();
        var child;

        while(child = node.firstChild) {
          self.compileElement(child, vm);
          frag.append(child); // 将所有子节点添加到fragment中
        }
        return frag;
      },
      compileElement: function(node, vm) {
        var reg = /\{\{(.*)\}\}/;

        //节点类型为元素
        if(node.nodeType === 1) {
          var attr = node.attributes;
          // 解析属性
          for(var i = 0; i < attr.length; i++ ) {
            if(attr[i].nodeName == 'v-model') {
              var name = attr[i].nodeValue; // 获取v-model绑定的属性名
              node.addEventListener('input', function(e) {
                // 给相应的data属性赋值，进而触发该属性的set方法
                 vm[name]= e.target.value;
              });
              // node.value = vm[name]; // 将data的值赋给该node
              new Watcher(vm, node, name, 'value');
            }
          };
        }
        //节点类型为text
        if(node.nodeType === 3) {
          if(reg.test(node.nodeValue)) {
            var name = RegExp.$1; // 获取匹配到的字符串
            name = name.trim();
            // node.nodeValue = vm[name]; // 将data的值赋给该node
            new Watcher(vm, node, name, 'nodeValue');
          }
        }
      },
    }
    function Dep() {
      this.subs = [];
    }
    Dep.prototype = {
      addSub: function(sub) {
        this.subs.push(sub);
      },
      notify: function() {
        this.subs.forEach(function(sub) {
          sub.update();
        })
      }
    }
    function Watcher(vm, node, name, type) {
      Dep.target = this;
      this.name = name;
      this.node = node;
      this.vm = vm;
      this.type = type;
      this.update();
      Dep.target = null;
    }

    Watcher.prototype = {
      update: function() {
        this.get();
        this.node[this.type] = this.value; // 订阅者执行相应操作
      },
      // 获取data的属性值
      get: function() {
        this.value = this.vm[this.name]; //触发相应属性的get
      }
    }
    function defineReactive (obj, key, val) {
      var dep = new Dep();
      Object.defineProperty(obj, key, {
        get: function() {
           //添加订阅者watcher到主题对象Dep
          if(Dep.target) {
            // JS的浏览器单线程特性，保证这个全局变量在同一时间内，只会有同一个监听器使用
            dep.addSub(Dep.target);
          }
          return val;
        },
        set: function (newVal) {
          if(newVal === val) return;
          val = newVal;
          console.log(val);
          // 作为发布者发出通知
          dep.notify();
        }
      })
    }
    function observe(obj, vm) {
      Object.keys(obj).forEach(function(key) {
        defineReactive(vm, key, obj[key]);
      })
    }

 　 function Vue(options) {
      this.data = options.data;
      var data = this.data;
      observe(data, this);
      var id = options.el;
      var dom =new Compile(document.getElementById(id),this);
      // 编译完成后，将dom返回到app中
      document.getElementById(id).appendChild(dom);
    }
    var vm = new Vue({
      el: 'app',
      data: {
        text: 'hello world'
      }
    });
  </script>
  </body>
</html>

参考链接
http://www.html-js.com/article/Study-of-twoway-data-binding-JavaScript-talk-about-JavaScript-every-day
https://segmentfault.com/a/1190000006599500

------本文结束 感谢阅读------