Javascript 在setTimeout（）内的$之后运行函数

我有点困惑，我有一个setTimeout（），它有一个$。每个函数每5秒为每个滑块设置动画。（发生这种情况的原因是$.each函数中的另一个setTimeout（）

现在我想知道如何在之后运行我的populateGraph（）函数 setTimeout和$。每个都已完成，我尝试了以下操作，但是 它同时运行

---

谢谢！

您在上次设置超时调用后调用

populateGraph（）

，诀窍是，知道哪一个是您的最后一个：

setTimeout(function() {
    var currentCount = data.length;
    $.each(data, function(i, v) {
        setTimeout(function() {
            $(".slider#" + v.id).slider("value", globalcoachscores[i]);

            //decrease currentCount by one
            currentCount--;

            //if currentCount is at 0, then we know we've completed the last setTimeout
            if(!currentCount) {
              populateGraph();
            }
        }, 500 + (500 * i));
    });

}, 500);

---

在上次调用setTimeout后调用

populateGraph（）

，诀窍是知道哪一个是最后一个：

setTimeout(function() {
    var currentCount = data.length;
    $.each(data, function(i, v) {
        setTimeout(function() {
            $(".slider#" + v.id).slider("value", globalcoachscores[i]);

            //decrease currentCount by one
            currentCount--;

            //if currentCount is at 0, then we know we've completed the last setTimeout
            if(!currentCount) {
              populateGraph();
            }
        }, 500 + (500 * i));
    });

}, 500);

我想，你需要使用，就像这样

我想，你需要使用，就像这样

试试这个：

setTimeout(function() {
    var d= $.Deferred();
    var c=data.length;
    $.each(data, function(i, v) {
        setTimeout(function() {
            $(".slider#" + v.id).slider("value", globalcoachscores[i]);

         if (i+1==c)   d.resolve();
        }, 500 + (500 * i));
    });

    d.done(function () {
        populateGraph();
    });
}, 500);

试试这个：

setTimeout(function() {
    var d= $.Deferred();
    var c=data.length;
    $.each(data, function(i, v) {
        setTimeout(function() {
            $(".slider#" + v.id).slider("value", globalcoachscores[i]);

         if (i+1==c)   d.resolve();
        }, 500 + (500 * i));
    });

    d.done(function () {
        populateGraph();
    });
}, 500);

---

就安排在最后一个500毫秒后

setTimeout(function() {
    $.each(data, function(i, v) {
        setTimeout(function() {
            $(".slider#" + v.id).slider("value", globalcoachscores[i]);
        }, 500 * i);
    });
    setTimeout(populateGraph, 500 * data.length);
}, 500);

---

就安排在最后一个500毫秒后

setTimeout(function() {
    $.each(data, function(i, v) {
        setTimeout(function() {
            $(".slider#" + v.id).slider("value", globalcoachscores[i]);
        }, 500 * i);
    });
    setTimeout(populateGraph, 500 * data.length);
}, 500);

---

似乎你需要一个发射器来帮助你

setTimeout(function() {
    var emitter = new SuperEmitter(),//Create new super emitter
        emittors = [];
    $.each(data, function(i, v) {
        emittors.push(v.id);//Collect all emittors that populateGraph() should wait
        setTimeout(function() {
            $(".slider#" + v.id).slider("value", globalcoachscores[i]);
            emitter.emit(v.id);//Emit emittor when one job is done
        }, 500 + (500 * i));
    });
    emitter.on(emittors,function(){
        populateGraph();
    });//Set event job after all the jobs are done
}, 500);

这是我的超级发射器构造函数：

// Super Emitter
/**
 * Create a super emitter
 *
 * @constructor
 * @param {String} name - The name of the emitter.
 * @author Maplemx(Maplemx@gmail.com)
 */
function SuperEmitter(name){
    var waitors = [],
        emittors = {};

    function tryEmittor(emittor,data){
        if (emittors[emittor]){
            data = mergeObjects(emittors[emittor],data);
        }
        for (var i = 0;i < waitors.length;i++){
            if (waitors[i]){
                var emittorIndex = waitors[i].wait.indexOf(emittor);
                if (emittorIndex > -1){
                    waitors[i].wait.splice(emittorIndex,1);
                    waitors[i].data = mergeObjects(waitors[i].data,data);
                }
                if (waitors[i].wait.length === 0){
                    waitors[i].func(waitors[i].data);
                    waitors[i] = undefined;
                }
            }
        }
    }
    function tryWaitors(waitorId){
        if (waitors[waitorId]){
            for (var emittor in emittors){
                var emittorIndex = waitors[waitorId].wait.indexOf(emittor);
                if (emittorIndex > -1){
                    waitors[waitorId].wait.splice(emittorIndex,1);
                    waitors[waitorId].data = mergeObjects(waitors[waitorId].data,emittors[emittor]);
                }
                if (waitors[waitorId].wait.length === 0){
                    waitors[waitorId].func(waitors[waitorId].data);
                    waitors[waitorId] = undefined;
                    break;
                }
            }
        }
    }

    /**
     * Set new function into wait list
     * 
     * @public
     * @param {Array|*} emittors - The emittor(s) that the function wait for.(If emittor is not an Array, will turn it to an Array)
     * @param {Function} func - The function todo when emittor is sent.
     * @param {Object} [data] - The data want to send to the function.
     */
    this.on = function on(emittors,func,data){
        if (!(emittors instanceof Array)){emittors = [emittors];}
        var waitorId = waitors.push({
            wait: emittors,
            func: func,
            data: data,
        }) - 1;
        tryWaitors(waitorId);
    }

    /**
     * Send an emittor
     *
     * @public
     * @param {*} emittor - The emittor to be sent.
     * @param {Object} [data] - The data want to send to the functions which are waiting for the emittor.(The data here have higher priority than the data given when functions are put into wait list.)
     * @param {Boolean} [stay=true] - Tell if you want the emittor stay in memory, so that functions which are put into wait list later than emittor which are sent can also be activated by those emittor. If "stay" is true, you have to "unemit" the emittor manual.
     */
    this.emit = function emit(emittor,data,stay){
        if (typeof(stay) === 'undefined'){stay = true;}
        if (stay){
            emittors[emittor] = data;
        }
        tryEmittor(emittor,data);
    }

    /**
     * Erase an emittor (If "stay" is set false when emittor is sent, you don't need to erase it, because the emittor was not saved in memory)
     *
     * @public
     * @param {*} emittor - The emittor to be erased.
     */
    this.unemit = function unemit(emittor){
        if (emittors[emittor]){
            delete emittors[emittor];
        }
    }
}

//超级发射器
/**
*创建一个超级发射器
*
*@constructor
*@param{String}name-发射器的名称。
*@作者Maplemx(Maplemx@gmail.com)
*/
函数超级发射器（名称）{
var waiters=[]，
发射体={}；
功能测试指示器（发射器、数据）{
if（发射器[发射器]）{
数据=合并对象（发射器[emitter]，数据）；
}
for（变量i=0；i-1）{
waitors[i].wait.splice（emitterIndex，1）；
waitors[i].data=mergeObjects（waitors[i].data，data）；
}
if（waitors[i].wait.length==0）{
waitors[i].func（waitors[i].data）；
侍者[i]=未定义；
}
}
}
}
函数tryWaitors（waitorId）{
if（服务员[服务员ID]）{
用于（发射器中的var发射器）{
var emitterIndex=waitors[waitorId].wait.indexOf（emitter）；
如果（发射指数>-1）{
waitors[waitorId].wait.splice（emitterIndex，1）；
waitors[waitorId].data=mergeObjects（waitors[waitorId].data，emitter[emitter]）；
}
if（waitors[waitorId].wait.length==0）{
waitors[waitorId].func（waitors[waitorId].data）；
waitors[waitorId]=未定义；
打破
}
}
}
}
/**
*将新函数设置到等待列表中
* 
*@公众
*@param{Array |*}emitters-函数等待的发射器。（如果emitter不是数组，则将其转换为数组）
*@param{Function}func-发送发射器时的函数todo。
*@param{Object}[data]-要发送到函数的数据。
*/
this.on=函数开启（发射器、函数、数据）{
如果（！（emitters instanceof Array））{emitters=[emitters]；}
var waitorId=waitors.push({
等等：发射者，
func:func，
数据：数据，
}) - 1;
服务员（服务员）；
}
/**
*发送发射器
*
*@公众
*@param{*}emitter-要发送的发射器。
*@param{Object}[data]-要发送给正在等待发射器的函数的数据。（此处的数据比函数放入等待列表时给出的数据具有更高的优先级。）
*@param{Boolean}[stay=true]-告诉您是否希望发射器保留在内存中，以便那些发射器也可以激活在发射器之后放入等待列表的函数。如果“stay”为true，则必须“unmit”发射器手册。
*/
this.emit=函数emit（emitter、data、stay）{
if（typeof（stay）=='undefined'）{stay=true；}
如果（留下）{
发射器[发射器]=数据；
}
tryEmittor（发射器、数据）；
}
/**
*擦除发射器（如果发送发射器时将“停留”设置为false，则不需要擦除它，因为发射器未保存在内存中）
*
*@公众
*@param{*}emitter-要擦除的发射器。
*/
this.unemit=函数unemit（emitter）{
if（发射器[发射器]）{
删除发射器[发射器]；
}
}
}

看来你需要一个发射器来帮助你

setTimeout(function() {
    var emitter = new SuperEmitter(),//Create new super emitter
        emittors = [];
    $.each(data, function(i, v) {
        emittors.push(v.id);//Collect all emittors that populateGraph() should wait
        setTimeout(function() {
            $(".slider#" + v.id).slider("value", globalcoachscores[i]);
            emitter.emit(v.id);//Emit emittor when one job is done
        }, 500 + (500 * i));
    });
    emitter.on(emittors,function(){
        populateGraph();
    });//Set event job after all the jobs are done
}, 500);

这是我的超级发射器构造函数：

// Super Emitter
/**
 * Create a super emitter
 *
 * @constructor
 * @param {String} name - The name of the emitter.
 * @author Maplemx(Maplemx@gmail.com)
 */
function SuperEmitter(name){
    var waitors = [],
        emittors = {};

    function tryEmittor(emittor,data){
        if (emittors[emittor]){
            data = mergeObjects(emittors[emittor],data);
        }
        for (var i = 0;i < waitors.length;i++){
            if (waitors[i]){
                var emittorIndex = waitors[i].wait.indexOf(emittor);
                if (emittorIndex > -1){
                    waitors[i].wait.splice(emittorIndex,1);
                    waitors[i].data = mergeObjects(waitors[i].data,data);
                }
                if (waitors[i].wait.length === 0){
                    waitors[i].func(waitors[i].data);
                    waitors[i] = undefined;
                }
            }
        }
    }
    function tryWaitors(waitorId){
        if (waitors[waitorId]){
            for (var emittor in emittors){
                var emittorIndex = waitors[waitorId].wait.indexOf(emittor);
                if (emittorIndex > -1){
                    waitors[waitorId].wait.splice(emittorIndex,1);
                    waitors[waitorId].data = mergeObjects(waitors[waitorId].data,emittors[emittor]);
                }
                if (waitors[waitorId].wait.length === 0){
                    waitors[waitorId].func(waitors[waitorId].data);
                    waitors[waitorId] = undefined;
                    break;
                }
            }
        }
    }

    /**
     * Set new function into wait list
     * 
     * @public
     * @param {Array|*} emittors - The emittor(s) that the function wait for.(If emittor is not an Array, will turn it to an Array)
     * @param {Function} func - The function todo when emittor is sent.
     * @param {Object} [data] - The data want to send to the function.
     */
    this.on = function on(emittors,func,data){
        if (!(emittors instanceof Array)){emittors = [emittors];}
        var waitorId = waitors.push({
            wait: emittors,
            func: func,
            data: data,
        }) - 1;
        tryWaitors(waitorId);
    }

    /**
     * Send an emittor
     *
     * @public
     * @param {*} emittor - The emittor to be sent.
     * @param {Object} [data] - The data want to send to the functions which are waiting for the emittor.(The data here have higher priority than the data given when functions are put into wait list.)
     * @param {Boolean} [stay=true] - Tell if you want the emittor stay in memory, so that functions which are put into wait list later than emittor which are sent can also be activated by those emittor. If "stay" is true, you have to "unemit" the emittor manual.
     */
    this.emit = function emit(emittor,data,stay){
        if (typeof(stay) === 'undefined'){stay = true;}
        if (stay){
            emittors[emittor] = data;
        }
        tryEmittor(emittor,data);
    }

    /**
     * Erase an emittor (If "stay" is set false when emittor is sent, you don't need to erase it, because the emittor was not saved in memory)
     *
     * @public
     * @param {*} emittor - The emittor to be erased.
     */
    this.unemit = function unemit(emittor){
        if (emittors[emittor]){
            delete emittors[emittor];
        }
    }
}

//超级发射器
/**
*创建一个超级发射器
*
*@constructor
*@param{String}name-发射器的名称。
*@作者Maplemx(Maplemx@gmail.com)
*/
函数超级发射器（名称）{
var waiters=[]，
发射体={}；
功能测试指示器（发射器、数据）{
if（发射器[发射器]）{
数据=合并对象（发射器[emitter]，数据）；
}
for（变量i=0；i-1）{
waitors[i].wait.splice（emitterIndex，1）；
waitors[i].data=mergeObjects（waitors[i].data，data）；
}
if（waitors[i].wait.length==0）{
waitors[i].func（waitors[i].data）；
侍者[i]=未定义；
}
}
}
}
函数tryWaitors（waitorId）{
if（服务员[服务员ID]）{
用于（发射器中的var发射器）{
var emitterIndex=waitors[waitorId].wait.indexOf（emitter）；
如果（发射指数>-1）{
waitors[waitorId].wait.splice（emitterIndex，1）；
waitors[waitorId].data=mergeObjects（waitors[waitorId].data，emitter[emitter]）；
}
if（waitors[waitorId].wait.length==0）{
waitors[waitorId].func（waitors[waitorId].data）；
服务员