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


    框架简介:

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

    框架功能简要说明:

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

      1 /**
      2  * 
      3  * Base
      4  * @description 用于实现最基础的方法等
      5  * 
      6  */
      7 var 
      8     Base = {
      9         /**
     10          * 判断 类与类之间 以及 对象与类之间 关系的基础方法
     11          *
     12          * 情况一(类与类之间):
     13          * 1. 父类.is(子类) -> false
     14          * 2. 子类.is(父类) -> true
     15          *
     16          * 情况二(对象与类之间):
     17          * 1. 父类对象.is(子类) -> false
     18          * 2. 子类对象.is(父类) -> true
     19          *
     20          * @param {Object} type 类名称
     21          * @return {Boolean} 
     22          */
     23         is : function(type){
     24             var 
     25                 self = this;
     26 
     27                 /**
     28                  * 
     29                  * 调用对象.is(指定对象)
     30                  * 判断 调用对象 是否 包含 指定对象(属性)
     31                  * 或者也可以这样说
     32                  * 判断 指定对象 是否 包含于 调用对象(属性)
     33                  * 
     34                  */
     35 
     36                 while ( self ) {
     37                     if ( self == type ) return true;
     38                     self = self.__type__; // __type__ : (1)Class-引用其父类 (2)New-实例所属的类
     39                 }
     40 
     41                 return false;
     42         }
     43     };
     44 
     45 
     46 var 
     47     /**
     48      * 核心方法一: Class
     49      * 
     50      * 创建类的函数,用于声明类及继承关系
     51      * 
     52      * @param {Object} DefineClass 定义类的对象
     53      * @param {Object} BaseClass 需要继承的类(省略默认为 Base)
     54      * @return {Class} 创建类 
     55      */
     56     Class = function(DefineClass, BaseClass){
     57         // 默认继承 Base 基类
     58         var 
     59             parent = BaseClass || Base,
     60             // 创建类的临时函数壳 _class
     61             _class = function(){
     62                 // __type__ 属性 : 引用其父类
     63                 this.__type__ = parent;
     64                 // 复制类的全部定义到当前创建的类
     65                 for( var member in DefineClass ) {
     66                     this[member] = DefineClass[member];
     67                 }
     68             };
     69 
     70             _class.prototype = parent;
     71 
     72             return new _class();
     73     };
     74 
     75 var 
     76     /**
     77      * 核心方法二: New
     78      *
     79      * 创建对象的函数,用于任意类的对象创建
     80      *
     81      * @param {Object} ClassName 类
     82      * @param {Object} ClassParam 类参数(构造函数需要的参数)
     83      * @return {Object} 创建对象 
     84      */
     85     New = function(ClassName, ClassParam){
     86         // 创建对象的临时函数壳 _new
     87         var 
     88             _new = function(){
     89                 // __type__ 属性 : 据此可以访问到对象所属的类
     90                 this.__type__ = ClassName;
     91                 if(ClassName.create && typeof ClassName.create === 'function'){
     92                     // 约定 所有 类的构造函数: create ! 
     93                     ClassName.create.apply(this, ClassParam);
     94                 }
     95             };
     96 
     97             _new.prototype = ClassName;
     98 
     99             return new _new();
    100     };

    (2)全局函数(功能函数的扩充)

      1 /**
      2  * 
      3  * ---------------------------
      4  * 创建全局方法 VarToBool    |
      5  * @title VarToBool Global   |
      6  * @description 空值监测     |
      7  * ---------------------------
      8  * 
      9  */
     10 var 
     11     /**
     12      * 判断变量 是否 成立
     13      * [VarToBool 规定 ''|null|undefined|NaN|0|{}|[] 都为false,其他变量均为true]
     14      * 
     15      * @param  {[object]} data [需要判断的变量]
     16      * @return {[Boolean]}   
     17      */
     18     VarToBool = function(data){
     19         var 
     20             _t       = typeof data
     21             ,hasProp = false
     22             ,prop    = null
     23             ;
     24 
     25             if( _t === 'object' ) {
     26                 for ( prop in data ) {
     27                     hasProp = true; // 证明该对象存在属性
     28                     break;
     29                 }
     30                 return hasProp;
     31             }
     32 
     33             return !!data;
     34     };
     35 /**
     36  * 
     37  * ---------------------------
     38  * 创建全局方法 GetType      |
     39  * @title GetType Global     |
     40  * @description 获取变量类型 |
     41  * ---------------------------
     42  * 
     43  */
     44 var 
     45     /**
     46      * 得到变量 类型 字符串
     47      * 'abc'              return 'string'
     48      * true               return 'boolean'
     49      * 123,NaN,Infinity   return 'number'
     50      * []                 return 'array'
     51      * {}                 return 'object'
     52      * function(){}       return 'function'
     53      * new Date           return 'date'
     54      * new RegExp         return 'regexp'
     55      * Math               return 'math'
     56      * null               return 'null'
     57      * undefined          return 'undefined'
     58      */
     59     GetType = function(data){
     60         var 
     61             _t = ''
     62             ;
     63 
     64             return ( (_t = typeof data) == 'object' ? data == null && 'null' || Object.prototype.toString.call(data).slice(8,-1):_t ).toLowerCase();
     65     };
     66 /**
     67  * 
     68  * ---------------------------------
     69  * 创建全局方法 SerializeToJson    |
     70  * @title SerializeToJson Global   |
     71  * @description form序列化转JSON   |
     72  * ---------------------------------
     73  * 
     74  */
     75 var 
     76     /**
     77      * 将 序列化字符串(a=b&c=d&e=f) 转化 为 json 对象
     78      */
     79     SerializeToJson = function(paramStr){
     80         var 
     81             json = {}
     82             ,pairs = null
     83             ,i = 0
     84             ,pairsLen = 0
     85             ,pos = 0
     86             ,argname = ''
     87             ,value = ''
     88             ;
     89 
     90             if(!paramStr || typeof paramStr !== 'string'){
     91                 return {};
     92             }
     93             paramStr = paramStr.replace(/s*/g,''); // 清除该字符串所有空格
     94             
     95             pairs = paramStr.split('&');
     96 
     97             pairsLen = pairs.length || 0;
     98 
     99             for(;i<pairsLen;i++){
    100                 pos = pairs[i].indexOf('=');
    101 
    102                 // look for "name=value"
    103                 if(pos == -1) continue;
    104 
    105                 // if not found, skip
    106                 argname = pairs[i].substring(0,pos);
    107                 // extract the name
    108                 value = pairs[i].substring(pos + 1);
    109                 // extract the value
    110                 value = decodeURIComponent(value);
    111                 // decode it , if needed
    112                 json[argname] = value;
    113             }
    114             return json;
    115     };
    116 /**
    117  * 
    118  * ---------------------------------
    119  * 创建全局方法 JsonToSerialize    |
    120  * @title JsonToSerialize Global   |
    121  * @description JSON转form序列化   |
    122  * ---------------------------------
    123  * 
    124  */
    125 var 
    126     /**
    127      * 将 json 对象 转化 为 序列化字符串(a=b&c=d&e=f)
    128      */
    129     JsonToSerialize = function(json){
    130         var 
    131             k = null
    132             ,strArr = []
    133             ;
    134 
    135             if(!json || typeof json !== 'object'){
    136                 return '';
    137             }
    138 
    139             for(k in json){
    140                 strArr.push(k + '=' + json[k]);
    141             }
    142 
    143             return strArr.join('&');
    144     };
    145 /**
    146  * 
    147  * ---------------------------
    148  * 创建全局方法 InArray      |
    149  * @title InArray Global     |
    150  * @description              |
    151  * ---------------------------
    152  * 
    153  */
    154 var 
    155     /**
    156      * @method InArray 检查值是否在数组中
    157      * @param {value,Array} 值,数组
    158      * @return {Boolean} 真返回true,否则返回false
    159      */
    160     InArray = function(val,arr){
    161         var 
    162             i   = 0
    163             ,l   = 0
    164             ;
    165 
    166             if ( GetType(arr) !== 'array' ){
    167                 throw '{"code":"1","msg":"数组不存在"}';
    168             }
    169 
    170             for ( i = 0, l = arr.length; i < l; i++ ) {
    171                 if ( arr[i] === val ) {
    172                     return true;
    173                 }
    174             }
    175 
    176             return false;
    177     };

    (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 : 迭代器

     1 /**
     2      * [_each 迭代器]
     3      * @param  {[array]}    obj      [待迭代对象数组]
     4      * @param  {Function}   callback [迭代回调方法]
     5      * @param  {[object]}   context  [环境变量,用作回调函数中this的对象]
     6      * @param  {[type]}     arg      [传入迭代回调函数的参数]
     7      * @throws {jsonstringify} 缺少参数
     8      */
     9     App.each = function(obj, callback, context, arg){
    10         var 
    11             k     = null
    12             ,argsLen = arguments.length
    13             ;
    14 
    15             /* 方法重载 开始 */
    16             if ( argsLen === 0 || argsLen === 1 ) {
    17                 throw '{"code":"1","msg":"缺少参数"}';
    18             }
    19             /* 方法重载 结束 */
    20 
    21             if ( !callback || typeof callback !== 'function' ) throw '{"code":"1","msg":"参数类型必须为function"}';
    22 
    23             for ( k in obj ) {
    24                 callback.call( context||null, k, obj[k], arg );
    25             }
    26     };

    (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

  • 相关阅读:
    快慢指针
    成绩排序
    简单排序
    个人作业——软件工程实践总结作业
    团队作业——项目验收与总结博客(麻瓜制造者)
    Beta阶段总结博客(麻瓜制造者)
    “福大易宝”宣传文案
    Beta冲刺(5/5)(麻瓜制造者)
    Beta冲刺(4/5)(麻瓜制造者)
    个人作业——软件工程实践总结作业(待续)
  • 原文地址:https://www.cnblogs.com/jiangxiaobo/p/5465408.html
Copyright © 2020-2023  润新知