本课将通过源码分析的形式，来教大家如何实现一个动画引擎的模块。
我们先来看一个使用CSS3实现动画倒带的例子：
.animate { //这个animate类名加在上面的那个方块元素中，这个类名也可以是其他名字，比如:.move，只要设置的是那个方块元素就OK了。
animation-duration:3s;
animation-name:cycle;
animation-iteration-count:2; //动画播放的次数
animation-direction: alternate; //是否应该轮流反向播放动画。如果 animation-direction 值是 "alternate"，则动画会在奇数次数（1、3、5 等等）正常播放，而在偶数次数（2、4、6 等等）向后播放。注释：如果把动画设置为只播放一次，则该属性没有效果。
}
@keyframes cycle { //设置这个动画的初始位置和目的位置
from{ 100px;height:100px; }
to{ 700px; height: 700px; }
}
此动画先放大，然后再缩回原状。
接下来，我们真正的进入到js实现动画引擎的代码分析：
下面的实现原理：我们搞一个中央队列，其实就是一个数组timeline，只要它里面有元素（动画对象），它就驱动setInterval执行动画，如果动画执行结束，它就会从数组中删除这个动画对象，然后再检测此数组中还有没有元素，没有，就clearInterval，否则，就继续。这种实现原理在YUI，kissy框中使用，而jQuery的实现原理不是这样的，jQuery提供一个queue的参数，目的让作用于同一个元素的动画进行排队，执行完这个后再处理下一个，jQuery的queue是放在元素对应的缓存系统上的，里面有一个Promise对象，Promise对象的状态完成后，就会自动弹出下一个动画对象，所有的动画对象都有自己的setInterval驱动。
$.fn.animate = $.fn.fx = function(props){ //props为元素的样式属性集合，也叫做关键帧，animate方法就是用来添加关键帧的。
var opts = addOptions.apply(null, arguments) , p; //opts就是设置动画的所需时长，缓动公式，结束时执行的回调函数，以及before，after函数的
for(var name in props){ //如果第一个参数不是数字，而是一个对象
p = $.cssName(name) || name; //把样式属性名进行转换
if(name !==p){
props[p] = props[name]; // 比如：$("div").animate({border-top-100,float:left});会把props转换成{borderTopWidth:100,cssFloat(styleFloat):left}
delete props[name];
}
}
for(var i=0,node;node = this[i++];){ //$("div").animate({})，当页面有多个div元素时，这里被选择的元素将有多个，我们必须对这几个div进行循环遍历处理
insertFrame(
$.mix({
positive:[], //正向队列
negative:[], //反向队列
node:node, //元素节点
props:props //props是关键帧的样式集合，相当于css3中@keyframes定义的样式规则
},opts); //opts中定义的是动画的基本属性，也就是.animate中定义的动画的变化规则。
); //最后把这些属性值弄成一个json对象，传进insertFrame方法中，进行动画的执行。
}
return this;
}
function addOptions(props){
if(isFinite(props)){ //如果 props 是有限数字（或可转换为有限数字），那么返回 true。否则，如果props是 NaN（非数字），或者是正、负无穷大的数，则返回 false。 比如：$("div").animate(3);
return { duration:props};
}
var opts = {};
for(var i=1;i<arguments.length;i++){ //如果在animate方法中传入了第二个参数，第三个参数....
addOption(opts ,arguments[i]);
}
opts.duration = typeof opts.duration ==="number" ? opts.duration : 400; //如果第二个参数，第三个参数...中有数字类型，那么就返回这个数字类型，如果没有，就把opts.duration = 400;
opts.queue = !!(opts.queue ==null || opts.queue); //这里的opts.queue是undefined,因此这里返回true，也就是默认进行排队操作
opts.easing = $.easing[opts.easing] ? opts.easing : "swing"; //如果第二个参数，第三个参数...中有字符串类型，那么就判断这个字符串是否是缓动公式的名字，如果是就直接返回，如果不是，就设置opts.easing = "swing"，默认动画的缓动公式为swing。
return opts;
}
function addOption(opts, p){
switch($.type(p)){ //判断animate方法中第二个参数，第三个参数.....，的类型
case "Object":
addCallback(opts, p , "after");
addCallback(opts, p , "before");
$.mix(opts, p); //把第二个参数，第三个参数....，中的其他属性值赋给opts。
break;
case "Number": //如果是数字，就直接赋给opts的duration属性。
opts.duration = p;
break;
case "String": //如果是字符串，就直接赋给opts的easing属性
opts.easing = p;
break;
case "Function": //如果是函数，就直接赋给opts的complete属性，比如：$("div").animate({},function(){alert(1)});这时,opts = {complete:function(){alert(1)}}，当然，第三个参数，以及后面的参数，会覆盖同类型的属性值。比如:$("div").animate({},function(){alert(1)},function(){alert(2)})，complete会变成弹出2的那个函数。
opts.complete = p;
break;
}
}
function addCallback(target, source, name){ //这里的source的类型是Object，name是after或者是before
if(typeof source[name] === "function"){ //查看animate的第二个参数，第三个参数...里面是否有after或者before的函数
var fn = target[name]; //addOptions方法中私有的opts对象中是否有after或before函数
if(fn){ //如果有，就重写opts对象中的同名函数，我们假设$("div").animate({},{before:function(){alert(1)}},{before:function(){alert(2)}})，第一次判断时，opts对象是{}，里面没有before函数，因此把opts[before] = function(){alert(1)};，第二次判断时，opts对象是{before:function(){alert(1)}}，因此重写opts对象的before方法，此时opts = { before : function(node,fx){ (function(){alert(1)})(node,fx); (function(){alert(2)})(node,fx) ; }}
target[name] = function(node, fx){
fn(node, fx);
source[name](node,fx);
};
}else{
target[name] = source[name];
}
}
delete source[name]; //如果第二个参数，第三个参数....，中的before和after的属性值不是函数，那么就直接删除，如果是函数，赋值给opts后，也删除。
}
var timeline = $.timeline = [];
function insertFrame( frame ){
if(frame.queue){ //在addOptions方法中，默认设置queue为true，也就是动画默认支持队列操作
var gotoQueue = 1;
for(var i= timeline.length,el;el = timeline[--i];){ //timeline默认为空，所以这里第一次不执行
if(el.node === frame.node){ //当对同一个元素节点进行多个动画操作时，只有第一个动画才会马上执行，而其他动画会先保存在此动画对象的positive数组中，只有等第一个动画执行接受，才会取出第二个动画对象进行执行，直到positive数组中的所有动画都执行完
el.positive.push(frame);
gotoQueue = 0;
break;
}
}
if(gotoQueue){
timeline.unshift(frame); //从数组的前面插入此json对象frame。
}
}else{
timeline.push(frame); //如果不用排队，也就是针对一个元素的多个动画对象要同时执行，那么就添加到timeline数组中
}
if(insertFrame.id === null){ //第一次执行时，这里的id为null，因此执行
insertFrame.id = setInterval(deleteFrame , 1000 / $.fps); //fps是刷新率，1000除以fps就代表，多少毫秒需要进行一次帧的切换
}
}
insertFrame.id = null;
function deleteFrame(){
var i = timeline.length; //这里指的是动画的个数
while(--i >= 0){
if(!timeline[i].paused){ //如果动画没有被暂停，正常情况下，这里的paused是undefined
if(!(timeline[i].node && enterFrame(timeline[i],i))){ //这里node就是元素节点，然后执行enterFrame方法，如果此方法返回false，就进入if语句，只要进入了if语句，就会删除数组中的选项，动画就会结束，因此enterFrame方法，只有当动画结束时，才会返回false。
timeline.splice(i,1);
}
}
}
timeline.length || (clearInterval(insertFrame.id), insertFrame.id = null); //如果timeline数组为0，就取消定时器，并且把定时器的id置为null。
}
function enterFrame(fx, index){ //这里的fx其实就是insertFrame中的frame对象
var node = fx.node, now = +new Date(); //node就是元素节点
if(!fx.startTime){ //第一次执行时frame没有这个属性，因此进入if语句
callback(fx, node , "before"); //动画开始时，进行一些准备工作
fx.props && parseFrames(fx.node, fx, index); //这里的props就是调用animate方法时，传入的第一个参数值。parseFrames方法很复杂，这里就不贴出来了，此方法的作用，就是根据animate方法中得到的json对象，生成两个关键帧，存入props属性中。[第一个关键帧，第二个关键帧]
fx.props = fx.props || [];
AnimationPreproccess[fx.method || "noop"](node, fx); //这里的fx没有method属性，因此调用noop方法，这里的fx.method属性值可以是show或hide或toggle等三个属性值。因为在进行show,hide,toggle这三种动画效果时，要对样式进行一些预处理操作。
fx.startTime = now;
}else{ //第二次执行时，fx.startTime已经存在了，因而进入else语句
var per = (now - fx.startTime) / fx.duration; //动画执行的时间除以总时间，得到动画的进度0-1之间的数字
var end = fx.gotoEnd || per >=1; //gotoEnd属性默认为undefined，但是你可以通过stop方法强制让它变成true，这样动画就会马上停止了。当进度>=1时，也意味着动画应该停止了。
var hooks = effect.updateHooks;
if(fx.update){ //这里的update在调用parseFrames方法时，如果样式需要做兼容处理，这里则会赋值为true。
for(var i =0,obj; obj=fx.props[i++];){ //props = [第一个关键帧，第二个关键帧];
(hooks[obj.type] || hooks._default)(node, per, end,obj); //这里的hooks有三个属性，一个是color，一个是scroll，一个是默认值_default，针对每一个关键帧的type类型，进行函数的调用，如果type类型不是color或者scroll，那么就调用默认的_default方法。这里的hooks就是真正实现元素变化的地方，也就是元素出现动画效果的地方。
}
}
if(end){ //如果动画结束，也就是动画的最后一帧
callback(fx, node, "after"); //动画结束后，进行一些收尾工作
callback(fx, node , "complete"); //执行动画完成时的用户回调函数
if(fx.revert && fx.negative.length){ //如果设置了动画倒带操作，并且动画的negative数组存在动画对象，就进入if语句，根据我们的例子，这里不会进入if语句
Array.prototype.unshift.apply(fx.positive, fx.negative.reverse()); //把倒带数组中的动画对象放到正向数组中
fx.negative = []; //清空倒带数组
}
var neo = fx.positive.shift(); //根据我们的例子，这里的positive数组为空，因此取数组的第一项，也是空，如果对此元素有两个或以上的动画操作，这里将返回第二个动画对象，重复第一个动画的操作，执行第二个动画。
if(!neo){
return false; //如果为空，就停止定时器的运转，结束此动画的操作
}
timeline[index] = neo; //如果存在排队的动画，让它继续
neo.positive = fx.positive;
neo.negative = fx.negative;
}else{
callback(fx, node , "step"); //每执行一帧，就执行的回调函数
}
}
return true;
}
function callback(fx, node ,name){ //假设这里的name="before"
if(fx[name]){ //animate的第二个参数，第三个参数...中是否有before的函数，比如，$("#div1").animate({},{"before":function(){}});
fx[name](node,fx); //如果有，就执行这个before函数
}
}
var AnimationPreproccess = {
noop: function(){},
show : function(node, frame){ //node为元素节点
if(node.nodeType ===1 && $.isHidden(node)){ //只有元素节点，并且是隐藏的，才有show操作
这里就是把元素的display改为block，但是对于像li，td，tr，tbody，table这样的元素，它们有默认的display的值，如果强行改成block，布局就会走形，因此需要做兼容处理。根据元素的nodeName设置不同的display。
如果需要对内联元素，比如：span，em等进行缩放操作（设置元素的width或height），我们需要设置内联元素的display为inline-block。但是老版本IE浏览器需要开启hasLayout才能生效。要让老版本IE拥有布局，只需要让元素节点node.style.zoom = 1;就行了。
}
}
},
hide:function(node , frame){
这里就是将显示的元素隐藏起来，由于它对应的动画效果是从大到小（设置元素的width和height），这时进行动画的那个元素的子元素可能会超出父元素的大小。因此我们需要设置元素的overflow:hidden，在动画结束后，还原回来。此外，还原的样式值还有宽，高，边框，透明度等。（除了IE浏览器，如果你改写了overflow-x和overflow-y为同一个值，比如：hidden，那么它的overflow就会变成那个值，比如：hidden，但是IE下overflow不会改变。）
},
toggle:function(){
AnimationPreproccess[$.isHidden(node) ? "show" : "hide"](node,fx);
}
}
effect.updateHooks = {
_default:function(node, per, end, obj){ //node是元素节点，per是动画的进度，end动画是否结束，obj关键帧对象
$.css(node, obj.name , (end? obj.to : obj.from + obj.easing(per) * (obj.to-obj.from)) + obj.unit); //设置元素节点的样式属性obj.name，进度per传入缓存公式中得到它的最终进度，然后乘以总距离，最后加上此帧在整个动画的位置，得到最终值
},
color:function(node, per, end, obj){
var pos = obj.easing(per);
var rgb = end? obj.to : obj.from.map(function(from, i){ //如果是颜色，那么就需要处理三个值，也就是rgb，from是一个数组[r,g,b]
return Math.max( Math.min(parseInt(from+(obj.to[i]-from)*per,10),255),0);
})
node.style[obj.name] = "rgb(" + rgb + ")"; //假设这里的rgb = [33,33,33]，当数组与字符串相加时，会把数组转换成字符串，也就是rgb会转换成"33,33,33"，
因此node.style.color = "rgb(33,33,33)";设置颜色值。这里把颜色值转换成数组形式的rgb[r,g,b]是在parseFrame中进行的。而parseFrame是调用parseColor实现的。
},
scroll:function(node, per, end, obj){
node[obj.name] = (end? obj.to : obj.from + obj.easing(per) * (obj.to-obj.from));
}
}
var colorMap = {
"black":[0,0,0],
"gray":[128,128,128],
"white":[255,255,255],
"red":[255,0,0],
"green":[0,255,0],
"yellow":[255,255,0],
"blue":[0,0,255]
}
$.parseColor = function(color){
var color = color.toLowerCase();
if(colorMap[color]){ //处理颜色名
return colorMap[color];
}
if(color.indexOf("rgb") == 0){ //如果是rgb格式的，比如:"rgb(33,33,33)"或者"rgb(33%,33,33)"
var match = color.match(/(d+%?)/g); //match = [33,33,33]或 [33%,33%,33%]
var factor = match[0].indexOf("%") != -1 ? 2.55 :1; //如果是百分数，factor就是2.55，因为这里的百分数已经乘以100了，所以这里只需要乘以2.55就能转化成数字形式了。这里无法处理[33%,33%,33]混合情况。
return colorMap[color]=[ parseInt(match[0]) * factor , parseInt(match[1]) * factor , parseInt(match[2]) * factor ];
}else if(color.chatAt(0) == "#"){ //如果是16进制格式的，比如:"#ffffdd"
if(color.length === 4){ //"#fff"，这种情况
color = color.replace(/([^#])/g,"$1$1"); //这个正则的意思就是只要不是"#"就匹配，因此f匹配，被替换成$1$1，而$1代表的是第一个子表达式匹配的元素，也就是f，因此f被替换成ff，最后color = "#ffffff"。
}
var ret = [];
color.replace(/w{2}/g,function(match){ //这里的match就是ff，每次替换两个字符
ret.push(parseInt(match,16)); //把ff这种16进制的数字，转换成10进制的数字，这里的ff转换成255，然后存入数组ret中，ret最后变成[255,255,255]
});
return colorMap[color] = ret;
}
return colorMap.white; //如果都不匹配，就返回[255,255,2555]
}
此课，内容太多，难度太大，能看懂多少，就看懂多少吧，上面的这个转换颜色的方法，请看懂，大公司社招可能会问。
加油！