javaScript中的运动库封装

这个库的封装的目的是为了让调用者更好的使用，而不必要思考参数的位置或者参数的个数的问题；闭包里面的函数，如果需要给外界调用，可以通过window传递出去，把这个函数当作window身上的自定义属性，数组形式的判断：{}.toString.call(tmpEffect)==='[object Array]'// 数组的形式

// 闭包的方式
(function(){
// 运动的效果
      var icessunEffect={
          //匀速
        Linear: function (t, b, c, d) {
            return c * t / d + b;
        },
        //指数衰减的反弹缓动
        Bounce: {
            easeIn: function (t, b, c, d) {
                return c - ymyEffect.Bounce.easeOut(d - t, 0, c, d) + b;
            },
            easeOut: function (t, b, c, d) {
                if ((t /= d) < (1 / 2.75)) {
                    return c * (7.5625 * t * t) + b;
                } else if (t < (2 / 2.75)) {
                    return c * (7.5625 * (t -= (1.5 / 2.75)) * t + .75) + b;
                } else if (t < (2.5 / 2.75)) {
                    return c * (7.5625 * (t -= (2.25 / 2.75)) * t + .9375) + b;
                } else {
                    return c * (7.5625 * (t -= (2.625 / 2.75)) * t + .984375) + b;
                }
            },
            easeInOut: function (t, b, c, d) {
                if (t < d / 2) {
                    return ymyEffect.Bounce.easeIn(t * 2, 0, c, d) * .5 + b;
                }
                return ymyEffect.Bounce.easeOut(t * 2 - d, 0, c, d) * .5 + c * .5 + b;
            }
        },
        //二次方的缓动
        Quad: {
            easeIn: function (t, b, c, d) {
                return c * (t /= d) * t + b;
            },
            easeOut: function (t, b, c, d) {
                return -c * (t /= d) * (t - 2) + b;
            },
            easeInOut: function (t, b, c, d) {
                if ((t /= d / 2) < 1) {
                    return c / 2 * t * t + b;
                }
                return -c / 2 * ((--t) * (t - 2) - 1) + b;
            }
        },
        //三次方的缓动
        Cubic: {
            easeIn: function (t, b, c, d) {
                return c * (t /= d) * t * t + b;
            },
            easeOut: function (t, b, c, d) {
                return c * ((t = t / d - 1) * t * t + 1) + b;
            },
            easeInOut: function (t, b, c, d) {
                if ((t /= d / 2) < 1) {
                    return c / 2 * t * t * t + b;
                }
                return c / 2 * ((t -= 2) * t * t + 2) + b;
            }
        },
        //四次方的缓动
        Quart: {
            easeIn: function (t, b, c, d) {
                return c * (t /= d) * t * t * t + b;
            },
            easeOut: function (t, b, c, d) {
                return -c * ((t = t / d - 1) * t * t * t - 1) + b;
            },
            easeInOut: function (t, b, c, d) {
                if ((t /= d / 2) < 1) {
                    return c / 2 * t * t * t * t + b;
                }
                return -c / 2 * ((t -= 2) * t * t * t - 2) + b;
            }
        },
        //五次方的缓动
        Quint: {
            easeIn: function (t, b, c, d) {
                return c * (t /= d) * t * t * t * t + b;
            },
            easeOut: function (t, b, c, d) {
                return c * ((t = t / d - 1) * t * t * t * t + 1) + b;
            },
            easeInOut: function (t, b, c, d) {
                if ((t /= d / 2) < 1) {
                    return c / 2 * t * t * t * t * t + b;
                }
                return c / 2 * ((t -= 2) * t * t * t * t + 2) + b;
            }
        },
        //正弦曲线的缓动
        Sine: {
            easeIn: function (t, b, c, d) {
                return -c * Math.cos(t / d * (Math.PI / 2)) + c + b;
            },
            easeOut: function (t, b, c, d) {
                return c * Math.sin(t / d * (Math.PI / 2)) + b;
            },
            easeInOut: function (t, b, c, d) {
                return -c / 2 * (Math.cos(Math.PI * t / d) - 1) + b;
            }
        },
        //指数曲线的缓动
        Expo: {
            easeIn: function (t, b, c, d) {
                return (t == 0) ? b : c * Math.pow(2, 10 * (t / d - 1)) + b;
            },
            easeOut: function (t, b, c, d) {
                return (t == d) ? b + c : c * (-Math.pow(2, -10 * t / d) + 1) + b;
            },
            easeInOut: function (t, b, c, d) {
                if (t == 0) return b;
                if (t == d) return b + c;
                if ((t /= d / 2) < 1) return c / 2 * Math.pow(2, 10 * (t - 1)) + b;
                return c / 2 * (-Math.pow(2, -10 * --t) + 2) + b;
            }
        },
        //圆形曲线的缓动
        Circ: {
            easeIn: function (t, b, c, d) {
                return -c * (Math.sqrt(1 - (t /= d) * t) - 1) + b;
            },
            easeOut: function (t, b, c, d) {
                return c * Math.sqrt(1 - (t = t / d - 1) * t) + b;
            },
            easeInOut: function (t, b, c, d) {
                if ((t /= d / 2) < 1) {
                    return -c / 2 * (Math.sqrt(1 - t * t) - 1) + b;
                }
                return c / 2 * (Math.sqrt(1 - (t -= 2) * t) + 1) + b;
            }
        },
        //超过范围的三次方缓动
        Back: {
            easeIn: function (t, b, c, d, s) {
                if (s == undefined) s = 1.70158;
                return c * (t /= d) * t * ((s + 1) * t - s) + b;
            },
            easeOut: function (t, b, c, d, s) {
                if (s == undefined) s = 1.70158;
                return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
            },
            easeInOut: function (t, b, c, d, s) {
                if (s == undefined) s = 1.70158;
                if ((t /= d / 2) < 1) {
                    return c / 2 * (t * t * (((s *= (1.525)) + 1) * t - s)) + b;
                }
                return c / 2 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2) + b;
            }
        },
        //指数衰减的正弦曲线缓动
        Elastic: {
            easeIn: function (t, b, c, d, a, p) {
                if (t == 0) return b;
                if ((t /= d) == 1) return b + c;
                if (!p) p = d * .3;
                var s;
                !a || a < Math.abs(c) ? (a = c, s = p / 4) : s = p / (2 * Math.PI) * Math.asin(c / a);
                return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
            },
            easeOut: function (t, b, c, d, a, p) {
                if (t == 0) return b;
                if ((t /= d) == 1) return b + c;
                if (!p) p = d * .3;
                var s;
                !a || a < Math.abs(c) ? (a = c, s = p / 4) : s = p / (2 * Math.PI) * Math.asin(c / a);
                return (a * Math.pow(2, -10 * t) * Math.sin((t * d - s) * (2 * Math.PI) / p) + c + b);
            },
            easeInOut: function (t, b, c, d, a, p) {
                if (t == 0) return b;
                if ((t /= d / 2) == 2) return b + c;
                if (!p) p = d * (.3 * 1.5);
                var s;
                !a || a < Math.abs(c) ? (a = c, s = p / 4) : s = p / (2 * Math.PI) * Math.asin(c / a);
                if (t < 1) return -.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
                return a * Math.pow(2, -10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p) * .5 + c + b;
            }
        }  
       };

// 运动函数 传入一个对象
 function animate(opt){
     var opt=opt||{}// 验证参数，没有传入就默认是一个空对象
     if(!opt.ele ||　!opt.target) return; // 要是这个对象上没有ele这个属性时，就直接退出程序
     
     // 默认的一些属性值
     var defaultOpt={
         duration:700,
         effect:icessunEffect.Linear
      };
 
     // 传了按照传入的参数来，没有按照默认的
     for(var attr in opt){
        defaultOpt[attr]=opt[attr];
      }
      
      var ele=defaultOpt.ele;
      var tmpEffect=deaultOpt.effect; // 默认是匀速 运动方式
      var duration=defaultOpt.duration;
      var target=defaultOpt.target;
      var callback=defaultOpt.callback;
// 运动形式
  var ary=["Linear", "Elastic-easeOut", "Back-easeOut", "Bounce-easeOut", "Expo-easeIn"];

// 也可以使用switch判断
   if(typeof tmpEffect==='number'){
       ary=ary[tmpEffect%ary.length].split('-');// 变成一个数组
       tmpEffect=ary.length>=2?icessunEffect[ary[0]][ary[1]]:icessunEffect[ary[0]];
       
    }else if({}.toString.call(tmpEffect)==='[object Array]'){ // 数组的形式
         tmpEffect=tmpEffect.length>=2?icessnEffect[tmpEffect[0]][tmpEffect[1]]:icessunEffect[tmpEffect[0]];
     }else if(typeof tmpEffect==='function'){
        // 当tmpEffect是函数的时候
        callback=tmpEffect;
      }

// switch(typeof tmpEffect){
   //  case 'number':
        //    ary=ary[tmpEffect%ary.length].split('-');// 变成一个数组
     //  tmpEffect=ary.length>=2?icessunEffect[ary[0]]     [ary[1]]:icessunEffect[ary[0]];
      // break;
     //  case 'object':
         //  tmpEffect=tmpEffect.length>=2?icessnEffect[tmpEffect[0]][tmpEffect[1]]:icessunEffect[tmpEffect[0]];
        //   break;
  //  }

// 为Linear参数做准备
var begin={},change={};

// 遍历target来求出begin和change值
for(var attr in target){
         begin[attr]=utils.getCss(ele,attr); // DOM工具库
         change[attr]=target[attr]-begin[attr];
    }      

     var duration=opt.duration||1000;
      var time=0; // 时间的累加作为边界值的判断
      // 开启定时器
      var timer=setInterval(function(){
           time+=10;
           if(time>=duration){
              // 设置目的地的值
              utils.css(ele,target);
              clearInterval(timer);
              // 回调函数存在，则调用 call改变this指向为ele
              callback&&callback.call(ele); 
              return;
            }
            //  根据时间求出最新的位置
            for(var attr in change){
               var curpos=tmpEffect(time,begin[attr],change[attr],duration);
               utils.css(ele,attr,curpos);
             }
       },10)
  }
// 把函数传递出去
window.animate=animate;
 })();

使用我们封装好的运动库函数

 var oDiv=document.getElementById('div');
// opt对象里面必须传递的：ele target 
// 可不传的： duration callabck 
 animate({
      ele:oDIv,
      // effect:2 这样也可以
      effect:['Bounce','easeInOut'],
      target:{
          left:1000,
          top:400,
          opacity:1,
       },
       callback:function(){
          this.style.background='yellow'
        }
  })