js的点点滴滴

有关于JS的东西太多，也太杂了。总是想记下来，但总是以一些自以为是的理由来搪塞自己。今天总是下了点决心，先记下这点吧。以后有了随时更新。

1、js静态类
定义方法
var classname=
{
}
成员定义方法
每个成员由逗号分隔开（除最后一个成员）
对于成员变量，通常的定义方法为：
m_varname:value
对于成员函数，通常的定义方法为：
fnname:function(parameter)
{
}

另外，在静态类，可以直接使用外部的函数或者变量。但如果要引用静态类的成员，需要指出静态类的类名，如：staticClassName.member = value;即使是在同一个静态类中。

2、使用setTimeout函数传递对象:
var expFun=function(){OperationTime.SetShowTimerInfo(obj)};
  window.setTimeout(expFun,1000);

现在我吸取网上其它大大的经验，已经将它稍稍改进了一些。重写了一下window.setTimeout函数。

var  _st_fun  =  window.setTimeout;
window.setTimeout  = function (fRef,mDelay) {
    if(typeof fRef == 'function'){
        var context = this;
        var argus = Array.prototype.splice.call(arguments,2);
        var fun=function(){
            fRef.apply(context,argus);
        }
        return _st_fun(fun,mDelay);
    }
    return _st_fun(fRef,mDelay);
}

调用的时候，直接将要传递的参数按顺序放在参数列表中即可。

window.setTimeout的原型

iTimerID = window.setTimeout(vCode, iMilliSeconds [, sLanguage])

一般情况下，第三个参数（语言）没有什么用处，默认是javascript，所以在重载的时候将它放弃了。

调用如下：

var  dealyinvoke = function (matchError)
{
    this.processError(matchError);
}
var  obj  =   this ;
window.setTimeout.call(obj,dealyinvoke,parseInt(matchError.Try[ 0 ].Time) * 1000 ,matchError);

这是我的程序里面使用到的一个调用示例。由于我是面向对象编程，这个processError函数是当前对象中的一个成员。所以在回调中，我还是需要当前上下文的引用，所以使用的call来完成的调用。第一个参数将当前上下文通过call传递进去（如果对call或者apply的使用不明白，说明你和我一样，功力还欠缺火候，赶快补习一下）。

当前也可以直接调用的，就如没有重写一样。如果回调函数中不需要上下文，可以直接调用。如下：

var dealyinvoke=function(matchError)
{
    processError(matchError);
}

window.setTimeout(dealyinvoke,parseInt(matchError.Try[0].Time)*1000,matchError);

3、检查Access数据表中是否存在某字段（列）

// ===============================/
// 检查数据表中是否存在列
// strTableName        表名
// strColumnName        列名
// =============================/
function  fnColumnIsExists(tablename,columname)
{
    var blnExists = false;
    try
    {
        var rstPbase;
        rstPbase = g_objAnalyConn.OpenSchema(4, new Array(null, null,tablename,columname));
        blnExists = rstPbase.recordCount >0;
        rstPbase.Close();
        delete rstPbase;
    }
    catch (e)
    {
        //showErrorInfo("模块名称：QuestionTimer[fnColumnIsExists]\n详细信息：" + e.description);
        //alert(e.description);
    }
    return blnExists;
}

上面函数中，如果把rstPbase = g_objAnalyConn.OpenSchema(4, new Array(null, null,tablename,columname));中的columname如果为null的话，那返回的数据集就是所有字段名（列名）的一个集合。当然查询语句也要作出相应的调整。


4、有关于类的创建，精妙的语法。

var  Class  =   {
    create: function () {
        return function () {
            this.initialize.apply(this, arguments);
        };
    }
} ;
var  StringBuilder  =  Class.create();
StringBuilder.prototype  =   {
    initialize : function( str ) {
        this._strings_ = new Array;
        if ( str ) this.append(str);
    },
    append : function ( str ) {
        this._strings_.push ( str );
    },
    ToString : function () {
        return this._strings_.join ( "" );
    },
    Clear : function () {
        return this._strings_.splice (0,this._strings_.length);
    }
}
function  classtest() {
    var sb=new StringBuilder("ad");
}

5、Json对象
以我看来，Json和第一条提到的静态类，基本上是同一个东西，只不过静态类里面比JSON多了一些成员函数而已。它们的本质还是相同的。现在也说不清它们两者之间是先有鸡还是先有蛋的。亦或者是同时就存在了的。
var json={title:"标题",content:"内容"};
它们都是以{}为声明标记，内部以,分隔。并且每一个成员都是以:来区分名称和内容。
比如：json.title 这时，如果要调试输出的话，输出来的是字符串"标题".
同时，也可以把上面的json看作是一个静态类，只不过这个静态类，徒有虚表而已。是一个只有属性变量 ，没有成员函数的静态类。

json声明时，还可以加入数组。如下：
json={title:"标题",content:"内容"，category:["章节一","Javascript","客户端脚本"]};
如果alert(json.category),输出的将是：章节一,Javascript,客户端脚本。

同时，在json内部，还可以存在json子集。如下：
var json={title:"标题",content:"内容",category:{name0:"章节一",name1:"Javascript",name2:"客户端脚本"}};
如果alert(json.category。name2),输出的将是：客户端脚本。

6、给string对象扩充的方法

String.prototype.format=function(){
    Array.prototype.unshift.call(arguments,this);
    return String.format.apply(null,arguments);
}
String.format = function(){
    if(arguments.length == 0)return "";    
    var str = arguments[0];
    for(var index=0;index<arguments.length;index++){      
        var re = new RegExp('\\{' + (index) + '\\}','gm');
        str = str.replace(re, arguments[index+1]);
    }
    return str
}