Javascript promise如何处理嵌套函数调用

我有一段处理用户数据的代码。有许多嵌套函数调用：

f1(){
   f2(){
     ....
      fn{
        ///
      }
   }
}

fn

访问一个数据库，这意味着它是异步的，所以我以某种方式编写了它，它返回一个

promise

，在

fn-1

（调用

fn

的函数）中，我们使用

.then（）

来等待这个承诺。但现在看来，我必须在

fn-1

中做出承诺，以此类推。这是真的吗

var keyValueExists = function(key, value) {
    var query = {};
    query[key] = value;
    return new Promise(function(resolve, reject) {
        User.count(query, function(err, count) {
            if (err) {
                console.log(err);
                console.log('Problem with `.find` function');
                reject('Problem with `.find` function');
            } else {
                resolve(count !== 0);
            }
        });
    });
};

var addUser = function(newUserInfo) {
    var validationResult = Common._validateUserInfo(newUserInfo);
    if (validationResult.isOK) {
        keyValueExists('userName', newUserInfo.userName).then(function(userNameAlreadyExists) {
            if (userNameAlreadyExists) {
                validationResult = {
                    isOK: false,
                    reason: 'Username already exists',
                    infoWithBadInput: 'userName'
                }
            } else {
                var newUserId = generateUserId();
                //TODO: change it somehting more flexible. e.g. a predefined list of attributes to iterate over
                var newUser = {
                    'userName': newUserInfo.userName,
                    'password': newUserInfo.password,
                    'userId': newUserId,
                    'lastModificationTime': Common.getCurrentFormanttedTime(),
                    'createdTime': Common.getCurrentFormanttedTime()
                };
                var user = new User(newUser);
                user.save(function(err) {
                    if (err) {
                        console.log(err);
                        console.log('There is a problem saving the user info');
                    } else {
                        console.log('A new user added: ');
                        console.log(newUser);
                    }
                });
            }
            return validationResult;
        });
    } else {
        return validationResult;
    }
};

---

addUser返回未定义的

！

addUser

的调用者似乎没有等待它

这就是您在addUser函数中有效地执行的操作

var addUser = function(newUserInfo) {
    var validationResult = Common._validateUserInfo(newUserInfo);
    if (validationResult.isOK) {
        // ... do something asynchronously without returning anything
    } else {
        return validationResult;
    }
}

所以，是的，如果

validationResult.isOK

，adduser将返回undefined

这里有一些代码松散地基于您的代码，但它是独立运行的，以演示您应该如何做事情

var keyValueExists = function(key, value) {
    // pseudo junk, this simulates any username starting with b as existing
    return new Promise(function(resolve, reject) {
        resolve(value.substr(0,1) == 'b'); // barny and betty are dupes, fred and wilma are not
    });
}

var addUser = function (newUserInfo) {
    // var validationResult = Common._validateUserInfo(newUserInfo);
    var validationResult = {isOK: !!~(['fred', 'barny'].indexOf(newUserInfo.userName)), username: newUserInfo.userName}; // dummy code
    if (validationResult.isOK) {
        return keyValueExists('userName', newUserInfo.userName).then(function (userNameAlreadyExists) {
            if (userNameAlreadyExists) {
                validationResult = {
                    isOK: false,
                    reason: 'Username already exists',
                    infoWithBadInput: 'userName',
                    username: newUserInfo.userName
                }
            } else {
                // create new user here
                validationResult.userNumber = (Math.random() * 100000000) | 0;
            }
            return validationResult;
        });
    }
    else {
        // this function always needs to return a promise, even if it is resolved/rejected immediately
        return Promise.reject(validationResult);
    }
}

addUser({userName: 'fred'}).then(function (result) {
    console.log(result);
}).catch(function(err) {
    console.error(err);
});

addUser({userName: 'wilma'}).then(function (result) {
    console.log(result);
}).catch(function(err) {
    console.error(err);
});

addUser({userName: 'barny'}).then(function (result) {
    console.log(result);
}).catch(function(err) {
    console.error(err);
});

addUser({userName: 'betty'}).then(function (result) {
    console.log(result);
}).catch(function(err) {
    console.error(err);
});

---

这就是您在addUser函数中有效地执行的操作

var addUser = function(newUserInfo) {
    var validationResult = Common._validateUserInfo(newUserInfo);
    if (validationResult.isOK) {
        // ... do something asynchronously without returning anything
    } else {
        return validationResult;
    }
}

所以，是的，如果

validationResult.isOK

，adduser将返回undefined

这里有一些代码松散地基于您的代码，但它是独立运行的，以演示您应该如何做事情

var keyValueExists = function(key, value) {
    // pseudo junk, this simulates any username starting with b as existing
    return new Promise(function(resolve, reject) {
        resolve(value.substr(0,1) == 'b'); // barny and betty are dupes, fred and wilma are not
    });
}

var addUser = function (newUserInfo) {
    // var validationResult = Common._validateUserInfo(newUserInfo);
    var validationResult = {isOK: !!~(['fred', 'barny'].indexOf(newUserInfo.userName)), username: newUserInfo.userName}; // dummy code
    if (validationResult.isOK) {
        return keyValueExists('userName', newUserInfo.userName).then(function (userNameAlreadyExists) {
            if (userNameAlreadyExists) {
                validationResult = {
                    isOK: false,
                    reason: 'Username already exists',
                    infoWithBadInput: 'userName',
                    username: newUserInfo.userName
                }
            } else {
                // create new user here
                validationResult.userNumber = (Math.random() * 100000000) | 0;
            }
            return validationResult;
        });
    }
    else {
        // this function always needs to return a promise, even if it is resolved/rejected immediately
        return Promise.reject(validationResult);
    }
}

addUser({userName: 'fred'}).then(function (result) {
    console.log(result);
}).catch(function(err) {
    console.error(err);
});

addUser({userName: 'wilma'}).then(function (result) {
    console.log(result);
}).catch(function(err) {
    console.error(err);
});

addUser({userName: 'barny'}).then(function (result) {
    console.log(result);
}).catch(function(err) {
    console.error(err);
});

addUser({userName: 'betty'}).then(function (result) {
    console.log(result);
}).catch(function(err) {
    console.error(err);
});

---

这就是您在addUser函数中有效地执行的操作

var addUser = function(newUserInfo) {
    var validationResult = Common._validateUserInfo(newUserInfo);
    if (validationResult.isOK) {
        // ... do something asynchronously without returning anything
    } else {
        return validationResult;
    }
}

所以，是的，如果

validationResult.isOK

，adduser将返回undefined

这里有一些代码松散地基于您的代码，但它是独立运行的，以演示您应该如何做事情

var keyValueExists = function(key, value) {
    // pseudo junk, this simulates any username starting with b as existing
    return new Promise(function(resolve, reject) {
        resolve(value.substr(0,1) == 'b'); // barny and betty are dupes, fred and wilma are not
    });
}

var addUser = function (newUserInfo) {
    // var validationResult = Common._validateUserInfo(newUserInfo);
    var validationResult = {isOK: !!~(['fred', 'barny'].indexOf(newUserInfo.userName)), username: newUserInfo.userName}; // dummy code
    if (validationResult.isOK) {
        return keyValueExists('userName', newUserInfo.userName).then(function (userNameAlreadyExists) {
            if (userNameAlreadyExists) {
                validationResult = {
                    isOK: false,
                    reason: 'Username already exists',
                    infoWithBadInput: 'userName',
                    username: newUserInfo.userName
                }
            } else {
                // create new user here
                validationResult.userNumber = (Math.random() * 100000000) | 0;
            }
            return validationResult;
        });
    }
    else {
        // this function always needs to return a promise, even if it is resolved/rejected immediately
        return Promise.reject(validationResult);
    }
}

addUser({userName: 'fred'}).then(function (result) {
    console.log(result);
}).catch(function(err) {
    console.error(err);
});

addUser({userName: 'wilma'}).then(function (result) {
    console.log(result);
}).catch(function(err) {
    console.error(err);
});

addUser({userName: 'barny'}).then(function (result) {
    console.log(result);
}).catch(function(err) {
    console.error(err);
});

addUser({userName: 'betty'}).then(function (result) {
    console.log(result);
}).catch(function(err) {
    console.error(err);
});

---

这就是您在addUser函数中有效地执行的操作

var addUser = function(newUserInfo) {
    var validationResult = Common._validateUserInfo(newUserInfo);
    if (validationResult.isOK) {
        // ... do something asynchronously without returning anything
    } else {
        return validationResult;
    }
}

所以，是的，如果

validationResult.isOK

，adduser将返回undefined

这里有一些代码松散地基于您的代码，但它是独立运行的，以演示您应该如何做事情

var keyValueExists = function(key, value) {
    // pseudo junk, this simulates any username starting with b as existing
    return new Promise(function(resolve, reject) {
        resolve(value.substr(0,1) == 'b'); // barny and betty are dupes, fred and wilma are not
    });
}

var addUser = function (newUserInfo) {
    // var validationResult = Common._validateUserInfo(newUserInfo);
    var validationResult = {isOK: !!~(['fred', 'barny'].indexOf(newUserInfo.userName)), username: newUserInfo.userName}; // dummy code
    if (validationResult.isOK) {
        return keyValueExists('userName', newUserInfo.userName).then(function (userNameAlreadyExists) {
            if (userNameAlreadyExists) {
                validationResult = {
                    isOK: false,
                    reason: 'Username already exists',
                    infoWithBadInput: 'userName',
                    username: newUserInfo.userName
                }
            } else {
                // create new user here
                validationResult.userNumber = (Math.random() * 100000000) | 0;
            }
            return validationResult;
        });
    }
    else {
        // this function always needs to return a promise, even if it is resolved/rejected immediately
        return Promise.reject(validationResult);
    }
}

addUser({userName: 'fred'}).then(function (result) {
    console.log(result);
}).catch(function(err) {
    console.error(err);
});

addUser({userName: 'wilma'}).then(function (result) {
    console.log(result);
}).catch(function(err) {
    console.error(err);
});

addUser({userName: 'barny'}).then(function (result) {
    console.log(result);
}).catch(function(err) {
    console.error(err);
});

addUser({userName: 'betty'}).then(function (result) {
    console.log(result);
}).catch(function(err) {
    console.error(err);
});

---

---

好的，我在

中返回
validationResult
。然后

。是的，但是在if/else的if部分没有返回任何内容，你知道我是如何说“不返回任何内容”的吗。。。那是因为你在那块代码中返回了任何东西。老实说，我不明白。

然后

部分不是运行了吗？是的，它运行了，但是它的返回值没有做任何处理。因此在

添加用户

中，您没有定义任何

承诺

，调用它时如何将其视为承诺？嗯，我在

中返回
验证结果
。然后

。是的，您可以，但是在if/else的if部分你没有返回任何东西，你看到我说的“没有返回任何东西”了吗。。。那是因为你在那块代码中返回了任何东西。老实说，我不明白。

然后

部分不是运行了吗？是的，它运行了，但是它的返回值没有做任何处理。因此在

添加用户

中，您没有定义任何

承诺

，调用它时如何将其视为承诺？嗯，我在

中返回
验证结果
。然后

。是的，您可以，但是在if/else的if部分你没有返回任何东西，你看到我说的“没有返回任何东西”了吗。。。那是因为你在那块代码中返回了任何东西。老实说，我不明白。

然后

部分不是运行了吗？是的，它运行了，但是它的返回值没有做任何处理。因此在

添加用户

中，您没有定义任何

承诺

，调用它时如何将其视为承诺？嗯，我在

中返回
验证结果
。然后

。是的，您可以，但是在if/else的if部分你没有返回任何东西，你看到我说的“没有返回任何东西”了吗。。。那是因为你在那块代码中返回了任何东西。老实说，我不明白。

然后

部分不是运行了吗？是的，它运行了，但是它的返回值没有做任何处理。因此在

addUser

中，您没有定义任何

承诺

，调用它时如何将其视为承诺？是的，每个执行异步操作并使用承诺（即使只是有时）的函数都需要始终返回承诺。是的，每个执行异步操作并使用承诺（即使有时）的函数都需要始终返回承诺。是的，每个执行异步操作并使用承诺（即使有时）的函数都需要始终返回承诺。是的，每个执行异步操作并使用承诺（即使有时）的函数我们需要始终回报一个承诺。