DOM库，持续更新中。。。

//2013-9-21 Seaゞ_Ysd 整理

//=====================================================================================================//


//字符串扩展方法：去除字符串首尾的空格
String.prototype.trim=function(){
    var reg=/^\s+|\s+$/g;//以至少1个空格开头，以至少一到多个空格结尾
    return this.replace(reg,'');
}
//给数组扩展一个去除数组中的重复项的方法
Array.prototype.distinct=function(){
    for(var i=0;i<this.length;i++){
        var a=this[i];
        for( var j=i+1;j<this.length;){
            if(a==this[j]){
                this.splice(j,1)
            }else{
                j++
            }
        }
    }
    return  this;
}


//=====================================================================================================//
var DOM={
    //添加到某个节点后
    insertAfter:function(newNode,oldNode){
        /*var next=oldNode.nextSibiling;
        if(next){
            oldNode.parentNode.insetBefore(newNode,next);
        }else{
            oldNode.parentNode.appendChild(newNode)
        }*/
        //三元
        if(oldNode&&oldNode.nodeType===1&&newNode&&newNode.nodeType===1){
            oldNode.nextSibiling?oldNode.parentNode.insetBefore(newNode,next):oldNode.parentNode.appendChild(newNode);
        }else{
            throw new Error("参数传入错误");
        }
    },    
    //前追加
    prepend:function(newNode,parentNode){
        var Child=parentNode.firstChild;
        Child?parentNode.insertBefore(newNode,Child):parentNode.appendChild(newNode);    
    },
    //找出某个元素所有的哥哥节点
    preSiblings:function(currentEle){
        var pre=currentEle.previousSibiling;
        var a=[];
        while(pre){
            if(pre.nodeType===1){
                a.unshift(pre);
            }
        pre=pre.previousSibling;    
        }
        return a;
    },
    //找出某个元素所有的弟弟节点
    nextSibilings:function(currentEle){
        var next=currentEle.nextSibiling;
        var a=[];
        while(next){
            if(next===1){
                a.push(next);    
            }
        next=next.nextSibiling;
        }
        return a;
    },
    //z找出某个元素所有的兄弟节点
    sibilings:function(currentEle){
        return DOM.preSiblings(currentEle).concat(DOM.nextSibilings(currentEle));
    },
    //找出某个元素的上一个元素节点
    preEle:function(currentEle){
        if(currentEle.previousElementSibling){
            return currentEle.previousElementSibling
        }else{
            var pre=currentEle.previousSibiling;
            /*if(pre.nodeType==1&&pre.nodeType){
                return pre;
            }else{
                pre=pre.previousSibiling;
            }*/
            while(pre){
                if(pre.nodeType===1){
                    return pre;
                }
                pre=pre.previousSibling;    
            }
            return null;//它没有哥哥元素则返回null。
            }
    },
    //找出某个元素的下一个元素节点
    nextEle:function(currentEle){
        if(currentEle.nextElementSibling){
            return currentEle.nextElementSibling
        }else{
            var next=currentEle.nextSibiling;
            while(next){
                if(next.nodeType===1){
                    return next;
                }
                next=next.nextSibling;    
            }
            return null;//它没有哥哥元素则返回null。
        }
        
    },
    
    //获得ele指定标签名为tag的子元素。tag参数如果不传，则表示获取ele的所有子元素
    getChildren:function (ele,tag){
        var children=ele.childNodes;//先把ele所有子节点取到
        if(typeof tag=='string'){
                tag=tag.toUpperCase();
                var a=[];
                for(var i=0;i<children.length;i++){//做循环
                    var node=children[i];
                    if(node.nodeType==1&&node.nodeName==tag){
                        //如果当前这个子元素的“节点类型"是1 并且 节点名是tag的值
                        a.push(node);//则把此子节点放到数组里            
                    }        
                }
                return a;
                
        }else if(typeof tag=='undefined'){
                var a=[];
                for(var i=0;i<children.length;i++){//做循环
                    var node=children[i];
                    if(node.nodeType==1){
                        a.push(node);//则把此子节点放到数组里            
                    }        
                }
                return a;
        }else{
            throw new Error('tag参数类型错误！');    
        }    
    },
    
    
    //获取元素ele的索引号
    
    getIndex:function(ele){
        var nIndex=0;
        var p=ele.previousSibling
        while(p){
            if(p.nodeType==1){//如果这个哥哥是元素节点，则
                nIndex++;//让累加一次
            }            
            p=p.previousSibling;//继续判断它的下一个哥哥        
        }
        return nIndex;    
    },
    
    //给ele元素增加类样式
    addClass:function(ele,strClass){
        var reg=RegExp("\\b"+strClass+"\\b");
        if(reg.test(ele.className)){
        }else{
            ele.className=ele.className.trim()+''+strClass;
        }
    },
    
    //给ele元素移除类样式
    removeClass:function (ele,strClass){
        if(!(ele&&ele.nodeType==1)){    
            alert('第一参数ele需要是一个DOM元素对象');
            throw new Error('第一参数ele需要是一个DOM元素对象');
        }
        if(typeof strClass != 'string'){
            alert('第二参数必须为string类型');
            throw new Error('第二参数必须为string类型');
            
        }
        
        var reg=new RegExp("\\b"+strClass+"\\b",'g');    
        ele.className=ele.className.replace(reg,'').trim();    
    },
    
    //获取某元素距离浏览器的绝对位置,相当于jQuery中的offset
    getPosition:function(ele){
        var x=ele.offsetLeft;
        var y=ele.offsetTop;
        var p=ele.offsetParent;
        while(p&&p!=document.body){
            if(window.navigator.userAgent.indexOf('MSIE 8.0'>-1)){
                x+=p.offsetLeft;
                y+=p.offsetTop;
            }else{
                x+=p.offsetLeft+p.clientLeft;
                y+=p.offsertTop+p.clientTop;
            }
            p=p.offsetParent;
        }
        var obj={};
        obj.x=x;
        obj.y=y;
        return obj;
    }
    
//等待更新中。。。    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
};