关于单例模式的一点思考

关于单例模式的一点思考

在面向对象的知识点中，有一个既简单又不简单的小点：单例模式

这种模式提供了一种将代码组织为一个逻辑单元的手段。最主要的有点就是可以用来划分命名空间，从而减少全局变量的数量，防止全局污染，代码例如：

var singleton={
    attr1:true,
    method1:function(){}
}

作为一名新手，以为它就是那么简单，看下例

例1：

var getEle={
            getPre:function(ele){//求某一节点的哥哥元素节点
                      var pre=ele.previousSibling;
                      while(pre && pre.nodeType!=1){
                          pre=pre.previousSibling;
                      }
                      return pre;
                      },
            getNext:function (ele){//求某一节点的兄弟元素节点
                        var next=ele.nextSibling;
                        while(next && next.nodeType != 1){
                            next=next.nextSibling;
                        }
                        return next;
                    }
} 

不就是键值对嘛，直接相对应就好了啊~~

---

然后，当我遇到这个问题的时候：

例2：
需求1：勾选框：最上面一个选中下面全部选中，在全部选中的状态下， 将其中一个取消，则最上面一个取消
需求2：点击表格头部的“数学成绩”，将成绩排序，点击第二次，反序，如图：

遇到这种问题，各位打算怎么办？我的思路：function+function+function……（看我的function万能大法）

for(var i=3;i<oThs.length;i++){
    oThs.item(i).onclick=(function(i){
        return function(){…………

for(var i=0;i<oChecks.length;i++){
    oChecks.item(i).onclick=(function(i){
        return function(){…………
        //就是这样用同一般的思路写到天昏地暗（具体代码各位可以脑补了）

师傅看完我写的代码，给了我一句：把高程3的对象看完再来找我~~~

好吧，奴才不会啊
向老好人师兄讨教，师兄大赞的来了句：“单例模式”；
无奈，只好尝试，如下代码一：

        var obj={
            firstcheck:function(allchecks){
                allchecks[0].onclick=function(){
                    for(var i=1;i<allchecks.length;i++){
                        allchecks[i].checked=this.checked;
                    }
                }
            },
            allcheck:function(allchecks){
                for(var j=1;j<allchecks.length;j++){
                    allchecks[j].onclick=function(){
                        for(var k=1;k<allchecks.length;k++){
                            if(allchecks[k].checked===false){
                                allchecks[0].checked=false;
                            }
                        }
                    };
                }
            },
            tSort:function(oTh){
                for(var i=3;i<oTh.length;i++){
                    oTh[i].onclick=(function(i){
                        return function(){
                            tableSort.call(this,i);
                        }
                    })(i)
                }
                function tableSort(j){
                    var oTbody=oTable.tBodies[0];
                    var allRows=oTbody.rows;
                    var allRowsAry=null;
                    allRowsAry=nodeList(allRows);
                    allRowsAry.sort(function(a,b){
                        return a.cells[j].innerHTML-b.cells[j].innerHTML;
                    })
                    if(this.getAttribute("px")=="des"){
                        allRowsAry.reverse();
                        this.setAttribute("px","inc");
                    }else{
                        this.setAttribute("px","des");
                    }
                    for(var p=0;p<allRowsAry.length;p++){
                        oTbody.appendChild(allRowsAry[p]);
                    }
                }
                function nodeList(nodelist){
                    var ary=[];
                    try{
                        ary=[].slice.call(nodelist,0);
                    }catch(e){
                        for(var j=0;j<nodelist.length;j++){
                            ary.push(nodelist[j])
                        }
                    }
                    return ary;
                }
            }
        }

---

对于以上代码，编写的时候各种坑，我就不多讲了，但是，各位看官，以上代码是否可以优化呢？

我有一种想法，是否可以将四个一起执行，只要输入一行代码就足够了呢？

脑海中浮现了比较流行的一个词汇：模块化开发
我可不可以使用模块化开发的思想，将传参，执行分开呢？

而这个想法的实现很简单，只需要在开始加入一些代码就好了，如下：

            init:function(opt){

                if(opt.index){
                    this.allcheck(opt.option);
                }
                if(opt.trindex){
                    this.firstcheck(opt.option);
                }
                if(opt.sortable){
                    this.tSort(opt.Th)
                }
            },

主要的想法就是在输入的时候首先进行判断，以确定是需要执行那一段代码，将传参与执行相互之间分开，便于后面的程序猿（媛）维护优化。