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这个模块：

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

function each(objects, func, context) {
}

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

function recursiveMerge(target, src) {
}

//返回值
module.exports = {
};

});

有了前面的经验，我们知道，第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);