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