PhoneGap源码分析10——cordova/builder

08-09 01:39:23   来源:cnblogs   评论: 点击:

Object类型是所有它的实例的基础,所有的内置类型都是通过原型继承的方式继承了Object类。
这一篇我们分析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);

 

 

相关热词搜索:PhoneGap

上一篇:PhoneGap源码分析8——cordova 下一篇:PhoneGap源码分析12——引导程序与cordova/platform
分享到: 收藏