Page 172 - Node.js开发指南
P. 172

附录 A  JavaScript 的高级特性    165


                   };                                                                                 1

                   Function.prototype.clone = function() {
                     var that = this;
                     var newFunc = function() {
                       return that.apply(this, arguments);
                     };                                                                               2
                     for (var i in this) {
                       newFunc[i] = this[i];
                     }
                     return newFunc;
                                                                                                      3
                   };

                   var obj = {
                     name: 'byvoid',
                     likes: ['node'],
                                                                                                      4
                     display: function() {
                       console.log(this.name);
                     },
                   };

                   var newObj = obj.clone();                                                          5
                   newObj.likes.push('python');
                   console.log(obj.likes); // 输出 [ 'node' ]
                   console.log(newObj.likes); // 输出 [ 'node', 'python' ]
                   console.log(newObj.display == obj.display); // 输出 false
                   上面这个实现看起来很完美,它不仅递归地复制了对象复杂的结构,还实现了函数的深                                             6
               拷贝。这个方法在大多数情况下都很好用,但有一种情况它却无能为力,例如下面的代码:

                   var obj1 = {
                     ref: null                                                                        7
                   };

                   var obj2 = {
                     ref: obj1
                   };
                                                                                                      8
                   obj1.ref = obj2;
                   这段代码的逻辑非常简单,就是两个相互引用的对象。当我们试图使用深拷贝来复制
               obj1 和 obj2 中的任何一个时,问题就出现了。因为深拷贝的做法是遇到对象就进行递归
                                                                                                      9
               复制,那么结果只能无限循环下去。对于这种情况,简单的递归已经无法解决,必须设计一
               套图论算法,分析对象之间的依赖关系,建立一个拓扑结构图,然后分别依次复制每个顶点,
               并重新构建它们之间的依赖关系。这已经超出了本书的讨论范围,而且在实际的工程操作中
               几乎不会遇到这种需求,所以我们就不继续讨论了。                                                                10
   167   168   169   170   171   172   173   174   175   176   177