8주 3일째 노트의 운동 라이브러리 포장

11764 단어
동작 라이브러리 패키지
  • 실질: 원소는 현재 위치(ele결정)부터 정해진 시간(duration) 내에 일종의 운동효과(effect)로 목표 위치(target)에 도달한 다음에 한 가지 일(callback)를 한다.하나의 운동 과정이다.
  • 사고방식:
  • 자체 실행 함수 봉인, 운동 형식 라이브러리 gbEffect, 운동 함수 animate() 만들기;
  • animate는 하나의 매개 변수opt를 하나의 대상으로 전송하고 실참 대상에는 여러 개의 속성 이름이 포함된다. 예를 들어ele,duration,target 대상,effect,callback 등 속성;
  • animate 함수 작성 프로세스:
  • 1 전송된 실참치를 판단한다.
  • 2 새 대상, 기본 스타일 추가
  • 3은 전송된 실참opt를 모든 속성에defaultopt에 부여하고 재부여가 존재하면 존재하지 않으면 기본값을 사용합니다.
  • 4defaultopt의 매개 변수 가져오기
  • 5 운동 형식 획득, 매개 변수 계산
  • 5.1 획득 운동 형식:effect의 데이터 유형을 판단하고 다음 두 가지 상황을 만족시키면 각자의 코드를 실행하고 만족하지 않으면 기본값을 사용한다.
  • 5.2 전입 운동 형식의 매개 변수 계산
  • 6 타이머 추가
  • 6.1 변수 누적
  • 6.2 경계치 판단
  • 6.2.1 경계값 설정
  • 6.2.2 타이머 중지
  • 6.2.3 리셋 함수를 실행하고 다음 조작
  • 6.2.4 차단기 실행
  • 6.3 최신 위치 가져오기 및 최신 위치 설정
  • 6.3.1 운동 방식으로 최신 위치 얻기;
  • 6.3.2 각각 최신 위치 설정


  • 자체 실행 함수 중의 애니메이션 함수를 window의 전역 변수로 설정합니다.

  • 지식 포인트:
  • 실참에 전입되었는지 판단하고 실참에 전입된 요소가 있는지 판단한다. 예를 들어 아래 코드:
  •  function animate(opt) {
         //        
         opt=opt || {};
         //ele target       ,                 ;
         if(!opt.ele || !opt.target) return;//      ,       ;
       }
    
  • 새로운defaultopt 대상을 만듭니다. 기본 속성을 설정하고 전송된 대상의 모든 속성을 새 대상에게 부여합니다. 속성이 존재하면 다시 부여하고 존재하지 않으면 설정합니다.defaultopt의 역할은 기본 속성을 설정하는 것입니다. 전송된 실삼에defaultopt의 속성을 설정하면 다시 값을 부여하고 설정하지 않으면 기본값을 사용합니다.
  •  //1       ,        
     var defaultOpt={
         duration: 2000,
         effect: "linear"
     };
     //2       opt,       defaultOpt,        ,     ,     ;
     for(var attr in opt){
         defaultOpt[attr]=opt[attr];
     }
     //  :defaultOpt           ,            defaultOpt     ,     ,      ,     ;
     //          opt,   defaultOpt;
    
  • 리셋 함수 호출 및this가 가리키는 설정을 변경한다. 예를 들어 callback && callback.call(ele);'&&'를 이용하여 콜백이 존재하는 상황에서만 뒷코드를 실행하고 뒷코드에서call을 이용하여 리셋 함수 중의this지향을 바꾸어ele요소를 가리키며 기본적으로this는window를 가리킨다.
  • 투명도 설정 문제는 target에 투명도를 설정한 후 운동 형식에서 출력을 계산한 것은 문자열로 설정에 성공하지 못하기 때문에 처리하고 Number를 이용하여 전환해야 한다.
  •  //  opacity   ,           ,      
     if(typeof linear ==="string"){
          //linear=parseFloat(linear).toFixed(2);//          
         linear=Number(linear.slice(0,4));//        ,        ,   Number     NaN;
     }
    
  • 코드
  • 운동 라이브러리 코드:
  •  (function () {
         //     
         function animate(opt) {
             //0            ;
             opt=opt || {};
             //ele target       ,                 ;
             if(!opt.ele || !opt.target) return;//      ,       ;
             //1       ,        
             var defaultOpt={
                 duration: 2000,
                 effect: "Linear"
             };
             //2       opt,       defaultOpt,        ,     ,     ;
             for(var attr in opt){
                 defaultOpt[attr]=opt[attr];
             }
             //  :defaultOpt           ,            defaultOpt     ,     ,      ,     ;
             //          opt,   defaultOpt;
     
             //3   defaultOpt     
             var ele=defaultOpt.ele;
             var target=defaultOpt.target;
             var duration=defaultOpt.duration;
             var callback=defaultOpt.callback;
             var effect=defaultOpt.effect;
             var tempEffect=null;
             //4       ,    
             //4.1       :  effect     ,        ,        ,     ,      ;
             var ary=["Linear","EaseIn","EaseOut","EaseBoth","EaseInStrong","EaseOutStrong","EaseBothStrong","Elastic-In","Elastic-Out","Elastic-Both","Back-In","Back-Out","Back-Both","Bounce-In","Bounce-Out","Bounce-Both"];
             if(typeof effect==="number"){
                 ary=ary[effect%ary.length].split("-");
                 tempEffect=ary.length>=2?gbEffect[ary[0]][ary[1]]:gbEffect[ary[0]];
             }else if(typeof effect==="object"){
                 tempEffect=effect.length>=2?gbEffect[effect[0]][effect[1]]:gbEffect[effect[0]];
             }else if(typeof effect==="string"){
                 tempEffect=gbEffect[effect];//  tempEffect          ,     ;
             }
             //4.2             
             var begin={},change={};
             for(var attr in target){
                 begin[attr]=utils.css(ele,attr);
                 change[attr]=target[attr]-begin[attr];
             }
             var time=0;
     
             //5      
             var timer=setInterval(function () {
                 //5.1     
                 time+=30;
                 //5.2      
                 if(time>=duration){
                     //5.2.1      
                     utils.css(ele,target);
                     //5.2.2      
                     clearInterval(timer);
                     //5.2.3       ,       
                     callback && callback.call(ele);// callback     ,      ,     this     ;
                     //5.2.4       
                     return;
                 }
                 //5.3              
                 for(var attr in change){
                     //5.3.1           ;
                     var cur=tempEffect(time,begin[attr],change[attr],duration);
                     //  opacity   ,           ,      
                     if(typeof cur ==="string"){
                         //cur=parseFloat(cur).toFixed(2);//          
                         cur=Number(cur.slice(0,4));//        
                     }
                     //5.3.2         
                     utils.css(ele,attr,cur);
                 }
             },30)
     
         }
         window.animate=animate;//            ;
     })();
    
  • 운동방식 라이브러리:
  •  var gbEffect= {
         Linear: function (t, b, c, d){  //  
             return c*t/d + b;
         },
         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;
         },
         EaseBoth: function(t, b, c, d){  //      
             if ((t/=d/2) < 1) {
                 return c/2*t*t + b;
             }
             return -c/2 * ((--t)*(t-2) - 1) + b;
         },
         EaseInStrong: function(t, b, c, d){  //     
             return c*(t/=d)*t*t*t + b;
         },
         EaseOutStrong: function(t, b, c, d){  //     
             return -c * ((t=t/d-1)*t*t*t - 1) + b;
         },
         EaseBothStrong: 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;
         },
         Elastic:{
             In: function(t, b, c, d, a, p){  //      (    )
                 if (t === 0) {
                     return b;
                 }
                 if ( (t /= d) == 1 ) {
                     return b+c;
                 }
                 if (!p) {
                     p=d*0.3;
                 }
                 if (!a || a < Math.abs(c)) {
                     a = c;
                     var s = p/4;
                 } else {
                     var 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;
             },
             Out: function(t, b, c, d, a, p){    //      (    )
                 if (t === 0) {
                     return b;
                 }
                 if ( (t /= d) == 1 ) {
                     return b+c;
                 }
                 if (!p) {
                     p=d*0.3;
                 }
                 if (!a || a < Math.abs(c)) {
                     a = c;
                     var s = p / 4;
                 } else {
                     var 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;
             },
             Both: function(t, b, c, d, a, p){
                 if (t === 0) {
                     return b;
                 }
                 if ( (t /= d/2) == 2 ) {
                     return b+c;
                 }
                 if (!p) {
                     p = d*(0.3*1.5);
                 }
                 if ( !a || a < Math.abs(c) ) {
                     a = c;
                     var s = p/4;
                 }
                 else {
                     var s = p/(2*Math.PI) * Math.asin (c/a);
                 }
                 if (t < 1) {
                     return - 0.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 )*0.5 + c + b;
             }
     
         },
         Back:{
             In: function(t, b, c, d, s){     //    (    )
                 if (typeof s == 'undefined') {
                     s = 1.70158;
                 }
                 return c*(t/=d)*t*((s+1)*t - s) + b;
             },
             Out: function(t, b, c, d, s){
                 if (typeof s == 'undefined') {
                     s = 3.70158;  //     
                 }
                 return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
             },
             Both: function(t, b, c, d, s){
                 if (typeof 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;
             }
         },
         Bounce:{
             In: function(t, b, c, d){    //    (    )
                 return c - gbEffect.Bounce.Out(d-t, 0, c, d) + b;
             },
             Out: 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 + 0.75) + b;
                 } else if (t < (2.5/2.75)) {
                     return c*(7.5625*(t-=(2.25/2.75))*t + 0.9375) + b;
                 }
                 return c*(7.5625*(t-=(2.625/2.75))*t + 0.984375) + b;
             },
             Both: function(t, b, c, d){
                 if (t < d/2) {
                     return gbEffect.Bounce.In(t*2, 0, c, d) * 0.5 + b;
                 }
                 return gbEffect.Bounce.Out(t*2-d, 0, c, d) * 0.5 + c*0.5 + b;
             }
         }
     };
     //             ;
     var gbEffectAry=["Linear","EaseIn","EaseOut","EaseBoth","EaseInStrong","EaseOutStrong","EaseBothStrong","Elastic-In","Elastic-Out","Elastic-Both","Back-In","Back-Out","Back-Both","Bounce-In","Bounce-Out","Bounce-Both"];
    
  • 실행 코드:
  • var oDiv1=document.getElementById("div1"); animate({ ele:oDiv1, target:{ left:1000, top:400, opacity: 0.8 }, effect:1, duration: 2000, callback:function () { // ,this window; // , call this ele; this.style.backgroundColor="yellow"; } })

    좋은 웹페이지 즐겨찾기