`

贡献一个连jquery都觉的大的时候可以用的 js库

 
阅读更多

在一些很小的项目里,连用jquery都还觉的大的时候,你就可以用我的这个库了。

一个库或者框架,是应需求而生的,当你的项目实际上只需要简单的一个好用的选择器 一个ajax 封装 一个兼容的事件封装的时候,你当然就会觉的jquery都太臃肿了,好吧,我那jquery剥离了这几个功能出来,本来我是只剥离jquery的domready 的, 但是发现这个东西牵扯到了jquery的事件模型的封装,那我就把jquery的事件也一并的剥离了下来,然后自己写了一个ajax封装。ok,一个最简单的js开发库成型了。代码在下面:

/*
 * 简易的开发js库 暂命名为 --- 呃没有命名
 * $选择器,ajax,event模块,dom.ready()方法
 * 该js library 暂时不能和同样用$符号注册window标志符的js framework or library比如jquery等协作,会有命名空间冲突
*/
(function(scope){
        var _my_library=scope.my_library,_$=scope.$;
        var my_library=scope.my_library=scope.$=function(selector,context){
            return my_library.fn.init(selector,context);
        }
        var quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#(\w+)$/;    
            // 简单的判断是一个html片段or是一个dom的id
            //undefined;//定义一个局部的undefined
        my_library.fn = {
            init : function(selector,context){
                   selector = selector || document;
                   if(selector.nodeType){
                      return selector;
                   }
                   if ( typeof selector == "string" ) {
                        var match = quickExpr.exec( selector );
                        if ( match && (match[1] || !context) ) {
                            if ( match[1] ){
                                //return new String(selector);
                                var temp = document.createElement('div'),
                                    frag = document.createDocumentFragment();
                                temp.innerHTML = selector;
                                (function(){
                                    if(temp.firstChild) {
                                        frag.appendChild(temp.firstChild);
                                        arguments.callee();
                                    } 
                                })();
                                //传入的为html串,则返回包含该html串的documentfragmet文档碎片
                                return frag;
                                
                            } else {
                                var elem = document.getElementById( match[3] );
                                if ( elem )
                                    return elem;
                                return undefined;
                            }
                         } else
                             var $ret=PetQuery(selector,context);                             
                             return $ret.length==0 ? undefined : $ret;
                    } else if (my_library.isFunction(selector)){
                        my_library.ready( selector,document);
                        //如果传入的是方法,那么就自动启动ready加栽执行
                    }
            }
        };
        var PetQuery = (function(){
            //pet query javascript选择器  begin
            var snack = /(?:[\w\-\\.#]+)+(?:\[\w+?=([\'"])?(?:\\\1|.)+?\1\])?|\*|>/ig,
                exprClassName = /^(?:[\w\-_]+)?\.([\w\-_]+)/,
                exprId = /^(?:[\w\-_]+)?#([\w\-_]+)/,
                exprNodeName = /^([\w\*\-_]+)/,
                na = [null,null];    
            function _find(selector, context) {
                context = context || document;        
                var simple = /^[\w\-_#]+$/.test(selector);        
                if (!simple && context.querySelectorAll) {
                    return realArray(context.querySelectorAll(selector));
                }        
                if (selector.indexOf(',') > -1) {
                    var split = selector.split(/,/g), ret = [], sIndex = 0, len = split.length;
                    for(; sIndex < len; ++sIndex) {
                        ret = ret.concat( _find(split[sIndex], context) );
                    }
                    return unique(ret);
                }        
                var parts = selector.match(snack),
                    part = parts.pop(),
                    id = (part.match(exprId) || na)[1],
                    className = !id && (part.match(exprClassName) || na)[1],
                    nodeName = !id && (part.match(exprNodeName) || na)[1],
                    collection;            
                if (className && !nodeName && context.getElementsByClassName) {            
                    collection = realArray(context.getElementsByClassName(className));            
                } else {            
                    collection = !id && realArray(context.getElementsByTagName(nodeName || '*'));            
                    if (className) {
                        collection = filterByAttr(collection, 'className', RegExp('(^|\\s)' + className + '(\\s|$)'));
                    }            
                    if (id) {
                        var byId = context.getElementById(id);
                        return byId?[byId]:[];
                    }
                }        
                return parts[0] && collection[0] ? filterParents(parts, collection) : collection;        
            }
            
            function realArray(c) {
                try {
                    return Array.prototype.slice.call(c);
                } catch(e) {
                    var ret = [], i = 0, len = c.length;
                    for (; i < len; ++i) {
                        ret[i] = c[i];
                    }
                    return ret;
                }        
            }    
            function filterParents(selectorParts, collection, direct) {
                var parentSelector = selectorParts.pop();        
                if (parentSelector === '>') {
                    return filterParents(selectorParts, collection, true);
                }        
                var ret = [],
                    r = -1,
                    id = (parentSelector.match(exprId) || na)[1],
                    className = !id && (parentSelector.match(exprClassName) || na)[1],
                    nodeName = !id && (parentSelector.match(exprNodeName) || na)[1],
                    cIndex = -1,
                    node, parent,
                    matches;
                    
                nodeName = nodeName && nodeName.toLowerCase();            
                while ( (node = collection[++cIndex]) ) {            
                    parent = node.parentNode;            
                    do {                
                        matches = !nodeName || nodeName === '*' || nodeName === parent.nodeName.toLowerCase();
                        matches = matches && (!id || parent.id === id);
                        matches = matches && (!className || RegExp('(^|\\s)' + className + '(\\s|$)').test(parent.className));                
                        if (direct || matches) { break; }                
                    } while ( (parent = parent.parentNode) );            
                    if (matches) {
                        ret[++r] = node;
                    }
                }        
                return selectorParts[0] && ret[0] ? filterParents(selectorParts, ret) : ret;        
            }  
            var unique = (function(){        
                var uid = +new Date();                
                var data = (function(){         
                    var n = 1;         
                    return function(elem) {         
                        var cacheIndex = elem[uid],
                            nextCacheIndex = n++;         
                        if(!cacheIndex) {
                            elem[uid] = nextCacheIndex;
                            return true;
                        }         
                        return false;         
                    };         
                })();        
                return function(arr) {
                    var length = arr.length,
                        ret = [],
                        r = -1,
                        i = 0,
                        item;                
                    for (; i < length; ++i) {
                        item = arr[i];
                        if (data(item)) {
                            ret[++r] = item;
                        }
                    }            
                    uid += 1;            
                    return ret;    
                };    
            })();    
            function filterByAttr(collection, attr, regex) {
                var i = -1, node, r = -1, ret = [];        
                while ( (node = collection[++i]) ) {
                    if (regex.test(node[attr])) {
                        ret[++r] = node;
                    }
                }        
                return ret;
            }    
            return _find;    
        })();
        //query is end



        my_library.isFunction = (function() {
            //修复jquery中isFunction的 BUG 
            // Performance optimization: Lazy Function Definition
            return "object"  === typeof document.getElementById ?
                   isFunction = function(fn){
                        try {
                            return /^\s*\bfunction\b/.test("" + fn);
                        } catch (x) {
                            return false
                        }
                   }:
                   isFunction = function(fn){
                       return "[object Function]" === Object.prototype.toString.call(fn);
                   };
        })();

        my_library.Each = function( object, callback, args ) {
            var name, i = 0, length = object.length;
            if ( args ) {
                if ( length === undefined ) {
                    for ( name in object )
                        if ( callback.apply( object[ name ], args ) === false )
                            break;
                } else
                    for ( ; i < length; )
                        if ( callback.apply( object[ i++ ], args ) === false )
                            break;
            // A special, fast, case for the most common use of each
            } else {
                if ( length === undefined ) {
                    for ( name in object )
                        if ( callback.call( object[ name ], name, object[ name ] ) === false )
                            break;
                } else
                    for ( var value = object[0];
                        i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
            }
            return object;
        };


        ////开始为dom ready做准备    begin
        Function.prototype.hookend = function(hook){
            //这里侵入了Function的原形,一个挂钩函数,让函数可以继承自己执行新的函数,唉,取舍啊
            var fn = this;
            return function(){
                    var ret = fn.apply(this, arguments);
                    hook.apply(this, arguments);
                    return ret;
            }
        };
        my_library.domReady=function(){
             //domready 页面load 回调的 顶层函数,后面通过$(function(){})添加的 函数 都 在由这个函数为顶层函数的闭包作用域链上
             if(scope.location.href.toString().indexOf("file:")!=0)
                 document.domain="qq.com";
             
        };
        my_library.isReady = false;
        // Handle when the DOM is ready
        my_library.ready_run = function() {
            // Make sure that the DOM is not already loaded
            if ( !my_library.isReady ) {
                // Remember that the DOM is ready
                my_library.isReady = true;
                // If there are functions bound, to execute
                my_library.domReady();
                //这里执行所有的domready函数
                my_library.domReady=null;
                //把扩展的hookend原型去掉,还原原型污染
                Function.prototype.hookend=null;
                delete Function.prototype.hookend;
                //这个方法的使命完成了
            }
        };
        my_library.ready = function(fn) {
            bindReady();
            if (my_library.isReady)
                fn.call(scope.document);
            else
                my_library.domReady=my_library.domReady.hookend(fn);
                //用挂钩闭包来缓存要domready执行的function
            return this;
        };
        var readyBound=false;
        function bindReady(){
            if ( readyBound ) return;
            readyBound = true;
            if ( document.addEventListener ) {
                document.addEventListener( "DOMContentLoaded", function(){
                    document.removeEventListener( "DOMContentLoaded", arguments.callee, false );
                    my_library.ready_run();
                }, false );
            // If IE event model is used
            } else if ( document.attachEvent ) {
                document.attachEvent("onreadystatechange", function(){
                    if ( document.readyState === "complete" ) {
                        document.detachEvent( "onreadystatechange", arguments.callee );
                        my_library.ready_run();
                    }
                });
                if ( document.documentElement.doScroll && window == window.top ) (function(){
                    if ( my_library.isReady ) return;
                    try {
                        document.documentElement.doScroll("left");
                    } catch( error ) {
                        setTimeout( arguments.callee, 0 );
                        return;
                    }
                    my_library.ready_run();
                })();
            }
            my_library.event.add( window, "load", my_library.ready_run );
        };


        var expando = "my_library" + now(), uuid = 0, windowData = {};
        function now(){
            return +new Date;
        }
        my_library.cache = {};
        my_library.data = function( elem, name, data ) {
            elem = elem == window ?
                windowData :
                elem;
            var id = elem[ expando ];
            if ( !id )
                id = elem[ expando ] = ++uuid;
            if ( name && !my_library.cache[ id ] )
                my_library.cache[ id ] = {};
            if ( data !== undefined )
                my_library.cache[ id ][ name ] = data;
            return name ?
                my_library.cache[ id ][ name ] :
                id;
        };
        my_library.removeData = function( elem, name ) {
            elem = elem == window ?
                windowData :
                elem;
            var id = elem[ expando ];
            if ( name ) {
                if ( my_library.cache[ id ] ) {
                    delete my_library.cache[ id ][ name ];
                    name = "";
                    for ( name in my_library.cache[ id ] )
                        break;
                    if ( !name )
                        my_library.removeData( elem );
                }
            } else {
                try {
                    delete elem[ expando ];
                } catch(e){
                    if ( elem.removeAttribute )
                        elem.removeAttribute( expando );
                }
                delete my_library.cache[ id ];
            }
        };
        my_library.event = {
            //该模块来自己jquery,所以相关注释请查看jquery的develope版本
            add: function(elem, types, handler, data) {
                if ( elem.nodeType == 3 || elem.nodeType == 8 )
                    return;
                if ( elem.setInterval && elem != window )
                    elem = window;
                if ( !handler.guid )
                    handler.guid = this.guid++;
                if ( data !== undefined ) {
                    var fn = handler;
                    handler = this.proxy( fn );
                    handler.data = data;
                }
                var events = my_library.data(elem, "events") || my_library.data(elem, "events", {}),
                    handle = my_library.data(elem, "handle") || my_library.data(elem, "handle", function(){
                        return typeof my_library !== "undefined" && !my_library.event.triggered ?
                            my_library.event.handle.apply(arguments.callee.elem, arguments) :
                            undefined;
                    });
                // event in IE.
                handle.elem = elem;
                my_library.Each(types.split(/\s+/), function(index, type) {
                    var namespaces = type.split(".");
                    type = namespaces.shift();
                    handler.type = namespaces.slice().sort().join(".");
                    var handlers = events[type];
                    
                    if ( my_library.event.specialAll[type] )
                        my_library.event.specialAll[type].setup.call(elem, data, namespaces);
                    if (!handlers) {
                        handlers = events[type] = {};
                        if ( !my_library.event.special[type] || my_library.event.special[type].setup.call(elem, data, namespaces) === false ) {
                            if (elem.addEventListener)
                                elem.addEventListener(type, handle, false);
                            else if (elem.attachEvent)
                                elem.attachEvent("on" + type, handle);
                        }
                    }
                    handlers[handler.guid] = handler;
                    my_library.event.global[type] = true;
                });
                // Nullify elem to prevent memory leaks in IE
                elem = null;
            },
            guid: 1,
            global: {},
            proxy: function( fn, proxy ){
                proxy = proxy || function(){ return fn.apply(this, arguments); };
                proxy.guid = fn.guid = fn.guid || proxy.guid || this.guid++;
                return proxy;
            },
            remove: function(elem, types, handler) {
                if ( elem.nodeType == 3 || elem.nodeType == 8 )
                    return;
                var events = my_library.data(elem, "events"), ret, index;
                if ( events ) {
                    if ( types === undefined || (typeof types === "string" && types.charAt(0) == ".") )
                        for ( var type in events )
                            this.remove( elem, type + (types || "") );
                    else {
                        if ( types.type ) {
                            handler = types.handler;
                            types = types.type;
                        }
                        my_library.Each(types.split(/\s+/), function(index, type){
                            var namespaces = type.split(".");
                            type = namespaces.shift();
                            var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)");
                            if ( events[type] ) {
                                if ( handler )
                                    delete events[type][handler.guid];
                                else
                                    for ( var handle in events[type] )
                                        if ( namespace.test(events[type][handle].type) )
                                            delete events[type][handle];                                            
                                if ( my_library.event.specialAll[type] )
                                    my_library.event.specialAll[type].teardown.call(elem, namespaces);
                                for ( ret in events[type] ) break;
                                if ( !ret ) {
                                    if ( !my_library.event.special[type] || my_library.event.special[type].teardown.call(elem, namespaces) === false ) {
                                        if (elem.removeEventListener)
                                            elem.removeEventListener(type, my_library.data(elem, "handle"), false);
                                        else if (elem.detachEvent)
                                            elem.detachEvent("on" + type, my_library.data(elem, "handle"));
                                    }
                                    ret = null;
                                    delete events[type];
                                }
                            }
                        });
                    }
                    // Remove the expando if it's no longer used
                    for ( ret in events ) break;
                    if ( !ret ) {
                        var handle = my_library.data( elem, "handle" );
                        if ( handle ) handle.elem = null;
                        my_library.removeData( elem, "events" );
                        my_library.removeData( elem, "handle" );
                    }
                }
            },
            handle: function(event) {                
                var all, handlers;
                event = arguments[0] = my_library.event.fix( event || window.event );
                event.currentTarget = this;
                var namespaces = event.type.split(".");
                event.type = namespaces.shift();
                all = !namespaces.length && !event.exclusive;                
                var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)");
                handlers = ( my_library.data(this, "events") || {} )[event.type];
                for ( var j in handlers ) {
                    var handler = handlers[j];
                    if ( all || namespace.test(handler.type) ) {
                        event.handler = handler;
                        event.data = handler.data;
                        var ret = handler.apply(this, arguments);
                        if( ret !== undefined ){
                            event.result = ret;
                            if ( ret === false ) {
                                event.preventDefault();
                                event.stopPropagation();
                            }
                        }
                        if( event.isImmediatePropagationStopped() )
                            break;
                    }
                }
           },
            props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
            fix: function(event) {
                if ( event[expando] )
                    return event;
                var originalEvent = event;
                event = my_library.Event( originalEvent );
                for ( var i = this.props.length, prop; i; ){
                    prop = this.props[ --i ];
                    event[ prop ] = originalEvent[ prop ];
                }
                if ( !event.target )
                    event.target = event.srcElement || document; 
                if ( event.target.nodeType == 3 )
                    event.target = event.target.parentNode;
                if ( !event.relatedTarget && event.fromElement )
                    event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
                if ( event.pageX == null && event.clientX != null ) {
                    var doc = document.documentElement, body = document.body;
                    event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
                    event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
                }
                if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
                    event.which = event.charCode || event.keyCode;
                if ( !event.metaKey && event.ctrlKey )
                    event.metaKey = event.ctrlKey;
                if ( !event.which && event.button )
                    event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
                return event;
            },
            proxy: function( fn, proxy ){
                proxy = proxy || function(){ return fn.apply(this, arguments); };
                proxy.guid = fn.guid = fn.guid || proxy.guid || this.guid++;
                return proxy;
            },    
            special: {
                ready: {
                    setup: bindReady,
                    teardown: function() {}
                }
            },
               specialAll: {
                live: {
                    setup: function( selector, namespaces ){
                        my_library.event.add( this, namespaces[0], liveHandler );
                    },
                    teardown:  function( namespaces ){
                        if ( namespaces.length ) {
                            var remove = 0, name = RegExp("(^|\\.)" + namespaces[0] + "(\\.|$)");
                            
                            my_library.each( (my_library.data(this, "events").live || {}), function(){
                                if ( name.test(this.type) )
                                    remove++;
                            });                            
                            if ( remove < 1 )
                                my_library.event.remove( this, namespaces[0], liveHandler );
                        }
                    }
                }
            }
        };
        my_library.Event = function( src ){
            if( !this.preventDefault )
                return new my_library.Event(src);            
            if( src && src.type ){
                this.originalEvent = src;
                this.type = src.type;
            }else
                this.type = src;
            this.timeStamp = now();
            this[expando] = true;
        };
        function returnFalse(){
            return false;
        }
        function returnTrue(){
            return true;
        }
        my_library.Event.prototype = {
            preventDefault: function() {
                this.isDefaultPrevented = returnTrue;

                var e = this.originalEvent;
                if( !e )
                    return;
                if (e.preventDefault)
                    e.preventDefault();
                e.returnValue = false;
            },
            stopPropagation: function() {
                this.isPropagationStopped = returnTrue;
                var e = this.originalEvent;
                if( !e )
                    return;
                if (e.stopPropagation)
                    e.stopPropagation();
                e.cancelBubble = true;
            },
            stopImmediatePropagation:function(){
                this.isImmediatePropagationStopped = returnTrue;
                this.stopPropagation();
            },
            isDefaultPrevented: returnFalse,
            isPropagationStopped: returnFalse,
            isImmediatePropagationStopped: returnFalse
        };

        my_library.ajax=function(options){
            var hastype= ("type" in options) ? true : false; 
            options={
                //默认设置               
               method : options.method || "GET",
               type   : options.type || "xml",
               url    : options.url || "",
               //超时连接,默认5秒
               timeout: options.timeout || 50000,
               delaytime:options.delaytime || 300,
                  
               onComplete: options.onComplete || function(){},
               onError: options.onError || function(){},
               onSuccess: options.onSuccess || function(){},
               data   : options.data || ""
               //服务器将会返回的数据类型
            };
            var xml=getXMLHttpRequest(options.type);

            //创建请求对象
            xml.open(options.method , options.url);

            //初始化异步请求
            //超时计算 begin//
            var timeoutLength=options.timeout;

            var delaylength = options.delaytime;

            //我们在请求5秒超时后放弃请求
            var requestDone=false;
            //请求超过300毫秒(目前默认为300毫秒)则延时
            var isdelay=false;

            setTimeout(function(){
                 //如果这个时候onreadystatechange回调函数已经执行请求已经返回,isdelay被该回调函数修改为null,否则设置isdelay=true说明系统已经开始延时
                 if (isdelay==null)
                     return;
                 isdelay=true; //系统已经延时                 
                 
                 //记录请求是否完成,这个时候就要注意设置请求可能超时的定时监听了
                 setTimeout(function(){
                   requestDone=true;
                 },timeoutLength);

            },delaylength)


            //超时计算 end//
            xml.onreadystatechange = function(){
              if(xml.readyState == 4 && !requestDone){
                 if(httpSuccess(xml)){
                    var r_data=httpData( xml , options.type);
                    if(r_data != null)
                        options.onSuccess(r_data);
                    else 
                        options.onError(null);
                 } else {
                     //否则就发生了错误
                    $.ui.showErr("服务器响应失败!http状态为"+xml.status);
                    options.onError();
                 }
                 options.onComplete();
                 //调用完成回调函数
                 xml = null;
                 //为避免内存泄漏,清理文档
              }
            };    
            xml.send();
            //发送请求,建立连接
            function httpSuccess(r){
               try
               { 
                 //得不到服务器状态,而且我们正在请求本地文件,认为成功,200到300间的状态码表示成功      304未修改状态也酸成功    safari在文档为修改时返回空状态,,,
                 return !r.status && location.protocol == "file:" ||(r.status >= 200 && r.status<300) || r.status ==304 || navigator.userAgent.indexOf("Safari") > 0 && typeof r.status == "undefined" ;
               }
               catch (e){}
               return false;
               //若请求失败
            };
            function httpData(r,type){
               //如果该方法返回null的话,则onsuccess回调函数不执行
                //组装返回的对象数据
               //抓去响应的http头部信息
               var ct = r.getResponseHeader("content-type");

               //检索返回是否为xml对象
               var data = ct && ct.indexOf("xml") >= 0;

               //alert(data)
               //如果用户设置要输出xml,只有在type参数为xml 并且是手动配置的xml才解析response
               data = (type == "xml" && hastype ) || data ? r.responseXML : r.responseText;

               //因为ie不能解析responsexml
               if(((type == "xml" && hastype ) || (ct && ct.indexOf("xml") >= 0) ) && window.ActiveXObject){
                   //ie下面需要转换一下
                    //data=r.responseText;
                    var doc = new ActiveXObject("MSxml2.DOMDocument")
                    doc.loadXML(r.responseText);
                    data=doc;
                    //避免内存泄漏,清理该文档
                    doc=null;
               }

               //返回json对象
               if(type == "json") {
                  try{
                     
                       /*return (new Function("return"+data))();*/
                       var c_obj=(new Function("return"+data))();

                       if(c_obj.result && c_obj.result == -1){
                            $.ui.showErr(c_obj.msg);
                            return null;
                       } else 
                            return c_obj;
                       
                  }
                  catch (e){
                      alert(e.message)
                      alert(data);
                      return null;
                      //如果alert出了这里,说明组织的json对象的数据结构错误,无法解析成对象
                  }
               }

               //请求一个script脚本
               if(type == "script") {
                   //eval.call(window,data);//这个不行,被john骗了
                   var script_o=document.createElement("script");
                   script_o.nodeValue=data;
                   script_o.setAttribute("charset","utf-8");
                   $("head")[0].appendChild(script_o);
               }
               return data;
            };
            function getXMLHttpRequest (type){       
                var xmlHR=false;
                if(scope.ActiveXObject){
                    try {xmlHR=new ActiveXObject("Msxml2.XMLHTTP");}
                    catch(e){try{xmlHR=new ActiveXObject("Microsoft.XMLHTTP");}
                    catch(e){try{xmlHR=new ActiveXObject("Msxml2.XmlHttp.4.0");}catch(e){}}}
                }else if(scope.XMLHttpRequest){
                    xmlHR=new XMLHttpRequest();
                    if(xmlHR.overrideMimeType){
                       if (!hastype){//如果没有传入type参数那么头定义为html的
                           xmlHR.overrideMimeType('text/xml');
                       } else {
                           switch (type){
                               case "xml": xmlHR.overrideMimeType('text/xml');
                               break
                               case "json":xmlHR.overrideMimeType('text/json');
                               break
                               default : xmlHR.overrideMimeType('text/html');
                           }
                       }
                    }
                    }else{alert("Create XMLHttpRequest object false!");return false;}
                return xmlHR;
            }
        };    
       
})(window);
 关键的 我来说下我的这个 选择器啊,这个选择器和jq最大的不同 ,就是 返回的不是一个jq对象,而是直接返回你所以找到的dom对象 or domlist。其他的,很,很简单,自己看看吧。 至于domready  就是$(function(){//这个就是push进ready准备执行的 处理函数了,})

 简单吧,真的很简单。

分享到:
评论

相关推荐

    jquery-3.7.0.min.js(jQuery下载)

    jquery-3.7.0.min.js(jQuery下载)jquery-3.7.0.min.js(jQuery下载)jquery-3.7.0.min.js(jQuery下载)jquery-3.7.0.min.js(jQuery下载)jquery-3.7.0.min.js(jQuery下载)jquery-3.7.0.min.js(jQuery下载)...

    jquery框架的js库

    jQuery还有一个比较大的优势是,它的文档说明很全,而且各种应用也说得很详细,同时还有许多成熟的插件可供选择。 jQuery能够使用户的html页保持代码和html内容分离,也就是说,不用再在html里面插入一堆js来调用...

    仿照jquery封装一个自己的js库(一)

    仿照jquery封装一个自己的js库(一)

    jquery的js文件

    jquery jquery.js javascript库 jquery库jquery jquery.js javascript库 jquery库jquery jquery.js javascript库 jquery库jquery jquery.js javascript库 jquery库

    jquery插件库(jquery.treeview插件库)

    jquery插件库(jquery.treeview插件库)jquery插件库(jquery.treeview插件库)jquery插件库(jquery.treeview插件库)jquery插件库(jquery.treeview插件库)jquery插件库(jquery.treeview插件库)jquery插件库(jquery....

    jquery-3.3.1.js和jquery-3.3.1.min.js

    jquery-3.3.1.js和jquery-3.3.1.min.js免费下载哈。jquery-3.3.1.js和jquery-3.3.1.min.js免费下载哈。jquery-3.3.1.js和jquery-3.3.1.min.js免费下载哈。jquery-3.3.1.js和jquery-3.3.1.min.js免费下载哈。jquery-...

    Javascript脚本库:jQuery类库

    jQuery还有一个比较大的优势是,它的文档说明很全,而且各种应用也说得很详细,同时还有许多成熟的插件可供选择。jQuery能够使用户的html页保持代码和html内容分离,也就是说,不用再在html里面插入一堆js来调用命令...

    jquery-1.11.1.js

    jQuery库

    jquery1.2.3到3.3.1版本都有

    jquery1.2.3到3.3.1版本都有: jquery-1.10.2.min.js jquery-1.11.1.min.js jquery-1.11.3.min.js jquery-1.2.3.min.js jquery-1.3.2.min.js jquery-1.4.2.min.js jquery-1.4.4.min.js jquery-1.5.2.min.js jquery-...

    jquery-1.7.2.js免费下载

    jquery-1.7.2.min.js (minified, production) jquery-1.7.2.js (unminified, debug) jQuery 1.7 正式版已经可以下载使用。jQuery是一个JavaScript库,它简化了HTML文档遍历,事件处理,动画和为网络快速发展的Ajax...

    jquery 手册 一个新型的JavaScript库

    jQuery是一个简洁快速的JavaScript库,它能让你在你的网页上简单的操作文档、处理事件、运行动画效果或者添加Ajax交互。jQuery的设计会改变你写JavaScript代码的方式。 jQuery适合于设计师、开发者以及那些还好者,...

    jquery-1.9.1.min.js_javascript_jquery_

    jQuery 是一个 JavaScript 库。jQuery 极大地简化了 JavaScript 编程。jQuery 很容易学习。

    jQuery与其他JS库或jQuery文件冲突解决方法

    本人亲测,本人网页有两个JS效果,用到了两个jQuery文件(一个是jquery.min.js,另一个是jquery.pack.js),可以两个冲突,只能保留一个。 但效果就只能有一个。我想两个都保留,于是就想了很多办法,查了很多资料,...

    jquery 库文件jquery-1.4.2.min.js

    jquery 库文件jquery-1.4.2.min.js 发布的最新版本

    各个版本的JQuery库

    jquery-1.1.4.js jquery-1.4.3.js jquery-1.6.2.js jquery-1.7.1.min.js .. 从jquery1.1到jquery1.7.1各个版本的js库文件

    史上最全jquery核心库

    jquery-1.9.1.js jquery-1.9.1.min.js jquery-1.10.1.js jquery-1.10.1.min.js jquery-2.0.2.js jquery-2.0.2.min.js jquery-1.2.6.js jquery-1.2.6.min.js jquery-1.3.2.js jquery-1.3.2.min.js jquery-1.4.4.js ...

    jquery各个版本的js库

    jquery-1.6.3、jquery-1.6.4、jquery-1.7.1、jquery-1.7.2、jquery-1.8.0、jquery-1.8.1、jquery-1.8.2、jquery-1.8.3、jquery-1.9.0、jquery-1.9.1、jquery-2.0.0版本的jquery JS 库

    jQuery一个非常流行的操作Dom的JavaScript库

    jQuery 一个非常流行的操作Dom的 JavaScript 库

    原生JS打印插件之jQuery.EasyPrint.js使用文档

    使用JS实现打印功能;JavaScript 实现打印操作;javascript打印大全;通用;js实现打印的方式;JS怎么实现页面打印呢?JavaScript 实现打印,打印预览,打印设置;JS打印和报表输出;原生js打印插件Print.js;js控制...

    jquery-2.1.1.js 、jquery-2.1.1.min.js 【jquery包 js】

    jquery-2.1.1.js 、jquery-2.1.1.min.js 【jquery包 js】

Global site tag (gtag.js) - Google Analytics