关于Jquery对象的说明,以及异步

1、jquery选择器$('selector')返回的不是数组，而是封装好的jquery对象。但这个对象有一个特别的地方，就是查询到的节点被以下标为属性，添加到了jquery对象上，所以它看起来像数组，因为它存在一些属性是数字；

2、jquery对象有哪些属性和方法？

我们可以理解，$('selector')返回了一个对象obj，obj[0]....obj[i]总是返回查询到的第i个节点。除此之外，jquery对象还被通过prototype添加了一些方法，即：

1 2 3 4 5

jQuery.prototype.each = function(){} jQuery.prototype.hasClass = function(){} jQuery.prototype.hide = function(){} jQuery.prototype.css = function(){} jQuery.prototype.attr = function(){}

等等。这样的话，$('selector')返回的对象就可以调用这些方法，比如obj.attr('name')、obj.css('color', 'red')。

3、jquery方法如何处理多个节点？

实际上，以上诸如hide、css、attr等方法，在jquery内部都是通过循环来处理各个节点的。但是，如果是要获取节点属性，比如obj.attr('name')，显然这个只能返回一个字符串，所以类似的方法都是获取节点集合中的第一个节点的属性。也就是说，虽然返回的节点很多，但只有第一个会被处理。

4、为什么jquery可以链式调用？

在jquery中，很多同名的方法通过参数个数的不同实现不同的功能，比如css方法，如果传一个参数则表示获取css属性；如果传两个参数，则表示给节点添加某个属性，并赋值为第二个参数。attr、width等也是这样的处理。对于方法的返回值，除了获取属性值、获取css值等需要返回实际值的方法外，当css方法、attr方法表示为为节点添加属性、css样式时，是不需要返回值的，但jquery让这些方法返回了this，也就是返回了调用者自身，所以可以链式调用。

5、那么到底为什么要用链式操作呢？ 
为了更好的异步体验 
Javascript是无阻塞语言，所以他不是没阻塞，而是不能阻塞，所以他需要通过事件来驱动，异步来完成一些本需要阻塞进程的操作。 

但是异步编程是一种令人疯狂的东西……运行时候是分离的倒不要紧，但是编写代码时候也是分离的就…… 
常见的异步编程模型有哪些呢？ 
•回调函数 
所谓的回调函数，意指先在系统的某个地方对函数进行注册，让系统知道这个函数的存在，然后在以后，当某个事件发生时，再调用这个函数对事件进行响应。 

复制代码 代码如下:

function f(num, callback){ 
if(num<0) { 
alert("调用低层函数处理!"); 
alert("分数不能为负,输入错误!"); 
}else if(num==0){ 
alert("调用低层函数处理!"); 
alert("该学生可能未参加考试！"); 
}else{ 
alert("调用高层函数处理!"); 
setTimeout(function(){callback();}, 1000); 
} 
} 

这里callback则是回调函数。可以发现只有当num为非负数时候callback才会调用。 
但是问题，如果我们不看函数内部，我们并不知道callback会几时调用，在什么情况下调用，代码间产生了一定耦合，流程上也会产生一定的混乱。

虽然回调函数是一种简单而易于部署的实现异步的方法，但从编程体验来说它却不够好。 
•事件监听 
也就是采用事件驱动，执行顺序取决于事件顺序。 

复制代码 代码如下:

function EventTarget(){ 
this.handlers = {}; 
} 
EventTarget.prototype = { 
constructor: EventTarget, 
addHandler: function(type, handler){ 
this.handlers[type] = []; 
}, 
fire: function(){ 
if(!event.target){ 
event.target = this; 
} 
if(this.handlers[event.type instanceof Array]){ 
var handlers = this.handlers[event.type]; 
for(var i = 0, len = handlers.length, i < len; i++){ 
handlers[i](event); 
} 
} 
}, 
removeHandler: function(type, handler){ 
if(this.handlers[type] instanceof Array){ 
var handlers = this.handlers[type]; 
for(var i = 0, le = handlers.length; i < len; i++){ 
if(handlers[i] === handler){ 
break; 
} 
} 
handlers.splice(i, 1); 
} 
} 
}; 

上面是《JavaScript高级程序设计》中的自定义事件实现。于是我们就可以通过addHandler来绑定事件处理函数，用fire来触发事件，用removeHandler来删除事件处理函数。 

虽然通过事件解耦了，但流程顺序更加混乱了。 
•链式异步 
个人觉得链式操作最值得称赞的还是其解决了异步编程模型的执行流程不清晰的问题。jQuery中$(document).ready就非常好的阐释了这一理念。DOMCotentLoaded是一个事件，在DOM并未加载前，jQuery的大部分操作都不会奏效，但jQuery的设计者并没有把他当成事件一样来处理，而是转成一种“选其对象，对其操作”的思路。$选择了document对象，ready是其方法进行操作。这样子流程问题就非常清晰了，在链条越后位置的方法就越后执行。 

复制代码 代码如下:

(function(){ 
var isReady=false; //判断onDOMReady方法是否已经被执行过 
var readyList= [];//把需要执行的方法先暂存在这个数组里 
var timer;//定时器句柄 
ready=function(fn) { 
if (isReady ) 
fn.call( document); 
else 
readyList.push( function() { return fn.call(this);}); 
return this; 
} 
var onDOMReady=function(){ 
for(var i=0;i<readyList.length;i++){ 
readyList[i].apply(document); 
} 
readyList = null; 
} 
var bindReady = function(evt){ 
if(isReady) return; 
isReady=true; 
onDOMReady.call(window); 
if(document.removeEventListener){ 
document.removeEventListener("DOMContentLoaded", bindReady, false); 
}else if(document.attachEvent){ 
document.detachEvent("onreadystatechange", bindReady); 
if(window == window.top){ 
clearInterval(timer); 
timer = null; 
} 
} 
}; 
if(document.addEventListener){ 
document.addEventListener("DOMContentLoaded", bindReady, false); 
}else if(document.attachEvent){ 
document.attachEvent("onreadystatechange", function(){ 
if((/loaded|complete/).test(document.readyState)) 
bindReady(); 
}); 
if(window == window.top){ 
timer = setInterval(function(){ 
try{ 
isReady||document.documentElement.doScroll('left');//在IE下用能否执行doScroll判断dom是否加载完毕 
}catch(e){ 
return; 
} 
bindReady(); 
},5); 
} 
} 
})(); 

上面的代码不能用$(document).ready，而应该是window.ready。 
•Promise 
CommonJS中的异步编程模型也延续了这一想法，每一个异步任务返回一个Promise对象，该对象有一个then方法，允许指定回调函数。 
所以我们可以这样写： 
f1().then(f2).then(f3); 
这种方法我们无需太过关注实现，也不太需要理解异步，只要懂得通过函数选对象，通过then进行操作，就能进行异步编程。