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 {
            width: 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>

 

posted on 2020-02-15 16:03  素心~  阅读(189)  评论(0编辑  收藏  举报

导航