APICloud-端JS库功能API文档(1)

框架简介：

框架基于APICloud官网端API进行扩展和封装，框架完全采用面向对象编程形式，里面包含APP所使用的常用js功能：js类的自定义（类，构造方法，静态方法，继承...），常用工具函数（验证，变量类型，inarray，序列化转JSON...），对象扩展extend方法，迭代器each方法，apicloud常用端对象。

框架功能简要说明：

（1）封装js自定义类的方法，编写Base对象作为所有类的基类（即框架的类都继承与它）。

/**
 * 
 * Base
 * @description 用于实现最基础的方法等
 * 
 */
var 
    Base = {
        /**
         * 判断 类与类之间 以及 对象与类之间 关系的基础方法
         *
         * 情况一(类与类之间)：
         * 1. 父类.is(子类) -> false
         * 2. 子类.is(父类) -> true
         *
         * 情况二(对象与类之间)：
         * 1. 父类对象.is(子类) -> false
         * 2. 子类对象.is(父类) -> true
         *
         * @param {Object} type 类名称
         * @return {Boolean} 
         */
        is : function(type){
            var 
                self = this;

                /**
                 * 
                 * 调用对象.is(指定对象)
                 * 判断 调用对象 是否 包含 指定对象(属性)
                 * 或者也可以这样说
                 * 判断 指定对象 是否 包含于 调用对象(属性)
                 * 
                 */

                while ( self ) {
                    if ( self == type ) return true;
                    self = self.__type__; // __type__ : (1)Class-引用其父类 (2)New-实例所属的类
                }

                return false;
        }
    };


var 
    /**
     * 核心方法一： Class
     * 
     * 创建类的函数，用于声明类及继承关系
     * 
     * @param {Object} DefineClass 定义类的对象
     * @param {Object} BaseClass 需要继承的类(省略默认为 Base)
     * @return {Class} 创建类 
     */
    Class = function(DefineClass, BaseClass){
        // 默认继承 Base 基类
        var 
            parent = BaseClass || Base,
            // 创建类的临时函数壳 _class
            _class = function(){
                // __type__ 属性 : 引用其父类
                this.__type__ = parent;
                // 复制类的全部定义到当前创建的类
                for( var member in DefineClass ) {
                    this[member] = DefineClass[member];
                }
            };

            _class.prototype = parent;

            return new _class();
    };

var 
    /**
     * 核心方法二： New
     *
     * 创建对象的函数，用于任意类的对象创建
     *
     * @param {Object} ClassName 类
     * @param {Object} ClassParam 类参数(构造函数需要的参数)
     * @return {Object} 创建对象 
     */
    New = function(ClassName, ClassParam){
        // 创建对象的临时函数壳 _new
        var 
            _new = function(){
                // __type__ 属性 : 据此可以访问到对象所属的类
                this.__type__ = ClassName;
                if(ClassName.create && typeof ClassName.create === 'function'){
                    // 约定 所有 类的构造函数： create ! 
                    ClassName.create.apply(this, ClassParam);
                }
            };

            _new.prototype = ClassName;

            return new _new();
    };

（2）全局函数（功能函数的扩充）

/**
 * 
 * ---------------------------
 * 创建全局方法 VarToBool    |
 * @title VarToBool Global   |
 * @description 空值监测     |
 * ---------------------------
 * 
 */
var 
    /**
     * 判断变量 是否 成立
     * [VarToBool 规定 ''|null|undefined|NaN|0|{}|[] 都为false，其他变量均为true]
     * 
     * @param  {[object]} data [需要判断的变量]
     * @return {[Boolean]}   
     */
    VarToBool = function(data){
        var 
            _t       = typeof data
            ,hasProp = false
            ,prop    = null
            ;

            if( _t === 'object' ) {
                for ( prop in data ) {
                    hasProp = true; // 证明该对象存在属性
                    break;
                }
                return hasProp;
            }

            return !!data;
    };
/**
 * 
 * ---------------------------
 * 创建全局方法 GetType      |
 * @title GetType Global     |
 * @description 获取变量类型 |
 * ---------------------------
 * 
 */
var 
    /**
     * 得到变量 类型 字符串
     * 'abc'              return 'string'
     * true               return 'boolean'
     * 123,NaN,Infinity   return 'number'
     * []                 return 'array'
     * {}                 return 'object'
     * function(){}       return 'function'
     * new Date           return 'date'
     * new RegExp         return 'regexp'
     * Math               return 'math'
     * null               return 'null'
     * undefined          return 'undefined'
     */
    GetType = function(data){
        var 
            _t = ''
            ;

            return ( (_t = typeof data) == 'object' ? data == null && 'null' || Object.prototype.toString.call(data).slice(8,-1):_t ).toLowerCase();
    };
/**
 * 
 * ---------------------------------
 * 创建全局方法 SerializeToJson    |
 * @title SerializeToJson Global   |
 * @description form序列化转JSON   |
 * ---------------------------------
 * 
 */
var 
    /**
     * 将 序列化字符串(a=b&c=d&e=f) 转化 为 json 对象
     */
    SerializeToJson = function(paramStr){
        var 
            json = {}
            ,pairs = null
            ,i = 0
            ,pairsLen = 0
            ,pos = 0
            ,argname = ''
            ,value = ''
            ;

            if(!paramStr || typeof paramStr !== 'string'){
                return {};
            }
            paramStr = paramStr.replace(/s*/g,''); // 清除该字符串所有空格
            
            pairs = paramStr.split('&');

            pairsLen = pairs.length || 0;

            for(;i<pairsLen;i++){
                pos = pairs[i].indexOf('=');

                // look for "name=value"
                if(pos == -1) continue;

                // if not found, skip
                argname = pairs[i].substring(0,pos);
                // extract the name
                value = pairs[i].substring(pos + 1);
                // extract the value
                value = decodeURIComponent(value);
                // decode it , if needed
                json[argname] = value;
            }
            return json;
    };
/**
 * 
 * ---------------------------------
 * 创建全局方法 JsonToSerialize    |
 * @title JsonToSerialize Global   |
 * @description JSON转form序列化   |
 * ---------------------------------
 * 
 */
var 
    /**
     * 将 json 对象 转化 为 序列化字符串(a=b&c=d&e=f)
     */
    JsonToSerialize = function(json){
        var 
            k = null
            ,strArr = []
            ;

            if(!json || typeof json !== 'object'){
                return '';
            }

            for(k in json){
                strArr.push(k + '=' + json[k]);
            }

            return strArr.join('&');
    };
/**
 * 
 * ---------------------------
 * 创建全局方法 InArray      |
 * @title InArray Global     |
 * @description              |
 * ---------------------------
 * 
 */
var 
    /**
     * @method InArray 检查值是否在数组中
     * @param {value,Array} 值，数组
     * @return {Boolean} 真返回true，否则返回false
     */
    InArray = function(val,arr){
        var 
            i   = 0
            ,l   = 0
            ;

            if ( GetType(arr) !== 'array' ){
                throw '{"code":"1","msg":"数组不存在"}';
            }

            for ( i = 0, l = arr.length; i < l; i++ ) {
                if ( arr[i] === val ) {
                    return true;
                }
            }

            return false;
    };

（3）App对象

App.extend : 对象扩充

/**
     * [extend 对象合并]
     * @param  {[object]}       des            [源对象]
     * @param  {[array|object]} src            [对象数组]
     * @param  {[boolean]}      override       [是否重写源对象]
     * @return {[object]}                      [返回源对象的引用]
     */
    App.extend = function(des, src, override){
        var 
            i        = 0
            ,l       = 0
            ,k       = null
            ,argsLen = arguments.length
            ;

            /* 方法重载 开始 */
            if ( argsLen === 0 ) {
                return {};
            } else if ( argsLen === 1 ) {
                return arguments[0];
            }
            /* 方法重载 结束 */

            if ( src instanceof Array ) {
                for ( i = 0, l = src.length; i < l; i++ ) {
                    App.extend(des, src[i], override);
                }
            } else {
                for ( k in src ) {
                    if ( override || !(k in des) ) {
                        des[k] = src[k];
                    }
                }
            }

            return des;
    };

App.each : 迭代器

/**
     * [_each 迭代器]
     * @param  {[array]}    obj      [待迭代对象数组]
     * @param  {Function}   callback [迭代回调方法]
     * @param  {[object]}   context  [环境变量,用作回调函数中this的对象]
     * @param  {[type]}     arg      [传入迭代回调函数的参数]
     * @throws {jsonstringify} 缺少参数
     */
    App.each = function(obj, callback, context, arg){
        var 
            k     = null
            ,argsLen = arguments.length
            ;

            /* 方法重载 开始 */
            if ( argsLen === 0 || argsLen === 1 ) {
                throw '{"code":"1","msg":"缺少参数"}';
            }
            /* 方法重载 结束 */

            if ( !callback || typeof callback !== 'function' ) throw '{"code":"1","msg":"参数类型必须为function"}';

            for ( k in obj ) {
                callback.call( context||null, k, obj[k], arg );
            }
    };

（4）App.APICloud对象

在该对象下完全和APICloud端API分类相同：窗口系统、应用管理、网络通信、数据存储、消息事件、设备访问、UI组件、多媒体、WebApp历史、其他。

略。

（5）框架关键字：

基础：Base Class New UseAs VarToBool GetType SerializeToJson JsonToSerialize InArray 

对象：App Utils WinSystem AppManage Network DataStorage MsgEvent UI Media History Page