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