Javascript 使用队列中第二个函数中第一个函数的返回数据

我有一个类，它管理一个函数队列，并提供一个简单的API

manager.Queue（{data:foo}，function，callback）

，然后在我的渲染器进程中，单击一个按钮，我调用它来对各种预定义函数进行排队，但这里的问题是最后一个函数可以使用第一个函数返回的数据

我最初尝试的内容：
首先，我将返回数据存储在回调中的变量

results:any[]=[]

中，然后当我想对第二个任务进行排队时，我只需

manager.queue（{data:results[0]，function2，callback）；

现在，这显然不起作用，因为JavaScript是按值传递的，

结果[0]

是在队列时传递的，而不是在执行函数时从数组中读取值

当前实施：
当前我延迟排队，直到排队函数完成。 i、 e.我创建了一个任务数组，它调用

manager.queue….

而不是直接排队，在我的回调函数

tasks.shift（）（）//中，它将函数添加到队列中

然后

wait manager.start（）

，因为管理器队列中始终只有一个项目，所以它会停止，执行回调，然后将另一个函数添加到队列中，并重新启动管理器以使函数出列

这方面的问题：这很好，但它违背了管理器类的观点，调用类不必跟踪任务和结果，只需对任务进行排队，并指示管理器使用第二个成功函数的结果

现在，理论已经足够了，需要编写一些代码：）

Manager.ts  

interface TaskFunctionArguments<JobData>
{
    data: JobData
};

export type TaskFunction<JobData, ReturnData> = (
    arg: TaskFunctionArguments<JobData>
) => Promise<ReturnData>;

export default class Manager<JobData = any, ReturnData = any>
{
    private jobQueue: Queue<Job<JobData, ReturnData>> = new Queue<Job<JobData, ReturnData>>();

    public queue(data: JobData, task: TaskFunction<JobData, ReturnData>, callbacks?: ExecuteCallbacks)
    {
        const job = new Job<JobData, ReturnData>(data, task, callbacks);
        this.jobQueue.push(job);
    }

    public async start()
    {
        let job;
        let result: any;
        let errorState: Error | null = null;
        while (this.jobQueue.size())
        {
            job = this.jobQueue.shift();
            try
            {
                result = await job.taskFunction({ data: job.data as JobData });
            }
            catch (err)
            {
                errorState = err;
            }

            if (errorState)
            {
                job.executeCallbacks.reject(errorState || new Error("asf"));
                return { type: "error", error: errorState || new Error("asf") };
            }
            else
            {
                job.executeCallbacks.resolve(result);
                // return { type: "success", data: result };
            }
        }
        return { type: "success", data: result };
    }
}

var tasks: ((value?: any) => void)[] = [];
var results: any[] = [];

//callback code
async (r) => 
{
    results.push(r);
    if (tasks.length)
    {
       tasks.shift()();
       let result = await manager.start();
       console.log("result: ", result);
    }
}

//when I click want to add a function
tasks.push(() => 
{
   manager.queue({data:foo}, function, callback);
};

//to queue the second task
tasks.push(() =>
{
   //mostly result[0] is parsed like: result[0] as MyInterface
   manager.queue({data: results[0]}, function2, callback});
};

//When I want to start the queue
tasks.shift()();
await manager.start();