一个JS定时器类

学习js，因为函数和定时器直接的关系是非绑定的。我不能说我开启一个定时，然后拿一个变量去记录这个setInterval的返回值，这样很麻烦。

本着面向对象的思想，利用业余时间（周末在家里）写了一个类，用来管理定时器。

吐槽下jQuery，不知道是不是我的jQuery版本太低，貌似jQuery没有提供很好的定时器管理类。

好废话不多说，上代码：

function TimeControlEx() {
    var nCount = 0;
    var oTimerIDs = []; //ID,Name
    var that = this;
    var nTimerId = 0;
    this.ExecOnce = function (funcid) {
        if (oTimerIDs[funcid].Limit == 0) {
            //只要归零了，肯定是定时的，对于这种，就得关闭
            clearInterval(oTimerIDs[funcid].TimerID);
        }
    };
    this.add = function (nSec, oFunction, sName, nTimes) {
        ///<param name="nSec">延迟时间，毫秒</param>
        ///<param name="oFunction">调用函数</param>
        ///<param name="sName">定时器名称（可选）</param>
        ///<param name="nTimes">循环次数（可选）</param>
        //todo:根据各个参数来创建，基础的参数是nSec和oFunction
        var nParams = arguments.length;
        var obj;
        switch (nParams) {
            case 2:
                //两个参数，自动增加
                nTimerId = setInterval(oFunction, nSec);
                obj = {
                    ID: nCount,
                    TimerID:nTimerId,
                    Name: String(nCount),
                    Interval: nSec,
                    Limit: -1
                };
                oTimerIDs.push(obj);
                break;
            case 3:
                //三个参数
                nTimerId = setInterval(oFunction, nSec);
                obj = {
                    ID: nCount,
                    TimerID: nTimerId,
                    Name: sName,
                    Interval: nSec,
                    Limit: -1
                };
                oTimerIDs.push(obj);
                break;
            case 4:
                //四个参数
                obj = {
                    ID: nCount,
                    TimerID: nTimerId,
                    Name: sName,
                    Interval: nSec,
                    Limit: nTimes
                };
                oTimerIDs.push(obj);
                break;
            default:
                return;
        }
    };
    this.CloseTimer = function (sTimerName) {
        ///<param name="sTimerName">计时器的名字，或ID</param>
        if (typeof (sTimerName) == "number") {
            //按照数字方法关闭
            for (var j = 0; j < oTimerIDs.length; j++) {
                if (oTimerIDs[j].ID == sTimerName) {
                    clearInterval(oTimerIDs[j].TimerID);
                    oTimerIDs = oTimerIDs.splice(j, 1);
                    nCount--;
                    break;
                }
            }
        } else {
            //按照字符串方式关闭
            for (var m = 0; m < oTimerIDs.length; m++) {
                if (oTimerIDs[m].Name == sTimerName) {
                    clearInterval(oTimerIDs[m].TimerID);
                    oTimerIDs.splice(m, 1);
                    nCount--;
                    break;
                }
            }
        }
    };
}

编辑：今天查看后，发现代码存在严重的bug，修复了一下，现在放出修改后的代码：

 function TimeControlEx() {
     var nCount = 0;
     var oTimerIDs = []; //ID,Name
     var that = this;
     var nTimerId = 0;
     this.ExecOnce = function (funcid) {
         if (oTimerIDs[funcid].Limit == 0) {
             //只要归零了，肯定是定时的，对于这种，就得关闭
             clearInterval(oTimerIDs[funcid].TimerID);
         }
     };
     this.add = function (nSec, oFunction, sName, nTimes) {
         ///<param name="nSec">延迟时间，毫秒</param>
         ///<param name="oFunction">调用函数</param>
         ///<param name="sName">定时器名称（可选）</param>
         ///<param name="nTimes">循环次数（可选）</param>
         //todo:根据各个参数来创建，基础的参数是nSec和oFunction
         var nParams = arguments.length;
         var obj;
         switch (nParams) {
             case 2:
                 //两个参数，自动增加
                 nTimerId = setInterval(oFunction, nSec);
                 obj = {
                     ID: nCount,
                     TimerID: nTimerId,
                     Name: String(nCount),
                     Interval: nSec,
                     Limit: -1
                 };
                 oTimerIDs.push(obj);
                 break;
             case 3:
                 //三个参数
                 nTimerId = setInterval(oFunction, nSec);
                 obj = {
                     ID: nCount,
                     TimerID: nTimerId,
                     Name: sName,
                     Interval: nSec,
                     Limit: -1
                 };
                 oTimerIDs.push(obj);
                 break;
             case 4:
                 //四个参数
                 obj = {
                     ID: nCount,
                     TimerID: 0,
                     Name: sName,
                     Interval: nSec,
                     Limit: nTimes
                 };
                 var oFunc = function (oThis, oMyFunc) {
                     var oThat = oThis;
                     var oMyFun = oMyFunc;
                     var oRun = function () {
                         if (oThat.Limit > 0 || oThat.Limit == -1) {
                             oMyFun(); //执行传入的函数
                             if (oThat.Limit > 0) oThat.Limit--;
                         } else {
                             //自行了断
                             clearInterval(oThat.TimerID);
                         }
                     };
                     return oRun;
                 };
                 nTimerId = setInterval(oFunc(obj, oFunction), nSec);
                 obj.TimerID = nTimerId;
                 oTimerIDs.push(obj);
                 break;
             default:
                 return;
         }
     };
     this.CloseTimer = function (sTimerName) {
         ///<param name="sTimerName">计时器的名字，或ID</param>
         if (typeof (sTimerName) == "number") {
             //按照数字方法关闭
             for (var j = 0; j < oTimerIDs.length; j++) {
                 if (oTimerIDs[j].ID == sTimerName) {
                     clearInterval(oTimerIDs[j].TimerID);
                     oTimerIDs = oTimerIDs.splice(j, 1);
                     nCount--;
                     break;
                 }
             }
         } else {
             //按照字符串方式关闭
             for (var m = 0; m < oTimerIDs.length; m++) {
                 if (oTimerIDs[m].Name == sTimerName) {
                     clearInterval(oTimerIDs[m].TimerID);
                     oTimerIDs.splice(m, 1);
                     nCount--;
                     break;
                 }
             }
         }
     };
 }

谢谢大家的支持