• jQuery动画函数模拟


    <!DOCTYPE html>
    <html lang="en">
    
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Document</title>
        <style>
            div {
                 100px;
                height: 100px;
                background-color: pink;
                position: relative;
                top: 0;
                left: 0;
                padding-left: 10px;
            }
        </style>
    </head>
    
    <body>
        <div></div>
        <script>
            /*
             *@para0 DOM对象
             *@para1 目标对象JSON类型
             *@para2 动画总时长
             *@para3 动画缓冲描述词
             *@para4 回调函数
             */
            function animate(elem, targetJSON, time, tweenString, callback) {
                if (arguments.length == 3) {
                    tweenString = 'Linear';
                    callback = null
                } else if (arguments.length == 4) {
                    switch (typeof arguments[3]) {
                        case 'string':
                            callback = null;
                            break;
                        case 'function':
                            callback = arguments[3];
                            tweenString = 'Linear'
                            break;
                        default:
                            throw new Error("抱歉,第4个参数要么是缓冲描述词,要么是回调函数,请检查!");
                    }
                }
                // 定义动画每帧间隔时间
                var interval = 10;
                // 定义节流阀
                var isanimated = true
                    // 获取DOM对象当前值
                var originJSON = {};
                // 获取变化量
                var changeJSON = {};
                for (var k in targetJSON) {
                    targetJSON[k] = parseFloat(targetJSON[k])
                    originJSON[k] = parseFloat(fetchComputedStyle(elem, k))
                    changeJSON[k] = targetJSON[k] - originJSON[k]
                }
                // 计算总帧率与当前帧率
                var allFrame = time / interval
                var frameCount = 0;
                // 计算后的步值
                var state
                    // 声明定时器
                var timer = setInterval(function() {
                    frameCount++
                    // 利用缓动公式计算步值
                    for (var k in targetJSON) {
                        state = Tween[tweenString](frameCount, originJSON[k], changeJSON[k], allFrame)
                        if (k != 'opacity') {
                            elem.style[k] = state + 'px';
                        } else {
                            elem.style[k] = state
                        }
    
                    }
                    // 当动画完成后停表
                    if (frameCount >= allFrame) {
                        for (var k in targetJSON) {
                            if (k != 'opacity') {
                                elem.style[k] = targetJSON[k] + 'px'
                            } else {
                                elem.style[k] = targetJSON[k]
                            }
                        }
                        clearInterval(timer);
                        isanimated = false;
                        callback && callback.call(elem)
                    }
                }, interval)
    
    
    
                var Tween = {
                    Linear: function(t, b, c, d) {
                        return c * t / d + b;
                    },
                    //二次的
                    QuadEaseIn: function(t, b, c, d) {
                        return c * (t /= d) * t + b;
                    },
                    QuadEaseOut: function(t, b, c, d) {
                        return -c * (t /= d) * (t - 2) + b;
                    },
                    QuadEaseInOut: function(t, b, c, d) {
                        if ((t /= d / 2) < 1) return c / 2 * t * t + b;
                        return -c / 2 * ((--t) * (t - 2) - 1) + b;
                    },
                    //三次的
                    CubicEaseIn: function(t, b, c, d) {
                        return c * (t /= d) * t * t + b;
                    },
                    CubicEaseOut: function(t, b, c, d) {
                        return c * ((t = t / d - 1) * t * t + 1) + b;
                    },
                    CubicEaseInOut: 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;
                    },
                    //四次的
                    QuartEaseIn: function(t, b, c, d) {
                        return c * (t /= d) * t * t * t + b;
                    },
                    QuartEaseOut: function(t, b, c, d) {
                        return -c * ((t = t / d - 1) * t * t * t - 1) + b;
                    },
                    QuartEaseInOut: 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;
                    },
                    QuartEaseIn: function(t, b, c, d) {
                        return c * (t /= d) * t * t * t * t + b;
                    },
                    QuartEaseOut: function(t, b, c, d) {
                        return c * ((t = t / d - 1) * t * t * t * t + 1) + b;
                    },
                    QuartEaseInOut: 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;
                    },
                    //正弦的
                    SineEaseIn: function(t, b, c, d) {
                        return -c * Math.cos(t / d * (Math.PI / 2)) + c + b;
                    },
                    SineEaseOut: function(t, b, c, d) {
                        return c * Math.sin(t / d * (Math.PI / 2)) + b;
                    },
                    SineEaseInOut: function(t, b, c, d) {
                        return -c / 2 * (Math.cos(Math.PI * t / d) - 1) + b;
                    },
                    ExpoEaseIn: function(t, b, c, d) {
                        return (t == 0) ? b : c * Math.pow(2, 10 * (t / d - 1)) + b;
                    },
                    ExpoEaseOut: function(t, b, c, d) {
                        return (t == d) ? b + c : c * (-Math.pow(2, -10 * t / d) + 1) + b;
                    },
                    ExpoEaseInOut: 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;
                    },
                    CircEaseIn: function(t, b, c, d) {
                        return -c * (Math.sqrt(1 - (t /= d) * t) - 1) + b;
                    },
                    CircEaseOut: function(t, b, c, d) {
                        return c * Math.sqrt(1 - (t = t / d - 1) * t) + b;
                    },
                    CircEaseInOut: 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;
                    },
                    ElasticEaseIn: function(t, b, c, d, a, p) {
                        if (t == 0) return b;
                        if ((t /= d) == 1) return b + c;
                        if (!p) p = d * .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;
                    },
                    ElasticEaseOut: function(t, b, c, d, a, p) {
                        if (t == 0) return b;
                        if ((t /= d) == 1) return b + c;
                        if (!p) p = d * .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);
                    },
                    ElasticEaseInOut: 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);
                        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 -.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;
                    },
                    //冲过头系列
                    BackEaseIn: function(t, b, c, d, s) {
                        if (s == undefined) s = 1.70158;
                        return c * (t /= d) * t * ((s + 1) * t - s) + b;
                    },
                    BackEaseOut: 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;
                    },
                    BackEaseInOut: 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;
                    },
                    //弹跳系列
                    BounceEaseIn: function(t, b, c, d) {
                        return c - Tween.BounceEaseOut(d - t, 0, c, d) + b;
                    },
                    BounceEaseOut: 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;
                        }
                    },
                    BounceEaseInOut: function(t, b, c, d) {
                        if (t < d / 2) return Tween.BounceEaseIn(t * 2, 0, c, d) * .5 + b;
                        else return Tween.BounceEaseOut(t * 2 - d, 0, c, d) * .5 + c * .5 + b;
                    }
                }
    
            }
            var oDiv = document.querySelector('div')
            animate(oDiv, {
                'paddingLeft': '50px',
                'top': '60px',
                'left': '60px',
                'opacity': 0.6
            }, 500, function() {
    
            })
    
            // 获取DOM元素当前属性
            function fetchComputedStyle(obj, str) {
    
                str = str.replace(/([A-Z])/g, function(match, $1) {
                    return '-' + $1.toLowerCase()
                })
                return getComputedStyle(obj)[str]
            }
        </script>
    
    </body>
    
    </html>
  • 相关阅读:
    ZeroMQ
    ps-lite源码解析
    RDMA
    MapReduce
    parameter server
    BytePS
    ELF程序头部及程序加载
    网络序与主机序
    CPU、CPU核与线程的关系
    chroot
  • 原文地址:https://www.cnblogs.com/tengx/p/12312408.html
Copyright © 2020-2023  润新知