PhoneGap源码分析10——cordova/builder

　　这一篇我们分析cordova/builder这个模块。

　　在具体看这个模块之前，先复习一下Object类型。

（1）Object类型是所有它的实例的基础，所有的内置类型都是通过原型继承的方式继承了Object类。

（2）Object的每个实例都有一个Constructor属性，指向创建这个实例的函数。

（3）Object的每个实例都有下面的方法：

A、hasOwnProperty(propertyName)：检查propertyName是否在当前实例中（在实例原型中同样返回false）。

B、propertyIsEnumerable(propertyName)：检查propertyName是否可以使用for-in语句访问（只要属性没有特别标识，在实例原型中的属性也可以访问）。

C、isPorpertyOf(object)：检查object是否为另一个对象的原型。

D、toLocalString()、toString()、valueOf()。

　　因此可以使用下面的结构来遍历实例中的属性：

for(var propertyName in object){

　　if(object.hasOwnPorperty(propertyName)){

　　　　//循环处理

　　}

}

　　现在再来看cordova/builder这个模块：

 1 define("cordova/builder", function(require, exports, module) {

 2 var utils = require('cordova/utils');//导入工具类，由于前面模块中已经创建过，所以这里不会再次创建，而是直接返回

 3 

 4 function each(objects, func, context) {

 5 }

 6 

 7 function include(parent, objects, clobber, merge) {

 8 }

 9 

10 function recursiveMerge(target, src) {

11 }

12 

13 //返回值

14 module.exports = {

15 };

16 

17 });

有了前面的经验，我们知道，第14行的赋值实际上就是整个构造函数的返回值，其它的则是声明了三个内部函数，用于构建返回值。
1、展开第4行的函数each，这正是开始分析的一个循环遍历实例属性的结构：

function each(objects, func, context) {

    for (var prop in objects) {

        if (objects.hasOwnProperty(prop)) {//循环遍历objects实例的属性

            func.apply(context, [objects[prop], prop]);//在context环境中调用func处理属性，参数是属性值和属性名
        }

    }

}

2、再展开第10行的函数recursiveMerge（递归合并），这里也是一个循环遍历实例属性的结构，只是遍历处理复杂一些：

//递归合并对象属性（会覆盖目标对象中原有属性）

function recursiveMerge(target, src) {

    for (var prop in src) {

        if (src.hasOwnProperty(prop)) {//循环遍历源对象src的实例属性

            if (typeof target.prototype !== 'undefined' && target.prototype.constructor === target) {

                // 如果目标对象是一个构造函数，将属性赋值到其原型对象上，使得所有通过target构建的实例都可以共享src的实例属性

                // 这里实际上有一个隐患，如果src有一个引用类型的实例属性ref，然后通过target创建了两个实例A、B，修改A的ref会也就修改了B的ref

                target.prototype[prop] = src[prop];

            } else {

                // 简单类型直接赋值，object类型递归赋值

                target[prop] = typeof src[prop] === 'object' ? recursiveMerge(target[prop], src[prop]) : src[prop];

            }

        }

    }

    return target;

}

3、再来看第7行的函数include：

function include(parent, objects, clobber, merge) {

    each(objects, function (obj, key) {    

    });

}

在这里，调用了开始声明的each函数，传入对象objects和处理函数fn，但是并没有传入context，也就是说，在each内部使用apply调用函数处理属性时，是在全局环境下执行的，从each函数的源码中，我们知道，这里的处理函数fn的两个参数是属性值和属性名。具体展开fn的代码看看：

function (obj, key) {

        try {

          var result = obj.path ? require(obj.path) : {};//根据属性值中的路径，导入相应模块



          if (clobber) {

                if (typeof parent[key] === 'undefined') {

                  parent[key] = result;//如果目标对象不存在该属性，直接赋值为导入的模块

              } else if (typeof obj.path !== 'undefined') {

                  //目标对象已有该属性，并且已导入属性值对应模块

                  if (merge) {

                      recursiveMerge(parent[key], result);//要求合并，以新导入模块为准进行合并

                  } else {

                      parent[key] = result;

                  }

              }

              result = parent[key];//将已经处理好的属性反写至中间对象，当目标对象有子对象时，再递归处理

          } else {

            if (typeof parent[key] == 'undefined') {//如果目标对象不存在该属性，直接赋值为导入的模块

              parent[key] = result;

            } else if (merge && typeof obj.path !== 'undefined') {

              // 目标对象已有该属性，并且要求合并，则以原属性为准进行合并，并将合并后的属性

              recursiveMerge(result, parent[key]);

              parent[key] = result;

            } else {//目标对象已有该属性，使用该属性作为下一次递归处理的参数

              result = parent[key];

            }

          }



          if (obj.children) {//递归处理

            include(result, obj.children, clobber, merge);

          }

        } catch(e) {

          utils.alert('Exception building cordova JS globals: ' + e + ' for key "' + key + '"');

        }

    }

（1）最外层的try{}catch(e){}结构是捕获异常，并根据utils中的alert警告或写日志。
（2）根据代码中的注释，可以反过来推出include的参数parent就是需要处理属性的目标对象、objects就是需要处理的属性集、clobber则是表示以哪个为基准，为true时以objects中属性为准，false时以原对象parent中属性（如果parent未定义该属性，则仍以objects为准）为准、merge则表示是否递归合并属性及其子属性，为true时递归合并，为false时则只是简单赋值当前属性，不递归。

（3）对于objects中的属性，递归处理。

4、分析完了三个内部函数，再来看第14行的返回值：

//返回值

module.exports = {

    build: function (objects) {

        return {

            intoButDontClobber: function (target) {//以target中原属性为准，并且不递归合并子属性

                include(target, objects, false, false);

            },

            intoAndClobber: function(target) {//以objects中属性为准，但不递归合并子属性

                include(target, objects, true, false);

            },

            intoAndMerge: function(target) {//以objects属性为准并且递归合并子属性

                include(target, objects, true, true);

            }

        };

    }

};

返回值是一个对象字面量，只有一个属性build，而这个build是一个函数，接受一个属性修饰参数，返回一个包含了三种不同修饰方式函数的对象。源码中函数内嵌比较多，不易理解，直接返回include好理解一点（当然，调用方式也需要相应修改）：

module.exports = {build: include}

调用方式做如下修改：

var builder = require('cordova/builder'),

    base = require('cordova/common');

builder.build(base.objects).intoButDontClobber(window);

// 修改为

builder.build(window, base.objects, false, false);