jljlpch

mootools 1.1.1extend的功能测试

jljlpch — Tue, 02 Sep 2008 10:51:26 +0800

作者: jljlpch 链接：http://jljlpch.javaeye.com/blog/235622 发表时间: 2008年09月02日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

prk

已有 0 人发表留言，猛击->>这里<<-参与讨论

JavaEye推荐

T-SQL 存储过程

jljlpch — Tue, 02 Sep 2008 08:02:44 +0800

作者: jljlpch 链接：http://jljlpch.javaeye.com/blog/235550 发表时间: 2008年09月02日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

prk/彭仁夔 08-09-02 转载注明出处。

在开发中，我们经常要用到这样的统计

根据用户输入的日期，把每个月的备份表的数据和正在使用的表中的综合起来统计。假如2008-05-11到2008-08-01，那么就包含5，6，7，8四张备份表还有正在使用的表，加起5张表。这是要统计的所有的数据。

对于统计又有要求，分情况来统计各种情况的总计，但是有的特殊情况要统计其明细。

如下图：

T-sql日期转换不兼容。还有对运行的sql的长度也有一定的限制。

prk/彭仁夔 08-09-02 转载注明出处。

ALTER PROCEDURE [dbo].[UP_TSMReceivedDailyReport]
@StartTime varchar(100),
@EndTime    varchar(100),
@OrgAddrs  varchar(1000)='',
@MsgType_IDs  varchar(1000)=''
 AS 
     declare @where  varchar(1000)
     declare @startMonth  int 
     declare @endMonth int 
     declare @tempMonth int
     declare @generalSql varchar(1000)
     declare @tempSql varchar(1000)
     declare @tempSql1 varchar(3000)
     declare @tempTotal varchar(3000)
     declare @tempUndeal varchar(3000)
     declare @tempdealing varchar(3000)
     declare @tempdealed varchar(3000)
     declare @temp1 varchar(3000)
     declare @temp2 varchar(3000)
     declare @temp3 varchar(3000)
     declare @temp4 varchar(3000)
     declare @mm int
     declare @mm1 int
  /*
    declare @StartTime varchar(100)
    declare @EndTime    varchar(100)
    declare @OrgAddrs  varchar(1000)
    declare @MsgType_IDs  varchar(1000)
 
   set @StartTime ='2008-05-05'
   set  @EndTime  ='2008-07-07'
   set  @OrgAddrs =''
   set  @MsgType_IDs =''
*/
    set  @startMonth=Month(@StartTime)
    set  @endMonth =Month(@EndTime)
    set  @tempMonth=@startMonth
    set  @tempSql=' '
    set  @tempSql1=' '
    set  @temp1=' '
    set  @temp2=' '
    set  @temp3=' '
    set  @temp4=' '
    set  @where=' where recvTime>='''+CAST(@StartTime as varchar(20))+''' and recvTime<='''+CAST(@EndTime as varchar(20))+'''  '

    if @OrgAddrs!=''
     begin
      set @where=@where+' '+ ' and OrgAddr in '+@OrgAddrs+' '
      end
    
    if @MsgType_IDs!=''
       begin
       set @where=@where+' '+ ' and MsgType_ID in '+@MsgType_IDs+' '
       end
     print @where
     set @generalSql=' select RecvSM_ID,User_ID,MsgType_ID,OrgAddr ,DestAddr, cast(RecvTime as DateTime) RecvTime,
       SM_Content,DealSign,cast(DealTime as DateTime) DealTime,IsWait,ReMsgType_ID,SendSM_Content   
         from T_SMReceived '+@where+' and DealSign<>4  and (DealSign<>8 and iswait<>0) and (DealSign<>3 and IsWait<>0)'
       print @generalSql

create table #temp  (RecvSM_ID int, 
                      User_ID int, 
                      MsgType_ID int, 
                     OrgAddr varchar(128), 
                     DestAddr varchar(128), 
                     RecvTime datetime, 
                     SM_Content varchar(6000), 
                     DealSign tinyint, 
                     DealTime datetime,
                     IsWait bit, 
                     ReMsgType_ID int ,
                     SendSM_Content varchar(6000) )
   
    insert into #temp exec (@generalSql)
  
while @tempMonth<=@endMonth
       begin      
   set @tempSql='select RecvSM_ID,User_ID,MsgType_ID,OrgAddr ,DestAddr, cast(RecvTime as DateTime) RecvTime,
       SM_Content,DealSign,cast(DealTime as DateTime) DealTime,IsWait,ReMsgType_ID,SendSM_Content   from T_SMReceived_'+Cast(@tempMonth as varchar(2))+'  '+@where+' '
     insert into #temp  exec (@tempSql)       
       
     set @tempMonth= @tempMonth+1
     end   
     
      select @mm= count(*) from #temp
    print 'the temp table have:'+cast(@mm as varchar(100))

     set @temp1='select  msgtype_id  ,convert(varchar(10),recvtime,120) recvtime , total=count(*)     from #temp  '
     set @temp2=' group by  convert(varchar(10),recvtime,120), msgtype_id  '
     set @tempTotal = @temp1+''+@temp2
     print @tempTotal
     set @tempUndeal = @temp1+' where (iswait=1 and DealSign=0) or DealSign=2  or (iswait=1 and DealSign=8) '+@temp2
     print @tempUndeal
     set @tempdealing =@temp1+' where (iswait=1 and DealSign=1) or (iswait=1 and DealSign=9) '+@temp2
     print @tempdealing
     set @tempdealed =@temp1+' where (iswait=0 and DealSign=3) or (iswait=0 and DealSign=4) '+@temp2
     print @tempdealed

     set @temp3='select a.MsgType_ID , a.RecvTime,a.total,
     (select undeal= case  when b.total IS NULL  then 0 else b.total end) undeal ,
     (select dealing= case  when c.total IS NULL  then 0 else c.total end) dealing,
     (select dealed= case  when d.total IS NULL  then 0 else d.total end) dealed,
      undealDetail=null,dealingDetail=null,dealedDetail=null from ('+@tempTotal+') a left join ('
        +@tempUndeal+') b on a.msgtype_id=b.msgtype_id and a.recvtime=b.recvtime left join ('+
        @tempdealing+' ) c on a.msgtype_id=c.msgtype_id and a.recvtime=c.recvtime left join ( '
        +@tempdealed+') d on a.msgtype_id=d.msgtype_id and a.recvtime=d.recvtime'
    
   print '#temp1 SQL: '+ @temp3

create table #temp1  (
                     MsgType_ID int,                      
                     RecvTime varchar(10), 
                     total int,
                     undeal int,                      
                     dealing int,                     
                     dealed int,
                     undealDetail varchar(1000),
                     dealingDetail varchar(1000),
                     dealedDetail varchar(1000),                    
                     ) 

 insert into #temp1   exec(@temp3)


      select @mm1= count(*) from #temp1
print 'the #templ have :'+cast(@mm1 as varchar(100))

declare finalReport cursor 
  for select MsgType_ID,convert(varchar(10),recvtime,120) RecvTime ,dealed from #temp1
   open finalReport

     declare @MsgType_IDf int
     declare @RecvTimef varchar(10)
     declare @dealedf int
      print  'start tatal one record';
     fetch next from finalReport into @MsgType_IDf, @RecvTimef ,@dealedf
      while(@@fetch_status=0)
         begin

             declare my_cursor cursor 
              
              for  select a.msgtype_id ,a.recvtime,a.size,a.reMsgType_ID,b.ReMsgTypeName from
                     (select msgtype_id,count(*) size, convert(varchar(10),recvtime,120) recvtime,reMsgType_ID from #temp 
                       where convert(varchar(10),recvtime,120)=@RecvTimef and msgtype_id=@MsgType_IDf and (iswait=0 and (DealSign=3 or DealSign=4))   group by  convert(varchar(10),recvtime,120), msgtype_id,reMsgType_ID) a left join T_ReMsgType b
                      on a.reMsgType_ID=b.reMsgType_ID order by a.msgtype_id

                open my_cursor

                 declare @msgtype_id int
                 declare @recvtime varchar(10)
                 declare @reMsgType_ID int
                 declare @ReMsgTypeName varchar(500)
                 declare @dealedDetail varchar(500)
                 declare @size int
                 declare @flag int

                 set @flag=0
                 set @dealedDetail='总数:'+Cast(@dealedf as varchar(5))+' (其中 '
                  print  'start deal one record';
               fetch next from my_cursor into @msgtype_id,@recvtime,@size,@reMsgType_ID,@ReMsgTypeName
                 while(@@fetch_status=0)
                       begin

                         set @dealedDetail= @dealedDetail+@ReMsgTypeName+': '+                 
                         Cast((select undeal= case  when @size IS NULL  then 0  else @size end) as varchar(5))+','
                          set @flag=1  
                  
                         fetch next from my_cursor into @msgtype_id,@recvtime,@size,@reMsgType_ID,@ReMsgTypeName
                       end

                   if @flag=0
                       begin
                       set @dealedDetail=substring(@dealedDetail,0,len(@dealedDetail)-3)
                       end
                    else 
                       begin
                         set @dealedDetail=substring(@dealedDetail,0,len(@dealedDetail))+')'
                       end
                close my_cursor 
                DEALLOCATE my_cursor
          update #temp1 set dealedDetail= @dealedDetail  where convert(varchar(10),recvtime,120)=@RecvTimef and msgtype_id=@MsgType_IDf 
            print  'have update one record';

     fetch next from finalReport into @MsgType_IDf, @RecvTimef ,@dealedf
          end
    close finalReport
    DEALLOCATE finalReport

 select c.*,d.MsgTypeName from #temp1 c left join T_MsgType d on c.msgtype_id=D.msgtype_id  order by c.RecvTime,c.msgtype_id

已有 0 人发表留言，猛击->>这里<<-参与讨论

JavaEye推荐

Jquery1.2.6 源码分析

jljlpch — Fri, 29 Aug 2008 00:13:37 +0800

作者: jljlpch 链接：http://jljlpch.javaeye.com/blog/234218 发表时间: 2008年08月29日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

jQuery是一个非常优秀的JS库，与Prototype,YUI,Mootools等众多的Js类库相比，它剑走偏锋，从web开发的实用角度出发，抛除了其它Lib中一些中看但不实用的东西，为开发者提供了优美短小而精悍的类库。其使用简单，文档丰富，而且性能高效，能极大地提高web系统的开发效率。因此可以说是web应用开发中最佳的Js辅助类库之一。大部分开发者正在抛弃Prototype，而选择Jquery做为他们进行web开发的JS库。

如是开发人员仅仅只知道文档中的简单的使用方法，却不明白Jquery的运行原理和内部机制，在使用jquery时，肯定会碰到许多的问题。这些问题有一部分是Jquery的Bug。大部分是自身的使用不当而造成的。而文档的简单的使用说明很难解决问题。在调试基于jQuery的web应用时，很多时候都要跟踪进入jQuery对象分析其运行状态以了解出错的原因。

如果对于web的应用的页面运行性能和效率有所要求的话，那么我们更应该去明白其运行机理和核心源码。但是jQuery源码不像其它的类库那样，它有点晦涩，难懂。这就是本源码分析的原因，让所有使用jQuery的读者，能快速上手jQuery的源码，并在开发中得心应用。

Jquery的网络资源丰富，但Baidu了很久，很难找到那种完全深入地分析Jquery源码的文稿。倒是Jquery的开发者，John Resi的《Pro Javascript Techniques》涉及到Jquery的源码的分析，但是其主指还是在于JavaScript的使用。那本书并不能使我们完全细致地了解Jquery的源码。

写个这个源码分析的理由其实很简单，在工作中使用jquery经常出问题，不得不分析其源码，我把分析的源码放在blog。其标题是jquery core 源码分析。结果有一网友竟评论说打到标题党，可见还是有很多人像我这样想完全了解jquery的core代码。

从自己能看懂，到自己写出来。发现自己有一个质的提高。但是由于水平有限，分析过程的难免有错误。请大家多多指教。不过嘴下能留情就最好了。有什么问题可以到blog:jljlpch.javaeye.com去访问和评论。附件附有打包的源码。

2008-08-29 prk

已有 0 人发表留言，猛击->>这里<<-参与讨论

JavaEye推荐

jquery fx分析

jljlpch — Thu, 28 Aug 2008 19:37:47 +0800

作者: jljlpch 链接：http://jljlpch.javaeye.com/blog/234130 发表时间: 2008年08月28日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

8 FX分析

              prk/彭仁夔            转载请注明出处  http://jljlpch.javaeye.com/
8.1 FX的常用方法
和前面分析的代码相比，FX是非常让人兴奋的。以前javaeye登陆的时候，对其登陆窗口的淡出淡入的特效总是想入非非。Jquery的core包中也提供了Fx的实现。
Fx的实质是连续有序改变dom元素的属性达到视觉上的效果，动态地变化起来。这些属性主要是高度，宽度，透明度和颜色（背景色和前景色）等。连续有序是和时间相关的，也就是先在某个时间点改变一下CSS的样式属性，下一个时间点再改变一下样式属性，达到渐变的过程的效果。

Jquery为我们提供了几种常用的FX的函数。
Slide是滑出的动作，对于slide，jquery提供了slideDown、slideUp、slideToggle三种方法。slideDown是元素向下面渐渐地滑出，最后全部可见。slideUp是元素向上面渐渐地钻进去，最后不见。slideToggle则是这两者之间的转换了。
Fade是淡变的动作。对于Fade，jquery提供了fadeIn、fadeOut两个方法。fadeIn是从无到有渐渐地显示出整个元素。fadeOut相反，它从有到无渐渐地消失这个元素，fade还提供了一个fadeTo用来改变透明性渐变到一个指定的值，而不是消失。
Jquery还提供一组更强大的方法。Show、hide、toggle采用一种更为优美的方式显示元素。Show是元素的宽度渐渐变成，同时高度也渐渐变大，同时透明度也渐渐从无到不透明。这种的效果是元素从一个点渐渐变大，最终完全地显示出来。Hide刚是相反，它是渐渐透明同时宽高逐渐变小，最后消失。Toggle是两者之间的转换。

jQuery.each({
	slideDown: { height:"show" },
	slideUp: { height: "hide" },
	slideToggle: { height: "toggle" },
	fadeIn: { opacity: "show" },
	fadeOut: { opacity: "hide" }
}, function( name, props ){
	jQuery.fn[ name ] = function( speed, callback ){
		return this.animate( props, speed, callback );
	};
});
	// 把所有匹配元素的不透明度以渐进方式调整到指定的不透明度，
//并在动画完成后可选地触发一个回调函数。这个动画只调整元素的不透明度。
	fadeTo: function(speed,to,callback){
		return this.animate({opacity: to}, speed, callback);
	},
Slide和fade是通过分别改变height或opacity来完成效果的。其完成的工作任务在this.animate( props, speed, callback )上。
show
对于show和hide的，它们的效果更好一点，其代码也复杂一点。
// show(speed,[callback])
	// 以优雅的动画隐藏所有匹配的元素，并在显示完成后可选地触发一个回调函数。
    // 可以根据指定的速度动态地改变每个匹配元素的高度、宽度和不透明度。
	// 显示隐藏的匹配元素 show()
show: function(speed,callback){
return speed ?
this.animate({height: "show", width: "show", opacity: "show"
			          }, speed, callback)
 : this.filter(":hidden").each(function(){
	  this.style.display = this.oldblock || "";
		if ( jQuery.css(this,"display") == "none" ) {
		   var elem = jQuery("<" + this.tagName + " />").appendTo("body");
		   this.style.display = elem.css("display");// 默认的显示的display
	     	if (this.style.display == "none")// 显式地设定该tag不显示						this.style.display = "block";
			   	elem.remove();// 上面这些的处理有没有必要呢？
				}
			}).end();// 回到前一个jQuery对象
	},
hide: function(speed,callback){
	 return speed ?
		this.animate({height: "hide", width: "hide", opacity: "hide"
			    }, speed, callback)
 :	this.filter(":visible").each(function(){
			this.oldblock = this.oldblock || jQuery.css(this,"display");
				this.style.display = "none";
			}).end();
	},
toggle: function( fn, fn2 ){
return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
	this._toggle.apply( this, arguments ) :// 原来的toggle
		(fn ?   this.animate({height: "toggle", width: "toggle",
 opacity: "toggle"}, fn, fn2)
	 :  this.each(function(){jQuery(this)[ jQuery(this).is(":hidden") ?
 "show" : "hide" ]();}
			// 对每个元素都调用show,或hide函数。
			)
		);
	},
show和hide的函数如果没有指定speed的参数，它们就直接地show或hide元素。没有动画的效果。如果给定的speed的参数。它能根据这个speed的值动态去改变高度宽度透明度来达到动画的show或hide的效果。Toggle则是这两样的变换。
  prk/彭仁夔            转载请注明出处  http://jljlpch.javaeye.com/

8.2 Fx的核心源码分析
上面的几个常用方式都是调用了this.animate。jquery对象的animate是大包大揽的函数。所有的FX的效果都可以从这里得到。因为FX特效就是通过连续（间隔很小的时间点）去改变元素的CSS的样式。达到视觉上的效果。Animate就是根据指定的参数（如speed,元素的属性的变化范围）来完成这样的功能。
Animate
/**
	 * 用于创建自定义动画的函数。
	 * 这个函数的关键在于指定动画形式及结果样式属性对象。这个对象中每个属性都表示一个可以变化的样式属性（如“height”、“top”或“opacity”）。
	 * 注意：所有指定的属性必须用骆驼形式，比如用marginLeft代替margin-left.
	 * 而每个属性的值表示这个样式属性到多少时动画结束。如果是一个数值，样式属性就会从当前的值渐变到指定的值。如果使用的是“hide”、“show”或“toggle”这样的字符串值，则会为该属性调用默认的动画形式。
	 * 在 jQuery 1.2 中，你可以使用 em 和 % 单位。另外，在 jQuery 1.2 中，你可以通过在属性值前面指定 "+=" 或
	 * "-=" 来让元素做相对运动。
	 * 
	 * params (Options) : 一组包含作为动画属性和终值的样式属性和及其值的集合 。 duration (String,Number)
	 * :(可选) 三种预定速度之一的字符串("slow", "normal", or "fast")或表示动画时长的毫秒数值(如：1000)
	 * easing (String) : (可选) 要使用的擦除效果的名称(需要插件支持).默认jQuery提供"linear" 和 "swing".
	 * callback (Function) : (可选) 在动画完成时执行的函数
	 */
animate: function( prop, speed, easing, callback ) {
	var optall = jQuery.speed(speed, easing, callback); ①
// 执行each或queue方法
return this[ optall.queue === false ? "each" : "queue" ](function(){②	var opt = jQuery.extend({}, optall), p,
	hidden=this.nodeType==1&&jQuery(this).is(":hidden"),//元素节点且隐藏
	self = this;// 当前的元素
	for ( p in prop ) {                                        ③
	  //如果是完成的状态，就直接调用complate函数
	  if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden )		  return opt.complete.call(this);
	 if (( p == "height" || p == "width")&& this.style ){//style高宽度
		opt.display = jQuery.css(this, "display");// 保存当前元素的display
		opt.overflow = this.style.overflow;// 保证没有暗中进行的
		}
	 }
	if ( opt.overflow != null )// 超出部分不见
		this.style.overflow = "hidden";
opt.curAnim = jQuery.extend({}, prop);//clone传入的参数prop
   	jQuery.each( prop, function(name, val){              ④
// 对当前元素的给定的属性进行变化的操作
		var e = new jQuery.fx( self, opt, name );       ⑤
// 传参的属性可以用toggle，show，hide，其它
	  // 调用当前e.show,e.hide,e.val的方法，jQuery.fx.prototype
         if ( /toggle|show|hide/.test(val) )          ⑥
			e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );		else {                                             ⑦
			var parts = al.toString().match(/^([+-]=)?([\d+-.]+)(.*)$/),
			start = e.cur(true) || 0;// 当前元素当前属性的值
            // +=" 或 "-=" 来让元素做相对运动。
			if ( parts ) {                                       ⑧
				var end = parseFloat(parts[2]),	unit = parts[3] || "px";				if ( unit != "px" ) {// 计算开始的值=(end/cur)*start
					self.style[ name ] = (end || 1) + unit;
					start = ((end || 1) / e.cur(true)) * start;
					self.style[ name ] = start + unit;
					}
		    if( parts[1]) end = ((parts[1] == "-="? -1 : 1)* end)+ start;
			e.custom( start, end, unit );// 动画
		 } 
		//直接计算start和end的位置来动画。val是数值的end,start当前的属性值。
		else	e.custom( start, val, "" );// 动画    ⑨
		}
	});
	/ For JS strict compliance
return true;
});	},

Animate通过传入的参数对于jquery对象中的每个元素的每个指示的属性都进行时间上渐变的改变。下面就分析其中的代码。
jQuery.speed
在①是就通过jquery.speed来进行参数的统一整理。
// 主要用于辅助性的工作
speed: function(speed, easing, fn) {
	var opt = speed && speed.constructor == Object ? speed : {	
// coplete是至多三个参数的最后一个。看看是否传入动画完成回调的函数
    complete: fn ||!fn && easing ||jQuery.isFunction( speed ) && speed,
duration: speed,// 持继的时间，动画运行的时间。
//找到动画中属性随时间渐变的的算法。
easing:fn&&easing || easing && easing.constructor != Function && easing
	};
//计算出正确的duration，它支持fast,slow这样已经定义的常量
opt.duration = (opt.duration &&
 (opt.duration.constructor == Number?
opt.duration :
jQuery.fx.speeds[opt.duration]))||jQuery.fx.speeds._default; 
		// Queueing
		opt.old = opt.complete;
//这里是把complete形成了包裹，看看参数中是否指定队列操作，
//如果先出列，再执行complete
opt.complete = function(){
//可能通过参数指定queue，this指向是当前的dom元素。
	if ( opt.queue !== false )	jQuery(this).dequeue();//出queue
	if (jQuery.isFunction( opt.old ))	opt.old.call( this );
	};

return opt;
},
jquery.speed是对参数进行管理的操作函数。它首先看看speed是不是紧缩型的参数如{ complete:xx, easing:xx, duration:xx}。如果不是，就根据传入的参数进行判断，组成紧缩型的对象参数。
   由于jquery对象支持fast,slow这样的常量来代替具体的speed的数值，第二步就是进行speed的处理。如果没有提供就提供默认的speed。其代码在jQuery.fx.speeds中speeds:{	slow: 600,	fast: 200,	_default: 400},定义了三种形式的速度。
接下来是对在完成的时间执行的complete的回调函数进行包裹。包裹就是看看参数中提供了队列的操作没有。提供了就进行出队列的操作。之后再执行complete的回调函数。
jQuery.fn.dequeue = function(type){
	type = type || "fx";
	return this.each(function(){
		var q = queue(this, type);// 得取type的的值
		q.shift();// 移出一个
		if ( q.length )
			q[0].call( this );
	});
};
jQuery.fn.dequeue根据type取到当前dom元素的queue。先移出一个。再运行queue中的第一个。
Queue

  prk/彭仁夔            转载请注明出处  http://jljlpch.javaeye.com/

在②处和上一部分都看看参数中提供了队列的操作没有，有就是进行queue的操作。Queue的操作和each的操作是不一样的。
// 实现队列操作，为jQuery对象中的每个元素都加type的属性，值为fn.
queue: function(type, fn){
	// 可能看出支持一个参数的fn或array形式的集合其type为默认的fx的形式。
	if(jQuery.isFunction(type)||( type && type.constructor == Array)) {
		    	fn = type;	type = "fx";	}
	//没有参数时或一个参数是字符的type时就从jquery对象第一个元素的data中取
    //出相对于的type(空就是所有)的队列中的元素（fn）。
	if ( !type || (typeof type == "string" && !fn) )
		return queue( this[0], type );//从queue取出
//把fn保存在jquery对象中的每个元素的data中的对应的type中去。
//对于fn是fn的数组集合，就直接设定data中type为fn的数组
//如果是单个的fn,那么就采用追加的形式追加到data的type的fn数组中。
//如果追加的形式，而且之前数组中没有fn元素。那么就执行这个元素。
return this.each(function(){
	if ( fn.constructor == Array )// 数组的形式
		 queue(this, type, fn);// 存储在元素的type属性中
	else {
		  queue(this, type).push( fn );
			if ( queue(this, type).length == 1 )	fn.call(this);
			}
		});
	},
分析上面的代码可以看出Queue的操作和each的操作是不太一样的。Each是对每个元素都执行fn函数。而queue对于每个元素都把fn函数放到自已对应的cache中fx的属性中保存，是单个的fn的话，也立马运行。在②处和each的作用差不多。
在上面的代码，它还调用了queue(this, type, fn);来实现把把fn存到this元素的data中的对应的type中去。
// 为元素加上type的array的属性，或返回取到elem上type的值
var queue = function( elem, type, array ) {
	if ( elem ){
		type = type || "fx";
		var q = jQuery.data( elem, type + "queue" );
		if ( !q || array )
			q = jQuery.data( elem, type + "queue", jQuery.makeArray(array) );
	}
	return q;
};
这个全局的函数就是在jQuery.data进一步封装，使它支持默认的fx type和array的类数组的参数。
Jquery这里的Queue实质上没有起到什么作用。它本来可以支持一个元素的的连续执行几个Queue的函数达到更丰富的动画的效果。估计这里是没有完成。
①②③④⑤⑥⑦⑧⑨⑩
jQuery.fx
⑤处animate为dom元素的每个指定的属性都生成了一个fx对象。
// 根据参数构成一个对象
	fx: function( elem, options, prop ){
		this.options = options;
		this.elem = elem;
		this.prop = prop;

		if ( !options.orig )
			options.orig = {};
	}
Fx函数是一个构建函数，仅仅是把参数变成本对象的属性。以便于fx对象的其它方法来使用这些参数。在⑥处就是通过调用fx的方法show或hidden来完成一个属性的逐渐的改变。在⑨是通过custom方法来直接进行一个动画。
先看一下show或hidden：
show: function(){
// 保存当前的，以被修改之后能得到初始的值
this.options.orig[this.prop]=jQuery.attr(this.elem.style,this.prop);
this.options.show = true;//标明是进行show操作
this.custom(0, this.cur());
//让最开始时以1px的宽或高度来显示。防止内容flash
if ( this.prop == "width" || this.prop == "height" )
		this.elem.style[this.prop] = "1px";		
jQuery(this.elem).show();
	},
hide: function(){
// 保存当前的，以被修改之后能得到初始的值
this.options.orig[this.prop]=jQuery.attr(this.elem.style,this.prop);
this.options.hide = true;//标识是进行hide操作
this.custom(this.cur(), 0);	},
show和hide是在指定元素的属性为show或hide的时候调用的，如height: "show", width: "show", opacity: "show"。它们都是先保存原始的改悔。之后调用custom来完成动画。和⑨处是一样的。
也就是说完成动画的工作在custom中：
// 开动一个动画
	custom: function(from, to, unit){
		this.startTime = now();//动画开始的时候
		this.start = from;//位置开始点
		this.end = to;//位置结果点
		this.unit = unit || this.unit || "px";
		this.now = this.start;//位置当前点
		//state是时间间隔在总的duration的比率
		//pos是按一定算法把时间上的比率折算到位置上的比率
		this.pos = this.state = 0;
		//根据this.now位置当前点的值来设定元素的属性显示出来
		this.update();

		var self = this;
		function t(gotoEnd){
			return self.step(gotoEnd);// 调用step(gotoEnd)//本对象的
		}
		t.elem = this.elem;//删除的时候做判断用
		//timers栈是公共的，不同的元素的不同的属性step都是放在这里面。
		jQuery.timers.push(t);
         
		if ( jQuery.timerId == null ) {
			jQuery.timerId = setInterval(function(){
				var timers = jQuery.timers;
			//倒是觉得这里会有同步冲突的问题。Ext.observable中就有解决方法
				for ( var i = 0; i < timers.length; i++ ) 
				//当一个属性的动画完成，或强迫完成的时候，把step从数组中删除.
				//同时把i的位置不改变。继续下一个。
				if ( !timers[i]() )	timers.splice(i--, 1);		               
				  //说明还有属性的动画没有完成，step还在timers中。
				  //那么就不clearInterval，13ms之后再继续。直到数组
				  //中所有的step都被删除。
				if ( !timers.length ) {
					clearInterval( jQuery.timerId );
					jQuery.timerId = null;
				}
			}, 13);
		}
	},
在custom中为fx对象动态地追加了几个属性。Start和end属性指的属性值变化的开始和结束位置。这是属性值发生变化的范围。Now是在Start和end 范围的某一个点，也就是当前要比属性设定值。这个值是根据时间的间隔比率再通过一定的算法来得出的。pos 和state一个是位置上的比率，一个是时间上比率，值在0~1之间。
Custom通过this.now = this.start;和this.update();来设起始位置的样式属性。
// 为元素设值，更新显示
	update: function(){
		//可以在显示之前进行自定义的显示操作
		//这里可以是改变this.now或元素的其它属性。
		//改变this.now是改变动画的轨迹，改变其它的属性会有更多的效果
		if ( this.options.step )
			this.options.step.call( this.elem, this.now, this );
         //根据this.now来改变/设值当前属性的值。也就改变了样式。
		(jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );

		// 对于高度和宽度，肯定是要能看出效果的，故采用display=block。
		if ( ( this.prop == "height" || this.prop == "width" ) 
&& this.elem.style )
			this.elem.style.display = "block";
	},

  prk/彭仁夔            转载请注明出处  http://jljlpch.javaeye.com/

通过udate设定起始位置的样式属性之后，custom第二步就是采用setInterval
每隔13ms就执行一次当前的fx对象的step方法。该方法实现了动画结束的扫尾工作和动画过程中按一定的算法来计算this.now的值。因为这个值的改变，之后调用update就可以改变样式的属性。
这样一来，就实现了元素的某个属性的渐变过程。
// 动画的每一个步骤
	step: function(gotoEnd){
		var t = now();//运行到当前的时间，因为是13ms才运行一次。
         // 强行指定结束或当前时间大于startTime+duration
		if ( gotoEnd || t > this.options.duration + this.startTime ) {
			this.now = this.end;//当前的位置为结束位置
			this.pos = this.state = 1;//当前的state,pos的比率为1.最大。
			this.update();//显示
            //标识这个属性的动画已经完成
			this.options.curAnim[ this.prop ] = true;
            //再一次判断是否完成
			var done = true;
			for ( var i in this.options.curAnim )
				if ( this.options.curAnim[i] !== true )
					done = false;

			if ( done ) {				
				if ( this.options.display != null ) {//  恢复overflow
					this.elem.style.overflow = this.options.overflow;
					// 恢复 display
					this.elem.style.display = this.options.display;
					//判断其是否恢复成功，
					if ( jQuery.css(this.elem, "display") == "none" )
						this.elem.style.display = "block";
				}

				//如果是hide的操作
				if ( this.options.hide )
					this.elem.style.display = "none";
				
					//如果元素已经show或hide,恢复其动画改变的属性
				if ( this.options.hide || this.options.show )
					for ( var p in this.options.curAnim )
						jQuery.attr(this.elem.style, p, 
this.options.orig[p]);
			}

			if ( done )// 运行complete的回调函数
				this.options.complete.call( this.elem );

			return false;
		} else {
			var n = t - this.startTime;//时间间隔
			this.state = n / this.options.duration;//时间间隔比率

			//根据时间间隔的比率再按一定的算法比率来计算
//当前的运动的位置点的比率。默认是swing的算法
			this.pos = jQuery.easing[this.options.easing || 
			(jQuery.easing.swing ? "swing" : "linear")]
(this.state, n, 0, 1, this.options.duration);
		    //当前的位置
			this.now = this.start + ((this.end - this.start) * this.pos);

			// 显示
			this.update();
		}

		return true;
	}
Step中第一部分是完成时的扫尾工作，恢复动画时改变的属性和运行complete的回调函数。第二部分就是计算this.now的值之后显示出来。目前jquery提供了两种算法来计算从时间间隔比率转换成位置上的比率。
	easing: {
		linear: function( p, n, firstNum, diff ) {
			return firstNum + diff * p;
		},
		swing: function( p, n, firstNum, diff ) {
			return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
		}
	},
这就是它的算法。对于linear的形式，Jquery采用了1:1的关系来计算的。
Stop
  一个动画，有的时间可能会出现在没有运行完成就中断。Stop就是对这个进行操作的。
stop: function(clearQueue, gotoEnd){
	var timers = jQuery.timers;
	if (clearQueue)	this.queue([]);// 清除
		this.each(function(){
		//倒序是为了能把在loop过程加入timers的当前元素的属性的动画step也给删除。
			for ( var i = timers.length - 1; i >= 0; i-- )
				if ( timers[i].elem == this ) {
					if (gotoEnd) timers[i](true); // 强迫动画结束	
					 timers.splice(i, 1);
				}
		});
		// start the next in the queue if the last step wasn't forced
		if (!gotoEnd)		this.dequeue();

		return this;
	}
在stop中，我们可以看出step（force）中的参数的作用。这个强迫动画到最后一步，即动画结束进行扫尾工作。这里的jQuery.timers是公共的集合。在custom中的setInterval就是对它进行操作的。

已有 0 人发表留言，猛击->>这里<<-参与讨论

JavaEye推荐

jqueyr fx源码（修改）

jljlpch — Thu, 28 Aug 2008 19:33:47 +0800

作者: jljlpch 链接：http://jljlpch.javaeye.com/blog/234128 发表时间: 2008年08月28日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

/*
 * author：prk date:2008-08-07 comment:analyse the fx of jQuery.
 * 
 */
jQuery.fn.extend({
	
	// show(speed,[callback])
	// 以优雅的动画隐藏所有匹配的元素，并在显示完成后可选地触发一个回调函数。
    // 可以根据指定的速度动态地改变每个匹配元素的高度、宽度和不透明度。
	// 显示隐藏的匹配元素 show()
	show: function(speed,callback){
		return speed ?
			this.animate({
				height: "show", width: "show", opacity: "show"
			}, speed, callback) :

			this.filter(":hidden").each(function(){
				this.style.display = this.oldblock || "";
				if ( jQuery.css(this,"display") == "none" ) {
					var elem = jQuery("<" + this.tagName + " />").appendTo("body");
					this.style.display = elem.css("display");// 默认的显示的display
					// handle an edge condition where css is - div {
					// display:none; } or similar
					if (this.style.display == "none")// 处理显式地设定了该tag不显示，只好采用b
						this.style.display = "block";
					elem.remove();// 上面这些的处理有没有必要呢？
				}
			}).end();// 回到前一个jQuery对象
	},
	
    // 与show相反
	hide: function(speed,callback){
		return speed ?
			this.animate({
				height: "hide", width: "hide", opacity: "hide"
			}, speed, callback) :

			this.filter(":visible").each(function(){
				this.oldblock = this.oldblock || jQuery.css(this,"display");
				this.style.display = "none";
			}).end();
	},

	// Save the old toggle function
	_toggle: jQuery.fn.toggle,
      /*  prk/彭仁夔            转载请注明出处 http://jljlpch.javaeye.com/*/

	// 切换元素的可见状态。
    // 如果元素是可见的，切换为隐藏的；如果元素是隐藏的，切换为可见的。
	
	// 每次点击后依次调用函数。
    // 如果点击了一个匹配的元素，则触发指定的第一个函数，当再次点击同一元素时，则触发指定的第二个函数，
    // 如果有更多函数，则再次触发，直到最后一个。随后的每次点击都重复对这几个函数的轮番调用。
    // 可以使用unbind("click")来删除。
	toggle: function( fn, fn2 ){
		return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
			this._toggle.apply( this, arguments ) :// 原来的toggle
			(fn ?
			   this.animate({height: "toggle", width: "toggle", opacity: "toggle"}, fn, fn2)
			:  this.each(function(){jQuery(this)[ jQuery(this).is(":hidden") ? "show" : "hide" ]();}
			// 对每个元素都调用show,或hide函数。
			)
		);
	},

	// 把所有匹配元素的不透明度以渐进方式调整到指定的不透明度，并在动画完成后可选地触发一个回调函数。
     // 这个动画只调整元素的不透明度，也就是说所有匹配的元素的高度和宽度不会发生变化。
	fadeTo: function(speed,to,callback){
		return this.animate({opacity: to}, speed, callback);
	},
	
	/**
	 * 用于创建自定义动画的函数。
	 * 这个函数的关键在于指定动画形式及结果样式属性对象。这个对象中每个属性都表示一个可以变化的样式属性（如“height”、“top”或“opacity”）。
	 * 注意：所有指定的属性必须用骆驼形式，比如用marginLeft代替margin-left.
	 * 而每个属性的值表示这个样式属性到多少时动画结束。如果是一个数值，样式属性就会从当前的值渐变到指定的值。如果使用的是“hide”、“show”或“toggle”这样的字符串值，则会为该属性调用默认的动画形式。
	 * 在 jQuery 1.2 中，你可以使用 em 和 % 单位。另外，在 jQuery 1.2 中，你可以通过在属性值前面指定 "+=" 或
	 * "-=" 来让元素做相对运动。
	 * 
	 * params (Options) : 一组包含作为动画属性和终值的样式属性和及其值的集合 。 duration (String,Number)
	 * :(可选) 三种预定速度之一的字符串("slow", "normal", or "fast")或表示动画时长的毫秒数值(如：1000)
	 * easing (String) : (可选) 要使用的擦除效果的名称(需要插件支持).默认jQuery提供"linear" 和 "swing".
	 * callback (Function) : (可选) 在动画完成时执行的函数
	 */
	animate: function( prop, speed, easing, callback ) {
		var optall = jQuery.speed(speed, easing, callback);

		return this[ optall.queue === false ? "each" : "queue" ](function(){// 执行each或queue方法
			var opt = jQuery.extend({}, optall), p,
				hidden = this.nodeType == 1 && jQuery(this).is(":hidden"),// 是元素节点且是隐藏的
				self = this;// 当前的元素
	
			for ( p in prop ) {
				//如果是完成的状态，就直接调用complate函数
				if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden )// 已经是
					return opt.complete.call(this);//，在用户的callback加上队列的处理

				if ( ( p == "height" || p == "width" ) && this.style ) {// style中高度，宽度
					opt.display = jQuery.css(this, "display");// 保存当前元素的display
					opt.overflow = this.style.overflow;// 保证没有暗中进行的
				}
			}
			if ( opt.overflow != null )// 超出部分不见
				this.style.overflow = "hidden";

			opt.curAnim = jQuery.extend({}, prop);//clone传入的参数prop
   
			jQuery.each( prop, function(name, val){// 对当前元素的给定的属性进行变化的操作
				var e = new jQuery.fx( self, opt, name );
                
				if ( /toggle|show|hide/.test(val) )// 传参的属性可以用toggle，show，hide，其它
				// 调用当前e.show,e.hide,e.val的方法，jQuery.fx.prototype
					e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );					
				else {// 支持"+=" 或 "-=" 来让元素做相对运动。
					var parts = val.toString().match(/^([+-]=)?([\d+-.]+)(.*)$/),
						start = e.cur(true) || 0;// 当前元素当前属性的值
                      // +=" 或 "-=" 来让元素做相对运动。
					if ( parts ) {
						var end = parseFloat(parts[2]),// 值
							unit = parts[3] || "px";// 单位
						
						if ( unit != "px" ) {// 计算开始的值=(end/cur)*start
							self.style[ name ] = (end || 1) + unit;
							start = ((end || 1) / e.cur(true)) * start;
							self.style[ name ] = start + unit;
						}

						if ( parts[1] )// +=/-=,做相对运行
							end = ((parts[1] == "-=" ? -1 : 1) * end) + start;

						e.custom( start, end, unit );// 动画
					} 
					//直接计算start和end的位置来动画。val是数值的end,start当前的属性值。
					else
						e.custom( start, val, "" );// 动画
				}
			});
			// For JS strict compliance
			return true;
		});
	},

	// 实现队列操作，为jQuery对象中的每个元素都加type的属性，值为fn.
	queue: function(type, fn){
		// 可能看出支持一个参数的fn或array形式的集合其type为默认的fx的形式。
		if ( jQuery.isFunction(type) || ( type && type.constructor == Array )) {
			fn = type;
			type = "fx";
		}
		// type不存在,空字符等，无参数，type:string,fn不存在。肯定不是函数，也不是数组
		if ( !type || (typeof type == "string" && !fn) )
			return queue( this[0], type );//从queue取出

		return this.each(function(){
			//fn是数组的形式fn集合，直接构建queue
			if ( fn.constructor == Array )// 数组的形式
				queue(this, type, fn);// 存储在元素的type属性中
			  //取得queue,后push，只有一个立即运行。
			else {
				queue(this, type).push( fn );
				if ( queue(this, type).length == 1 )
					fn.call(this);
			}
		});
	},

	stop: function(clearQueue, gotoEnd){
		var timers = jQuery.timers;

		if (clearQueue)
			this.queue([]);// 清除

		this.each(function(){
			//倒序是为了能把在loop过程加入timers的当前元素的属性的动画step也给删除。
			for ( var i = timers.length - 1; i >= 0; i-- )
				if ( timers[i].elem == this ) {
					if (gotoEnd) timers[i](true);
						// 强迫动画结束						
					timers.splice(i, 1);
				}
		});
		// start the next in the queue if the last step wasn't forced
		if (!gotoEnd)
			this.dequeue();

		return this;
	}

});

// Generate shortcuts for custom animations
jQuery.each({
	slideDown: { height:"show" },
	slideUp: { height: "hide" },
	slideToggle: { height: "toggle" },
	fadeIn: { opacity: "show" },
	fadeOut: { opacity: "hide" }
}, function( name, props ){
	jQuery.fn[ name ] = function( speed, callback ){
		return this.animate( props, speed, callback );
	};
});

// 为元素加上type的array的属性，或返回取到elem上type的值
var queue = function( elem, type, array ) {
	if ( elem ){
		type = type || "fx";
		var q = jQuery.data( elem, type + "queue" );
		if ( !q || array )
			q = jQuery.data( elem, type + "queue", jQuery.makeArray(array) );
	}
	return q;
};
// 出列，根据type
jQuery.fn.dequeue = function(type){
	type = type || "fx";
	return this.each(function(){
		var q = queue(this, type);// 得取type的的值
		q.shift();// 移出一个
		if ( q.length )
			q[0].call( this );
	});
};


jQuery.extend({
     // 主要用于辅助性的工作
	speed: function(speed, easing, fn) {
		var opt = speed && speed.constructor == Object ? speed : {// 采用紧凑型方式
			complete: fn || !fn && easing ||
				jQuery.isFunction( speed ) && speed,// coplete是至多三个参数的最后一个，当然是Fn.
			duration: speed,// 持继的时间
			easing: fn && easing || easing && easing.constructor != Function && easing// 不是Fn
		};

		opt.duration = (opt.duration && (opt.duration.constructor == Number ?
			opt.duration :	jQuery.fx.speeds[opt.duration])) // 存在，不是数值，转找
			|| jQuery.fx.speeds._default;// 默认的

		// Queueing
		opt.old = opt.complete;
		opt.complete = function(){// 排队的处理
			if ( opt.queue !== false )//可能通过参数指定queue
				jQuery(this).dequeue();//出queue
			if ( jQuery.isFunction( opt.old ) )
				opt.old.call( this );//执行完成之后的回调
		};

		return opt;
	},

	// 擦除效果
	easing: {
		linear: function( p, n, firstNum, diff ) {
			return firstNum + diff * p;
		},
		swing: function( p, n, firstNum, diff ) {
			return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
		}
	},

	timers: [],// jQuery.timers
	timerId: null,
    
	// 根据参数构成一个对象
	fx: function( elem, options, prop ){
		this.options = options;
		this.elem = elem;
		this.prop = prop;

		if ( !options.orig )
			options.orig = {};
	}

});

jQuery.fx.prototype = {

	// 为元素设值，更新显示
	update: function(){
		//可以在显示之前进行自定义的显示操作
		//这里可以是改变this.now或元素的其它属性。
		//改变this.now是改变动画的轨迹，改变其它的属性会有更多的效果
		if ( this.options.step )
			this.options.step.call( this.elem, this.now, this );
         //根据this.now来改变/设值当前属性的值。也就改变了样式。
		(jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );

		// 对于高度和宽度，肯定是要能看出效果的，故采用display=block。
		if ( ( this.prop == "height" || this.prop == "width" ) && this.elem.style )
			this.elem.style.display = "block";
	},

	// 当前元素当前属性的值
	cur: function(force){
		if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) )
			return this.elem[ this.prop ];

		var r = parseFloat(jQuery.css(this.elem, this.prop, force));
		return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
	},

	// 开动一个动画
	custom: function(from, to, unit){
		this.startTime = now();//动画开始的时候
		this.start = from;//位置开始点
		this.end = to;//位置结果点
		this.unit = unit || this.unit || "px";
		this.now = this.start;//位置当前点
		//state是时间间隔在总的duration的比率
		//pos是按一定算法把时间上的比率折算到位置上的比率
		this.pos = this.state = 0;
		//根据this.now位置当前点的值来设定元素的属性显示出来
		this.update();

		var self = this;
		function t(gotoEnd){
			return self.step(gotoEnd);// 调用step(gotoEnd)//本对象的
		}
		t.elem = this.elem;//删除的时候做判断用
		//timers栈是公共的，不同的元素的不同的属性step都是放在这里面。
		jQuery.timers.push(t);
         
		if ( jQuery.timerId == null ) {
			jQuery.timerId = setInterval(function(){
				var timers = jQuery.timers;
				//倒是觉得这里会有同步冲突的问题。Ext.observable中就有解决方法
				for ( var i = 0; i < timers.length; i++ )// 执行timers中所有
				  
				//当一个属性的动画完成，或强迫完成的时候，把step从数组中删除.
				//同时把i的位置不改变。继续下一个。
				if ( !timers[i]() )					
						timers.splice(i--, 1);						
                  
				  //说明还有属性的动画没有完成，step还在timers中。
				  //那么就不clearInterval，13ms之后再继续。直到数组
				  //中所有的step都被删除。
				if ( !timers.length ) {
					clearInterval( jQuery.timerId );
					jQuery.timerId = null;
				}
			}, 13);
		}
	},

	// Simple 'show' function
	show: function(){
		// 保存当前的，以被修改之后能得到初始的值
		this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
		this.options.show = true;//标明是进行show操作
		
		this.custom(0, this.cur());
		
		//让最开始时以1px的宽或高度来显示。防止内容flash
		if ( this.prop == "width" || this.prop == "height" )
			this.elem.style[this.prop] = "1px";		
		jQuery(this.elem).show();
	},

	// 隐藏
	hide: function(){
		// 保存当前的，以被修改之后能得到初始的值
		this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
		this.options.hide = true;//标识是进行hide操作
		
		this.custom(this.cur(), 0);
	},

	// 动画的每一个步骤
	step: function(gotoEnd){
		var t = now();//运行到当前的时间，因为是13ms才运行一次。
         // 强行指定结束或当前时间大于startTime+duration
		if ( gotoEnd || t > this.options.duration + this.startTime ) {
			this.now = this.end;//当前的位置为结束位置
			this.pos = this.state = 1;//当前的state,pos的比率为1.最大。
			this.update();//显示
            //标识这个属性的动画已经完成
			this.options.curAnim[ this.prop ] = true;
            //再一次判断是否完成
			var done = true;
			for ( var i in this.options.curAnim )
				if ( this.options.curAnim[i] !== true )
					done = false;

			if ( done ) {				
				if ( this.options.display != null ) {//  恢复overflow
					this.elem.style.overflow = this.options.overflow;
					// 恢复 display
					this.elem.style.display = this.options.display;
					//判断其是否恢复成功，
					if ( jQuery.css(this.elem, "display") == "none" )
						this.elem.style.display = "block";
				}

				//如果是hide的操作
				if ( this.options.hide )
					this.elem.style.display = "none";
				
					//如果元素已经show或hide,恢复其动画改变的属性
				if ( this.options.hide || this.options.show )
					for ( var p in this.options.curAnim )
						jQuery.attr(this.elem.style, p, this.options.orig[p]);
			}

			if ( done )// 运行complete的回调函数
				this.options.complete.call( this.elem );

			return false;
		} else {
			var n = t - this.startTime;//时间间隔
			this.state = n / this.options.duration;//时间间隔比率

			//根据时间间隔的比率再按一定的算法比率来计算当前的运动的位置点的比率。默认是swing的算法
			this.pos = jQuery.easing[this.options.easing || 
			(jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
		    //当前的位置
			this.now = this.start + ((this.end - this.start) * this.pos);

			// 显示
			this.update();
		}

		return true;
	}

};

jQuery.extend( jQuery.fx, {
	// 动画的速度
	speeds:{
		slow: 600,
 		fast: 200,
 		// Default speed
 		_default: 400
	},
	
	// 为元素设值
	step: {
		opacity: function(fx){// 为元素CSS设opacity为fx
			jQuery.attr(fx.elem.style, "opacity", fx.now);
		},

		_default: function(fx){
			if( fx.prop in fx.elem ) // 对于元素
				fx.elem[ fx.prop ] = fx.now;
			else if( fx.elem.style )// 对于style
				fx.elem.style[ fx.prop ] = fx.now + fx.unit;
		}
	}
});

已有 0 人发表留言，猛击->>这里<<-参与讨论

JavaEye推荐

jquery.ajax

jljlpch — Wed, 27 Aug 2008 16:50:49 +0800

作者: jljlpch 链接：http://jljlpch.javaeye.com/blog/233252 发表时间: 2008年08月27日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

7.2 jquery.ajax

                prk/彭仁夔  08-08-27
这所有的最终都是通过jQuery.ajax()来完成的。
ajax : function(s) {
	//两次继承s,以便在测试中能检测
	s = jQuery.extend(true, s, jQuery.extend(true, {}, 
jQuery.ajaxSettings,	s));         ①
	var jsonp, jsre = /=\?(&|$)/g, status, data,
 type = s.type	.toUpperCase();
// 如果不是字符集串就转换在查询字符集串
if (s.data && s.processData && typeof s.data != "string")
		s.data = jQuery.param(s.data);

// 构建jsonp请求字符集串。jsonp是跨域请求，要加上callback=？后面将会加函数名
if (s.dataType == "jsonp") {                               ②
if (type == "GET") {//使get的url包含 callback=？后面将会进行加函数名
		if (!s.url.match(jsre))
			s.url += (s.url.match(/\?/) ? "&" : "?")
							+ (s.jsonp || "callback") + "=?";
			} // 构建新的s.data，使其包含callback=function name
else if (!s.data || !s.data.match(jsre))
		s.data = (s.data ? s.data + "&" : "") + (s.jsonp||"callback")+ "=?";
s.dataType = "json";
}		
//判断是否为jsonp,如果是，进行处理。
if (s.dataType == "json"  
			&& (s.data && s.data.match(jsre) || s.url.match(jsre))) {③
	 jsonp = "jsonp" + jsc++;
/ /为请求字符集串的callback=加上生成回调函数名
	if (s.data)s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
	s.url = s.url.replace(jsre, "=" + jsonp + "$1");

			// 我们需要保证jsonp 类型响应能正确地执行
	//jsonp的类型必须为script。这样才能执行服务器返回的
	//代码。这里就是调用这个回调函数。
	s.dataType = "script";
//window下注册一个jsonp回调函数有，让ajax请求返回的代码调用执行它，
	//在服务器端我们生成的代码 如callbackname(data);形式传入data.
	window[jsonp] = function(tmp) {
		data = tmp;success();complete();
	// 垃圾回收,释放联变量，删除jsonp的对象，除去head中加的script元素
	   window[jsonp] = undefined;
		try {	delete window[jsonp];
			} catch (e) {	}
		if (head)	head.removeChild(script);
		};
	}

if (s.dataType == "script" && s.cache == null)	s.cache = false;
// 加上时间戳，可见加cache:false就会加上时间戳
if (s.cache === false && type == "GET") {
	var ts = now();
	var ret = s.url.replace(/(\?|&)_=.*?(&|$)/, "$1_=" + ts + "$2");
	// 没有代替，就追加在url的尾部
	s.url = ret+ ((ret == s.url) ? (s.url.match(/\?/) ? "&" : "?") + "_="
						+ ts : "");
	}
// data有效，追加到get类型的url上去
if (s.data && type == "GET") {
		s.url += (s.url.match(/\?/) ? "&" : "?") + s.data;
		// 防止IE会重复发送get和post data
		s.data = null;
		}
// 监听一个新的请求
if (s.global && !jQuery.active++) jQuery.event.trigger("ajaxStart");④
// 监听一个绝对的url,和保存domain
var parts = /^(\w+:)?\/\/([^\/?#]+)/.exec(s.url);
// 如果我们正在请求一个远程文档和正在load json或script通过get类型
//location是window的属性，通过和地址栏中的地址比较判断是不是跨域。
if (s.dataType == "script"	&& type == "GET"&& parts	&& (parts[1] && 
parts[1] != location.protocol || parts[2] != location.host)) {⑤
		// 在head中加上
		var head = document.getElementsByTagName("head")[0];
		var script = document.createElement("script");
		script.src = s.url;
		if (s.scriptCharset)	script.charset = s.scriptCharset;
		//如果datatype不是jsonp，但是url却是跨域的。采用scriptr的
		//onload或onreadystatechange事件来触发回调函数。
	   if (!jsonp) {
			var done = false;
			// 对所有浏览器都加上处理器
			script.onload = script.onreadystatechange = function() {
			if (!done&& (!this.readyState || this.readyState == "loaded" 
|| this.readyState == "complete")) {
					done = true;	success();
					complete();head.removeChild(script);
				}
		};
	}
	head.appendChild(script);
// 已经使用了script 元素注射来处理所有的事情
	return undefined;
}
var requestDone = false;
// 创建request,IE7不能通过XMLHttpRequest来完成，只能通过ActiveXObject
var xhr = window.ActiveXObject                               ⑥
		? new ActiveXObject("Microsoft.XMLHTTP"): new XMLHttpRequest();
// 创建一个请求的连接，在opera中如果用户名为null会弹出login窗口中。
if (s.username)xhr.open(type, s.url, s.async, s.username, s.password);
else	xhr.open(type, s.url, s.async);
// try/catch是为防止FF3在跨域请求时报错
try {// 设定Content-Type                                              ⑦
	if (s.data)
		xhr.setRequestHeader("Content-Type", s.contentType);
		// 设定If-Modified-Since
	if (s.ifModified)
		xhr.setRequestHeader("If-Modified-Since",
			jQuery.lastModified[s.url]|| "Thu, 01 Jan 1970 00:00:00 GMT");
// 这里是为了让服务器能判断这个请求是XMLHttpRequest
	xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
// 设定 Accepts header 。指能接收的content-type，在服务器端设定
	xhr.setRequestHeader("Accept", s.dataType && s.accepts[s.dataType]
			? s.accepts[s.dataType] + ", */*": s.accepts._default);
} catch (e) {}
//拦截方法，我们可以在send之前进行拦截。返回false就不send
if (s.beforeSend && s.beforeSend(xhr, s) === false) {         ⑧
	// 清除active 请求计数
	s.global && jQuery.active--;
	xhr.abort();
	return false;
}

// 触发全局的ajaxSend事件
if (s.global)	jQuery.event.trigger("ajaxSend", [xhr, s]);
// 等待response返回，主要是为后面setInterval用。
var onreadystatechange = function(isTimeout) {           ⑨
// 接收成功或请求超时
if (!requestDone && xhr&& (xhr.readyState == 4 ||isTimeout == "timeout")) {	requestDone = true;
		 //清除定时器
		if (ival) {clearInterval(ival);		ival = null;	}
	// 分析status:tiemout-->error-->notmodified-->success
	status = isTimeout == "timeout" ? "timeout" : !jQuery
		ttpSuccess(xhr) ? "error" : s.ifModified&& jQuery.
httpNotModified(xhr, s.url)	? "notmodified": "success";
    	//如果success且返回了数据，那么分析这些数据
	if (status == "success") {					
		try {	data = jQuery.httpData(xhr, s.dataType, s);
			 } catch (e) {	status = "parsererror";	}
	}
// 分析数据成功之后,进行last-modified和success的处理。				
	if (status == "success") {
		var modRes;
		  try {modRes = xhr.getResponseHeader("Last-Modified");
			} catch (e) {	//FF中如果head取不到，会抛出异常} 
		 //保存last-mordified的标识。
		if (s.ifModified && modRes)jQuery.lastModified[s.url] = modRes;
	   // JSONP 有自己的callback
	    if (!jsonp) success();
	} else	// 失败时的处理
	jQuery.handleError(s, xhr, status);
// 无论如何都进行cpmplate.timeout和接收成功
	complete();
if (s.async)	xhr = null; // 防内存泄漏
}
};
if (s.async) {
// 这里是采用poll的方式，不是push的方式
//这里为什么不采用onreadystatechange？
var ival = setInterval(onreadystatechange, 13);
//如果过了timeout还没有请求到，会中断请求的。
	if (s.timeout > 0)
		setTimeout(function() {					
			if (xhr) {	xhr.abort();
				if (!requestDone)	onreadystatechange("timeout");	}
		}, s.timeout);
	}
// 发送
try {xhr.send(s.data); catch(e){jQuery.handleError(s,xhr,null,e);} ⑩
// firefox 1.5 doesn't fire statechange for sync requests
if (!s.async)	onreadystatechange();
function success() {
	// 调用构建请求对象时指定的success回调。
	if (s.success)	s.success(data, status);
	// 执行全局的回调
	if (s.global)	jQuery.event.trigger("ajaxSuccess", [xhr, s]);
	}
function complete() {
	// 本地的回调
	if (s.complete)	s.complete(xhr, status);
	// 执行全局的回调
	if (s.global)	jQuery.event.trigger("ajaxComplete", [xhr, s]);
	// 全局的ajax计数器
	if (s.global && !--jQuery.active)jQuery.event.trigger("ajaxStop");
	}
// return XMLHttpRequest便进行about()或其它操作.
return xhr;
},
Jquery.ajax是大包大揽的非常复杂的一个方法。它并没有像其它的lib一样，把每个小部分都分开来。它是整个都整在一个函数中。看起来很多，实际上上也没有脱离前面所说的ajax的请求的五步。它的很大一部分代码在处理跨域请求的处理上。下面就分别就ajax的代码进行分析。
ajaxSettings
在①处通过继承的方式把传入参数s和默认的jQuery.ajaxSettings都clone到s变量中。S的同名属性会覆盖jQuery.ajaxSettings的同名属性。这里两次继承s,以便在测试中能检测。
//默认的ajax的请求参数
	ajaxSettings : {
		url : location.href,//默认是地址栏中url
		global : true,//默认支持全局的ajax事件
		type : "GET",
		timeout : 0,
		contentType : "application/x-www-form-urlencoded",	
	 processData : true,
		async : true,
		data : null,
		username : null,
		password : null,
		accepts : {
			xml : "application/xml, text/xml",
			html : "text/html",
			script : "text/javascript, application/javascript",
			json : "application/json, text/javascript",
			text : "text/plain",
			_default : "*/*"
		}
这是默认的ajax的设定，我们要在参数s设定同名的属性来覆盖这些属性。但是我们不能覆盖accepts。这个会在后面的代码用到。我们可以通过设定s.dataType等于accepts中的某一个属性key指定请求的data类型，如xml,html,script,json,text。dataType还支持默认的_default和跨域的jsonp。不过其最终会解析成script。
scriptTag
②~⑥是处理跨域请求的部分。对于dataType为jsonp的类型，给其请求的字符串（可能是s.data）加上callback=callbackfn的key/value串，然后在window下注册一个callbackfn的函数。这个函数的形式如callbackfn(data){ data = tmp;success();complete();}。它代理了通过ajax(s)的传入s参数中success();complete()的功能。它就是调用这个函数，实际上是调用success();complete()的函数。
那么怎么调用呢？ajax不支持跨域。在⑤处，我们可以看到这里是采用scriptTag的方式来完成。先在页面的中添加一个