Jquey Deferred 独立实现版本不依赖jquery

原创 2017年08月26日 01:35:14
var eLingUtils = {
    GolbalFireActionCache: {},
    fireOnce: function (key, func) {
        if (GolbalFireActionCache.hasOwnProperty(key)) {
            return;
        } else {
            GolbalFireActionCache[key] = func();
        }
    },
    each: function (arr, func) {

        if (arr.length > 0) {
            for (var i = 0; i < arr.length; i++) {

                func.call(arr[i], i, arr[i])
            }
        }
    },
    extend: function (a, b) {
        var found = false;
        if (a == undefined) {
            found = true;
        } else {
            for (var c in a) {
                found = true;
                if (c in b) {
                    eLingUtils.extend(a[c], b[c]);
                }
            }
        }
        if (!found) {
            a = b;
        } else {
            if (b != undefined) {
                for (var d  in b) {
                    if (!(d in a)) {
                        a[d] = b[d];
                    }
                }
            }
        }
        return a;
    },
    Deferred: function (func) {
        var tuples = [
                ["resolve", "done", "resolved"],
                ["reject", "fail", "rejected"],
                ["notify", "progress"]
            ],
            state = "pending",
            callbacksProvider = {
                FireActionCache: {},
                addAndFireOnce: function (key, func) {
                    if (callbacksProvider.FireActionCache.hasOwnProperty(key)) {
                        return;
                    } else {
                        callbacksProvider.FireActionCache[key] = func();
                    }
                }, addCallbacks: function (key, func) {
                    if (callbacksProvider.FireActionCache.hasOwnProperty(key)) {

                        if (callbacksProvider.FireActionCache[key + "Initialized"] == false) {
                            var CachedParam = callbacksProvider.FireActionCache[key];
                            callbacksProvider.FireActionCache[key + "Initialized"] = true;
                            callbacksProvider.FireActionCache[key] = func;
                            for (var i = 0; i < CachedParam.length; i++) {
                                func.apply(CachedParam[i].contextCache, CachedParam[i].argumentsCache);
                            }
                        } else {
                            return;
                        }
                    } else {
                        callbacksProvider.FireActionCache[key + "Initialized"] = true;
                        callbacksProvider.FireActionCache[key] = func;
                    }
                }, memoryFire: function (key) {

                    if (callbacksProvider.FireActionCache.hasOwnProperty(key)) {
                        if (callbacksProvider.FireActionCache[key + "Initialized"]) {
                            return callbacksProvider.FireActionCache[key];
                        } else {
                            return function () {
                                callbacksProvider.FireActionCache[key].push({
                                    state: "pending",
                                    contextCache: this,
                                    argumentsCache: arguments

                                });
                            }
                        }

                    } else {
                        callbacksProvider.FireActionCache[key + "Initialized"] = false;
                        return function () {
                            callbacksProvider.FireActionCache[key] = [];
                            callbacksProvider.FireActionCache[key].push({
                                state: "pending",
                                contextCache: this,
                                argumentsCache: arguments

                            });
                        }
                    }
                }
            }, promise = {
                state: function () {
                    return state;
                }, always: function () {
                    deferred.done(arguments).fail(arguments);
                    return this;
                }, then: function () {
                    var fns = arguments;
                    return eLingUtils.Deferred(function (newDefer) {
                        eLingUtils.each(tuples, function (i, tuple) {
                            var action = tuple[0], fn = typeof(fns[i]) == "function" && fns[i];
                            deferred[tuple[1]](function () {
                                var returned = fn && fn.apply(this, arguments);
                                if (returned && typeof(returned.promise) == "function") {
                                    returned.promise()
                                        .done(newDefer.resolve)
                                        .fail(newDefer.reject)
                                        .progress(newDefer.notify);
                                } else {
                                    newDefer[action].apply(this === promise ? newDefer : this, arguments);
                                }
                            });
                        });
                        fns = null;
                    }).promise();
                }, promise: function () {
                    try {
                        return promise;
                    } catch (e) {

                    } finally {
                        if (func) {
                            func.call(deferred, deferred);
                        }
                    }
                }
            }, deferred = {};
        promise.pipe = promise.then;
        eLingUtils.each(tuples, function (i, tuple) {
            promise[tuple[1]] = function (func) {
                callbacksProvider.addCallbacks(tuple[0] + "With", func);
                return promise;
            };
            deferred[tuple[0]] = function () {
                if (tuple[0] == "notify") {
                    callbacksProvider.memoryFire(tuple[0] + "With").apply(this === deferred ? promise : this, arguments);
                    return this;
                } else {
                    callbacksProvider.addAndFireOnce(tuple[0] + "Fired", function () {

                        callbacksProvider.memoryFire(tuple[0] + "With").apply(this === deferred ? promise : this, arguments);
                        return this;
                    });
                }
            };
        });
        return eLingUtils.extend(deferred, promise);
    },
    when: function (subordinate) {
        var i = 0,
            resolveValues = Array.prototype.slice.call(arguments, 1),
            length = resolveValues.length,
            remaining = length !== 1 || ( subordinate && typeof(subordinate.promise) == "function" ) ? length : 0,
            deferred = remaining === 1 ? subordinate : eLingUtils.Deferred(),
            updateFunc = function (i, contexts, values) {
                return function (value) {
                    contexts[i] = this;
                    values[i] = arguments.length > 1 ? Array.prototype.slice.call(arguments) : value;
                    if (values === progressValues) {
                        deferred.notifyWith(contexts, values);
                    } else if (!( --remaining )) {
                        deferred.resolveWith(contexts, values);
                    }
                };
            }, progressValues, progressContexts, resolveContexts;
        if (length > 1) {
            progressValues = new Array(length);
            progressContexts = new Array(length);
            resolveContexts = new Array(length);
            for (; i < length; i++) {
                if (resolveValues[i] && typeof(resolveValues[i].promise) == "function") {
                    resolveValues[i].promise()
                        .done(updateFunc(i, resolveContexts, resolveValues))
                        .fail(deferred.reject)
                        .progress(updateFunc(i, progressContexts, progressValues));
                } else {
                    --remaining;
                }
            }
        }
        if (!remaining) {
            deferred.resolveWith(resolveContexts, resolveValues);
        }
        return deferred.promise();
    }
};

DoubleLinkedList独立实现,不依赖任何包

精彩继续,实现完SingleLinkedList之后,今天又实现了双向链接表,代码如下: public class DoubleLinkedListE> {     class NodeE...

Android 用service实现不依赖activity的版本更新功能

关于app的版本检测和更新功能在service里的实现。 先介绍下项目背景。大部分app都需要提供一个在线更新的功能,一般有自动弹出对话框,或者点击某个按钮后,弹出对话框提示有新版本的更新。...

tbl.js div实现的表格控件,完全免费,不依赖jquery

html上现在有比较好用的表格控件是datatable,但是编辑、按钮等部分是收费的,只有基础功能免费。而且尺寸发生变化时需要手工刷新等繁琐操作较多。所以我开发一个免费的供大家使用。 本项目已用于“...

如何将MATLAB程序发布为独立的不依赖MATLAB环境可执行的程序包(基于Matlab R2015b版 )

如何将MATLAB程序.m文件发布为独立的不依赖MATLAB环境可执行的程序包。本文演示了基于Matlab R2015b版的实际操作步骤。 应用背景:写好的Matlab程序要交给别人使用,但是对方机器...
  • heshiip
  • heshiip
  • 2016年02月26日 18:13
  • 7535

有了Jrebel,让独立部署的tomcat也支持热部署(不依赖Eclipse或MyEclipse)

网上多是Jrebel结合Eclipse或MyEclipse配置的文章,关于直接让Jrebel支持独立运行的Tomcat的文章很少,我这里来写一个我部署的过程。   JRebel是一套JavaEE开...
  • e_wsq
  • e_wsq
  • 2011年12月08日 17:19
  • 2305

deferred/when jQuery 1.5版本以后的一些新方法

$.when().done() deferred

VC生成不依赖高版本msvcrtXX.dll程序之方法一——完全抛弃CRT库

只使用Win32API,完全抛弃CRT库如果我们的程序只使用C语言基本语法、调用Win32API而不依赖C库的函数(《Windows程序设计》(petzold著)中的代码基本就是如此,因此国外也有人称...
  • LPWSTR
  • LPWSTR
  • 2017年11月16日 17:23
  • 79

借助WDK7.1让高版本VC生成的可执行文件不依赖msvcrtXX.dll

高版本VS链接到msvcrt.lib上一篇中介绍的方法适用面并不广,毕竟C++有着一大堆的优良特性和类库,比如STL、boost、MFC和QT等等,在普通的开发中只使用Win32API确实有点苦行僧的...
  • LPWSTR
  • LPWSTR
  • 2017年11月16日 17:42
  • 111

使用JQuery Deferred对象的then() 解决多个AJAX操作顺序依赖的问题

我们知道deferred.resolve()、deferred.reject()、deferred.notify()可以指定参数值,这个参数会传递给相应状态下的回调函数。如果我们使用的是done()、...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Jquey Deferred 独立实现版本不依赖jquery
举报原因:
原因补充:

(最多只允许输入30个字)