Javascript 等待来自不同文件的axios服务器响应

我有一个循环。在每一轮中，我都需要将问题数据添加到MongoDB数据库中。这个很好用。然而，我想在循环进入下一轮之前获得新插入问题的id。这就是我的问题所在。服务器返回_id和循环到下一轮需要一定的时间。因此，我需要一种等待服务器响应的方法，并且只有在该响应之后才能进入下一轮循环

这是我的后端代码：

router.post("/createQuestion", (req, res) => {
  const newQuestion = new Question({
    description: req.body.description,
    type: req.body.type, 
    model: req.body.model
  });
  newQuestion.save().then(question => res.json(question._id))
  .catch(err => console.log(err));
});

这是我的axios函数，它位于单独的文件中，并导入到类中：

export const createQuestion = (questionData) => dispatch => {
  axios.post("/api/scorecard/createQuestion", questionData)
    .then(res => {
      return res.data;
    }).catch(err =>
         console.log("Error adding a question")
    );
};

这是我的类中的代码：

JSON.parse(localStorage.getItem(i)).map(question => {
      const newQuestion = {
        description: question.description,
        type: question.questionType,
        model: this.props.model
      }
       const question_id =  this.props.createQuestion(newQuestion);
       console.log(question_id);
}

---

控制台显示未定义。

我遇到了相同的问题，我通过将数组问题发送到节点并逐个阅读问题并使用下一个问题ID更新来解决相同的问题

router.post("/createQuestion", (req, res) => {
let d =[questionarray];
let i = 0;
        let length = d.length;
        var result = [];
        try {
            const timeoutPromise = (timeout) => new Promise((resolve) => setTimeout(resolve, timeout));
            for (i = 0; i < length; i++) {
                await timeoutPromise(1000);   // 1000 = 1 second
                let CAT_ID = parseInt(d[i].CAT_ID);
                let TOPIC_ID = parseInt(d[i].TOPIC_ID);
                let Q_DESC = (d[i].Q_DESC);
                let OPT_1 = (d[i].OPT_1);
                let OPT_2 = (d[i].OPT_2);
                let OPT_3 = (d[i].OPT_3);
                let OPT_4 = (d[i].OPT_4);
                let ANS_ID = (d[i].ANS_ID);
                let TAGS = (d[i].TAGS);
                let HINT = (d[i].HINT);
                let LEVEL = d[i].LEVEL;
                let SRNO = d[i].SrNo;
                let qid;

                const savemyData = async (data) => {
                    return await data.save()

                }
                var myResult = await Question.find({ TOPIC_ID: TOPIC_ID }).countDocuments(function (err, count) {
                    if (err) {
                        console.log(err);
                    }
                    else {
                        if (count === 0) {
                            qid = TOPIC_ID + '' + 10001;
                            const newQuestion = new Question({
                                Q_ID: qid,
                                CAT_ID: CAT_ID,
                                TOPIC_ID: TOPIC_ID,
                                Q_ID: qid,
                                Q_DESC: Q_DESC,
                                OPT_1: OPT_1,
                                OPT_2: OPT_2,
                                OPT_3: OPT_3,
                                OPT_4: OPT_4,
                                ANS_ID: ANS_ID,
                                HINT: HINT,
                                TAGS: TAGS,
                                LEVEL: LEVEL,
                                Q_IMAGE: ''
                            })

                            await savemyData(newQuestion)
                                .then(result => { return true })
                                .catch(err => { return false });
                            //`${SRNO} is added successfully`
                            //`${SRNO} is Failed`

                        }

                        else if (count > 0) {
                            //   console.log(count)
                            Question.find({ TOPIC_ID: TOPIC_ID }).sort({ Q_ID: -1 }).limit(1)
                                .then(question => {
                                    qid = question[0].Q_ID + 1;
                                    const newQuestion = new Question({
                                        Q_ID: qid,
                                        CAT_ID: CAT_ID,
                                        TOPIC_ID: TOPIC_ID,
                                        Q_ID: qid,
                                        Q_DESC: Q_DESC,
                                        OPT_1: OPT_1,
                                        OPT_2: OPT_2,
                                        OPT_3: OPT_3,
                                        OPT_4: OPT_4,
                                        ANS_ID: ANS_ID,
                                        HINT: HINT,
                                        TAGS: TAGS,
                                        LEVEL: LEVEL,
                                        Q_IMAGE: ''
                                    })
                                    await savemyData(newQuestion)
                                        .then(result => { return true })
                                        .catch(err => { return false });

                                })
                                .catch(err => console.log(err));
                        }
                    }
                });
                if (myResult)
                    result.push(`${SRNO} is added successfully`);
                else
                    result.push(`${SRNO} is Failed`);
            }
            //      console.log(result)
            return res.json(result);
        }
        catch (err) {
            //res.status(404).json({ success: false })
            console.log(err)
        }
});

router.post（“/createQuestion”，（req，res）=>{
设d=[questionarray]；
设i=0；
设长度=d.长度；
var结果=[]；
试一试{
const timeoutPromise=（timeout）=>newpromise（（resolve）=>setTimeout（resolve，timeout））；
对于（i=0；i{
返回等待数据。保存（）
}
var myResult=wait Question.find（{TOPIC\u ID:TOPIC\u ID}）.countDocuments（函数（err，count）{
如果（错误）{
控制台日志（err）；
}
否则{
如果（计数==0）{
qid=主题ID+“”+10001；
const newQuestion=新问题({
Q_ID:qid，
猫号：猫号，
主题ID：主题ID，
Q_ID:qid，
Q_DESC:Q_DESC，
选项1：选项1，
OPT_2:OPT_2，
选项3：选项3，
选项4：选项4，
ANSU ID:ANSU ID，
提示：提示，
标签：标签，
级别:级别,，
Q_图像：“”
})
等待savemyData（新问题）
.then（结果=>{return true}）
.catch（err=>{return false}）；
//`${SRNO}已成功添加`
//`${SRNO}失败`
}
否则，如果（计数>0）{
//console.log（计数）
问题.查找（{TOPIC\u ID:TOPIC\u ID}）.排序（{Q\u ID:-1}）.限制（1）
.然后（问题=>{
qid=问题[0]。Q_ID+1；
const newQuestion=新问题({
Q_ID:qid，
猫号：猫号，
主题ID：主题ID，
Q_ID:qid，
Q_DESC:Q_DESC，
选项1：选项1，
OPT_2:OPT_2，
选项3：选项3，
选项4：选项4，
ANSU ID:ANSU ID，
提示：提示，
标签：标签，
级别:级别,，
Q_图像：“”
})
等待savemyData（新问题）
.then（结果=>{return true}）
.catch（err=>{return false}）；
})
.catch（err=>console.log（err））；
}
}
});
如果（我的结果）
推送（`${SRNO}已成功添加`）；
其他的
推送（`${SRNO}失败`）；
}
//console.log（结果）
返回res.json（结果）；
}
捕捉（错误）{
//res.status（404）.json（{success:false}）
console.log（错误）
}
});

首先，您的函数

createQuestion

不返回值，因此分配给question\u id总是未定义的。无论如何，由于您的

createQuestion

函数中有一个分派，我假设您使用的是

redux

，因此我建议您使用

redux thnk

，将获取新操作逻辑拆分为thunk操作，并使用

redux

状态中的questionID值，而不是从

createQuestion

返回值。在你的课堂上，你可以监听

questionID

的变化，如果发生这种情况，发送下一个问题的保存

我已经编辑了我的代码，所以我的函数createQuestion（）现在有一个返回值。你能告诉我怎么做吗