向对象传递它自己的数组承诺函数可以串联执行？

Question

我想实现以下目标：我有一个用一系列方法生成对象的类。每一个都可能是一个承诺。

从外部来看，应该可以选择这些方法并将它们组成一个数组，并要求同一对象串行执行它们。

代码应该是这样的(当然这不起作用，这就是我问的原因(：

class Car{
constructor(){}
fuctionA(input){
// do stuffs 
}
fuctionB(input){
// do stuffs 
}
fuctionC(input){
// do stuffs 
}
fuctionD(input){
// do stuffs 
}
executeArrayOfFuctions(array){
// execute each function in the array when the previous is resolved
}
}
const car1 = new Car();
const car2 = new Car();
const arrayOfFunctions = [functionA(input), functionC(input), functionA(input)];
car1.executeArrayOfFuctions(arrayOfFunctions);
car2.executeArrayOfFuctions(arrayOfFunctions);

EDIT：之所以我从对象外部传递任意顺序的函数，是因为我希望每次都能有这些函数的不同组合。比如编舞，你可以让很多舞者表演很多动作，但并不总是一样的，也不是每个人都一样。很抱歉，没有很好地指定。

编辑：对于@Akshay Bande，我很喜欢你如何将字符串引用传递给内部方法，但如果我真的尝试继续，并将我的方法定义为promise，并在1秒的超时时间内解决，它们会同时执行。我并没有真正理解Promise.resolve((部分。

class Car {
constructor() {}
functionA(input) {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log("A", input);
resolve();
}, 1000);
});
}
functionB(input) {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log("B", input);
resolve();
}, 1000);
});
}
functionC(input) {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log("C", input);
resolve();
}, 1000);
});
}
functionD(input) {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log("D", input);
resolve();
}, 1000);
});
}
executeArrayOfFuctions(array) {
let p = Promise.resolve();
array.forEach(val => {
p = p.then(() => {
this[val.functionName](val.arg);
return Promise.resolve();
});
});
}
}
const car1 = new Car();
const car2 = new Car();
const arrayOfFunctions = [
{ functionName: "functionA", arg: "1" },
{ functionName: "functionC", arg: "2" },
{ functionName: "functionA", arg: "3" }
];
car1.executeArrayOfFuctions(arrayOfFunctions);
//car2.executeArrayOfFuctions(arrayOfFunctions);

3编辑：感谢@AkshayBande的帮助，我认为这种方式可以奏效：

class Car {
constructor() {}
functionA(input) {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log("A", input);
resolve();
}, 1000);
});
}
functionB(input) {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log("B", input);
resolve();
}, 1000);
});
}
functionC(input) {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log("C", input);
resolve();
}, 1000);
});
}
functionD(input) {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log("D", input);
resolve();
}, 1000);
});
}
async executeArrayOfFuctions(array) {
for (let index = 0; index < array.length; index++) {
await this[array[index].functionName](array[index].arg);
}
}
}
const car1 = new Car();
const car2 = new Car();
const arrayOfFunctions = [
{ functionName: "functionA", arg: "1" },
{ functionName: "functionC", arg: "2" },
{ functionName: "functionA", arg: "3" }
];
car1.executeArrayOfFuctions(arrayOfFunctions);
//car2.executeArrayOfFuctions(arrayOfFunctions);

或者像这样：

class Car {
constructor() {}
functionsStack = [];
addFunctionA(input) {
this.functionsStack.push({ fn: "functionA", args: input });
return this;
}
addFunctionB(input) {
this.functionsStack.push({ fn: "functionB", args: input });
return this;
}
addFunctionC(input) {
this.functionsStack.push({ fn: "functionC", args: input });
return this;
}
addFunctionD(input) {
this.functionsStack.push({ fn: "functionD", args: input });
return this;
}
functionA(input) {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log("A", input);
resolve();
}, 1000);
});
}
functionB(input) {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log("B", input);
resolve();
}, 1000);
});
}
functionC(input) {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log("C", input);
resolve();
}, 1000);
});
}
functionD(input) {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log("D", input);
resolve();
}, 1000);
});
}
start() {
return new Promise((resolve, reject) => {
this.executeArrayOfFuctions(this.functionsStack).then(() => {
this.functionsStack = [];
resolve();
});
});
}
async executeArrayOfFuctions(array) {
for (let index = 0; index < array.length; index++) {
await this[array[index].fn](array[index].args);
}
}
}
const car1 = new Car();
const car2 = new Car();
car1
.addFunctionA("1")
.addFunctionB("2")
.addFunctionC("3")
.addFunctionA("5")
.addFunctionD("6")
.addFunctionB("7")
.start()
.then(() => {
console.log(car1.functionsStack);
});
// const arrayOfFunctions = [
//   { functionName: "functionA", arg: "1" },
//   { functionName: "functionC", arg: "2" },
//   { functionName: "functionA", arg: "3" }
// ];
// car1.executeArrayOfFuctions(arrayOfFunctions);
//car2.executeArrayOfFuctions(arrayOfFunctions);

Answer 1

不，不要让它变得那么复杂。使用async/await，您不需要四处传递函数。此外，Car对象不应该负责能够按顺序运行异步函数——如果你真的需要的话，这是一个简单的助手函数的工作

class Car {
constructor() {}
async functionA(input) {
// do stuffs 
}
async functionB(input) {
// do stuffs 
}
async functionC(input) {
// do stuffs 
}
async functionD(input) {
// do stuffs 
}
}
async function go(car) {
await car.functionA(input);
await car.functionC(input);
await car.functionA(input);
}
go(new Car()); // car 1
go(new Car()); // car 2

Answer 2

承诺是您所需要的。

class Car{
constructor(){}
functionA(input){
// do stuffs 
console.log(input);
}
functionB(input){
// do stuffs 
console.log(input);
}
functionC(input){
// do stuffs 
console.log(input);
}
functionD(input){
// do stuffs 
console.log(input);
}
executeArrayOfFuctions(array){
// execute each function in the array when the previous is resolved
let p = Promise.resolve();
array.forEach((val)=>{
p = p.then(()=>{
this[val.functionName](val.arg);			
return Promise.resolve();
})
})
}
}
const car1 = new Car();
const car2 = new Car();
const arrayOfFunctions = [ {functionName: 'functionA', arg:'1'},{functionName: 'functionC', arg:'2'}, {functionName: 'functionA', arg:'3'} ];
car1.executeArrayOfFuctions(arrayOfFunctions);
//car2.executeArrayOfFuctions(arrayOfFunctions);

Answer 3

根据添加到问题中的edit，如果您想在延迟一秒后执行函数，那么您可以使用此代码。

class Car {
constructor() {}
delay(time){
return new Promise(function(resolve,reject){
setTimeout(function(){
resolve();
},time)
})
}
functionA(input) {
this.delay(1000).then(()=>{
console.log('A');
})
}
functionB(input) {
this.delay(1000).then(()=>{
console.log('B');
})
}
functionC(input) {
this.delay(1000).then(()=>{
console.log('C');
})
}
functionD(input) {
this.delay(1000).then(()=>{
console.log('D');
})
}
executeArrayOfFuctions(array) {
let p = Promise.resolve();
array.forEach(val => {
p = p.then(() => {
this[val.functionName](val.arg);
return Promise.resolve();
});
});
}
}
const car1 = new Car();
const car2 = new Car();
const arrayOfFunctions = [
{ functionName: "functionA", arg: "1" },
{ functionName: "functionC", arg: "2" },
{ functionName: "functionA", arg: "3" }
];
car1.executeArrayOfFuctions(arrayOfFunctions);
//car2.executeArrayOfFuctions(arrayOfFunctions);