菜鸟学习cordova－android的js源码(2)

浏览数：19 / 时间：2015年06月11日

　　刚刚数了一下，cordova.js中定义了17个模块，下面慢慢来看这17个模块。

　　先看比较独立的模块，一些工具模块。

1. cordova/urlutil

模块输出的对象包含一个方法makeAbsolute,把地址转化为绝对地址。

//mark
define("cordova/urlutil", function(require, exports, module) {
    
    exports.makeAbsolute = function makeAbsolute(url) {
        var anchorEl = document.createElement(‘a‘);
        anchorEl.href = url;
        return anchorEl.href;
    };

});

2. cordova/utils

这个模块的方法比较多

// file: src/common/utils.js
define("cordova/utils", function(require, exports, module) {

    var utils = exports;

    //为obj对象的key属性添加get/set 方法
    //Object, defineProperty/__defineGetter__/__defineSetter__
    utils.defineGetterSetter = function(obj, key, getFunc, opt_setFunc) {
        if (Object.defineProperty) {
            var desc = {
                get: getFunc,
                configurable: true
            };
            if (opt_setFunc) {
                desc.set = opt_setFunc;
            }
            Object.defineProperty(obj, key, desc);
        } else {
            obj.__defineGetter__(key, getFunc);
            if (opt_setFunc) {
                obj.__defineSetter__(key, opt_setFunc);
            }
        }
    };

    utils.defineGetter = utils.defineGetterSetter;

    //Array, indexOf
    utils.arrayIndexOf = function(a, item) {
        if (a.indexOf) {
            return a.indexOf(item);
        }
        var len = a.length;
        for (var i = 0; i < len; ++i) {
            if (a[i] === item) {
                return i;
            }
        }
        return - 1;
    };

    //Array, splice
    utils.arrayRemove = function(a, item) {
        var index = utils.arrayIndexOf(a, item);
        if (index !== -1) {
            a.splice(index, 1);
        }
        return index !== -1;
    };

    //输出对象类型 "[object type]" 
    utils.typeName = function(val) {
        return Object.prototype.toString.call(val).slice(8, -1);
    };

    utils.isArray = function(a) {
        return utils.typeName(a) === ‘Array‘;
    };

    utils.isDate = function(d) {
        return utils.typeName(d) === ‘Date‘;
    };

    //复制对象，深度克隆对象
    utils.clone = function(obj) {
        //注意的地方, typeof [Date|Array|正则] is object
        if ( !obj || typeof obj === ‘function‘ || utils.isDate(obj) || typeof obj !== ‘object‘) {
            return obj;
        }

        //递归调用

        var retVal, i;

        //数组拷贝
        if (utils.isArray(obj)) {
            retVal = [];
            for (i = 0; i < obj.length; ++i) {
                retVal.push(utils.clone(obj[i]));
            }
            return retVal;
        }

        //对象拷贝
        retVal = {};
        for (i in obj) {
            if (! (i in retVal) || retVal[i] != obj[i]) {
                retVal[i] = utils.clone(obj[i]);
            }
        }
        return retVal;
    };

    //Returns a wrapped version of the function, aplly/call, 设置方式执行的上下文环境
    utils.close = function(context, func, params) {
        if (typeof params === ‘undefined‘) {
            return function() {
                return func.apply(context, arguments);
            };
        } else {
            return function() {
                return func.apply(context, params);
            };
        }
    };

    //prototype, constructor, 这两个对于理解js继承的非常重要
    utils.extend = (function() {
        // proxy used to establish prototype chain
        var F = function() {};
        // extend Child from Parent
        return function(Child, Parent) {
            F.prototype = Parent.prototype;
            Child.prototype = new F();
            Child.__super__ = Parent.prototype;
            Child.prototype.constructor = Child;
        };
    } ());

    utils.alert = function(msg) {
        /*if (window.alert) {
            window.alert(msg);
        } else if (console && console.log) {*/
            console.log(msg);
        // }
    };

    utils.createUUID = function() {
        return UUIDcreatePart(4) + ‘-‘ + UUIDcreatePart(2) + ‘-‘ + UUIDcreatePart(2) + ‘-‘ + UUIDcreatePart(2) + ‘-‘ + UUIDcreatePart(6);
    };
    //返回相应的16进制数字
    function UUIDcreatePart(length) {
        var uuidpart = "";
        for (var i = 0; i < length; i++) {
            var uuidchar = parseInt((Math.random() * 256), 10).toString(16);//mark
            if (uuidchar.length === 1) {
                uuidchar = "0" + uuidchar;
            }
            uuidpart += uuidchar;
        }
        return uuidpart;
    }

});

　　1). defineGetterSetter, 参数obj, key, getFunc, opt_setFunc，为obj的key属性定义存取方法。

实现中有几个方法值得注意一下，Object.defineProperty和__defineGetter__（__defineSetter__），后面那个是非标准的方法。developer.mozilla.org上讲的很详细了，下面是链接

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/__defineGetter__

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/__defineSetter__

　　2). arrayIndexOf ，参数a, item，找索引，这个很简单。

　　3). arrayRemove，参数a, item，删除数组中的某个索引。

　　4). typeName、isArray、isDate，判断变量类型。

　　5). clone，变量复制，注意值类型和引用类型的区别就行了。

　　6). close，参数context, func, params：看这个方法实现就知道，apply方法的使用，可以跟call方法比较一下学习，

http://blog.csdn.net/myhahaxiao/article/details/6952321

　　7). extend，继承的方法。prototype和constructor，原型和构造器，用这两个来做js里面的继承，网上找到不错文章，推荐大家读读，

http://blog.csdn.net/niuyongjie/article/details/4810835

　　8). alert

　　9). createUUID，通用唯一识别码。返回是16进制的，Math.random()随机生成的。

3. cordova/base64

base64和ArrayBuffer的转换

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

    var base64 = exports;

    //参考ArrayBuffer相关知识，http://javascript.ruanyifeng.com/stdlib/arraybuffer.html

    //Uint8Array = 8位无符号整数数组，长度1个字节.这个是ArrayBuffer的视图
    base64.fromArrayBuffer = function(arrayBuffer) {
        var array = new Uint8Array(arrayBuffer);
        return uint8ToBase64(array);
    };

    //atob = base64 解码的方法
    //btoa = base64 编码的方法
    base64.toArrayBuffer = function(str) {
        //把str进行解码
        //用window.atob方法
        //用Buffer = node.js 中的Buffer,服务器端的js
        var decodedStr = typeof atob !== ‘undefined‘ ? atob(str) : new Buffer(str, ‘base64‘).toString(‘binary‘);

        //分配相应大小字节的内存,类型化数组
        var arrayBuffer = new ArrayBuffer(decodedStr.length);
        //创建arrayBuffer的操作视图
        var array = new Uint8Array(arrayBuffer);

        for (var i = 0, len = decodedStr.length; i < len; i++) {
            //Uint8Array,是8位的
            //charCodeAt, 返回 0-65535, 16位2个字节
            array[i] = decodedStr.charCodeAt(i);
        }

        return arrayBuffer;
    };

    //------------------------------------------------------------------------------
    /* This code is based on the performance tests at http://jsperf.com/b64tests
     * This 12-bit-at-a-time algorithm was the best performing version on all
     * platforms tested.
     */

    var b64_6bit = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    //一维数组代替二维数组
    var b64_12bit;

    //64X64的表格，横竖坐标轴都是b64_6bit的64个字符
    var b64_12bitTable = function() {
        b64_12bit = [];
        for (var i = 0; i < 64; i++) {
            for (var j = 0; j < 64; j++) {
                b64_12bit[i * 64 + j] = b64_6bit[i] + b64_6bit[j];
            }
        }

        //不错的想法
        b64_12bitTable = function() {
            return b64_12bit;
        };

        return b64_12bit;
    };

    // rawData = Uint8Array, 编码 有点像 ascii to base64
    function uint8ToBase64(rawData) {
        var numBytes = rawData.byteLength;
        var output = "";
        var segment;
        var table = b64_12bitTable();
        for (var i = 0; i < numBytes - 2; i += 3) {
            segment = (rawData[i] << 16) + (rawData[i + 1] << 8) + rawData[i + 2];
            output += table[segment >> 12];
            output += table[segment & 0xfff];
        }
        if (numBytes - i == 2) {
            segment = (rawData[i] << 16) + (rawData[i + 1] << 8);
            output += table[segment >> 12];
            output += b64_6bit[(segment & 0xfff) >> 6];
            output += ‘=‘;
        } else if (numBytes - i == 1) {
            segment = (rawData[i] << 16);
            output += table[segment >> 12];
            output += ‘==‘;
        }
        return output;
    }

});