Javascript JS回调堆栈

如果我有一个

n

函数数组，所有函数都接受回调，那么如何创建一个队列/堆栈系统，其中数组中的第一个函数调用其回调中的下一个函数

到目前为止我的工作。。我被困在堆栈的逻辑上

function foo(callback){
  if(callback){
     console.log("calling callback")
     callback();
  }
}

let queue = [foo, foo, foo];

let stack = [];
let i = 0;


// should be equivalent to
foo(foo.bind(null, foo.bind(null, foo)));

---

我不确定这是否是最好的方法，但可以使用一个简单的for循环来完成，该循环运行的次数比数组大小少1次

function foo(callback){
  if(callback){
     console.log("calling callback")
     callback();
  }
}

let queue = [foo, foo, foo];
for(let i=0; i<queue.length-1; i++){
    queue[i](queue[i+1]);
}

函数foo（回调）{ 如果（回调）{ log（“调用回调”） 回调（）； } } 让队列=[foo，foo，foo]；

---

for（设i=0；i我不确定这是否是最好的方法，但可以使用一个简单的for循环来完成，该循环运行的次数比数组大小少1次

function foo(callback){
  if(callback){
     console.log("calling callback")
     callback();
  }
}

let queue = [foo, foo, foo];
for(let i=0; i<queue.length-1; i++){
    queue[i](queue[i+1]);
}

函数foo（回调）{ 如果（回调）{ log（“调用回调”） 回调（）； } } 让队列=[foo，foo，foo]；

---

对于（设i=0；i我想我理解这个问题，所以可能：

queue.forEach（（func，i）=>{
if（队列[i+1]）{
stack.push（func（队列[i+1]））
}
})

我想我理解这个问题，所以也许：

queue.forEach（（func，i）=>{
if（队列[i+1]）{
stack.push（func（队列[i+1]））
}
})

其中，

foo1

，

foo2

，

foo3

都是函数，它们都接受回调

结果将是（当

foo1

、

foo2

、

foo3

与示例中的

foo

函数相同时）：

---

解释 为了实现它，我必须从数组中的最后一个函数迭代到开始，在每次迭代中，我为下一次迭代中的函数构建下一个回调

reduceRight

的结果是一个函数，因为在每次迭代中，我都会构建一个新函数（这也是对数组中“previous”函数的回调）

其中，

foo1

，

foo2

，

foo3

都是函数，它们都接受回调

结果将是（当

foo1

、

foo2

、

foo3

与示例中的

foo

函数相同时）：

---

解释 为了实现它，我必须从数组中的最后一个函数迭代到开始，在每次迭代中，我为下一次迭代中的函数构建下一个回调

---

reduceRight

的结果是一个函数，因为在每次迭代中，我都会构建一个新函数（这也是数组中“先前”函数的回调）。

您可以使用

reduceRight

创建回调链

以下函数将队列作为其参数，并将链作为基于回调的可重用函数返回。调用该函数时，将执行该链：

函数foo（回调）{ 如果（回调）{ log（“调用回调”） 回调（）； } } const callbackChainer=queue=>callback=>queue.reduceRight（（acc，elem）=>elem.bind（null，acc，callback）（） 让队列=[foo，foo，foo]； const chain=callbackChainer（队列） 链（（）=>console.log（'done'）） /* 呼叫回调 呼叫回调 呼叫回调 完成 */ //重用链（无回调）： 链（） /* 呼叫回调 呼叫回调

---

*/您可以使用

reduceRight

创建回调链

以下函数将队列作为其参数，并将链作为基于回调的可重用函数返回。调用该函数时，将执行该链：

函数foo（回调）{ 如果（回调）{ log（“调用回调”） 回调（）； } } const callbackChainer=queue=>callback=>queue.reduceRight（（acc，elem）=>elem.bind（null，acc，callback）（） 让队列=[foo，foo，foo]； const chain=callbackChainer（队列） 链（（）=>console.log（'done'）） /* 呼叫回调 呼叫回调 呼叫回调 完成 */ //重用链（无回调）： 链（） /* 呼叫回调 呼叫回调

---

*/我相信你可以通过链接承诺干净利落地做你想做的事情，但这需要你重写函数来回报承诺。有趣的问题我相信你可以通过链接承诺干净利落地做你想做的事情，但这需要你重写函数来回报承诺。有趣的问题这并不是真的如果以前的函数是异步的，则不必使用它们（这可能是因为调用同步函数没有太多意义）。只需尝试将

callback（）

替换为

setTimeout（callback，1000）

即可查看结果……如果以前的函数是异步的，则不必等待（这可能是因为回调同步函数没有太多意义）。只需尝试将

callback（）

替换为

setTimeout（callback，1000）

即可查看结果。。。

calling callback
calling callback
calling callback
end