Javascript Promise.then（）但函数是异步运行的

我是Javascript新手，正在做一个爬虫程序，我已经创建了4个这样的承诺

var openConfig = new Promise((resolve, reject) => {
  fs.readFile('./config.json', (err, data) => {
    if (err) throw err;
    config = JSON.parse(data);
    client = new MsTranslator({
      client_id: config.translatorId,
      client_secret: config.translatorSecret
    }, true)
    resolve();
  })
})

var openFile = new Promise((resolve, reject) => {
  console.log('Opening file...')
  fs.readFile('./writing/writing.json', (err, data) => {
    if (err) throw err;
    writing = JSON.parse(data);
    console.log('Done parsing file');
    resolve();
  })
})

var ask = new Promise((resolve, reject) => {
  var rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  })
  rl.question('Which lesson do you want to add? ', (ans) => {
    lessonId = ans;
    rl.close();
    resolve();
  })
})

var createLesson = new Promise((resolve, reject) => {
  console.log('Now processing lesson ' + lessonId);
})

那就称第一个承诺为

openConfig
  .then(() => {
    return openFile;
  })
  .then(() => {
    return ask;
  })
  .then(() => {
    return createLesson;
  })

但当我运行时，控制台显示

Opening file...
Which lesson do you want to add? Now processing lesson undefined
Done parsing file

我理解为我的承诺是错误的，我的函数是异步运行的。你能帮我修一下吗

谢谢。

承诺不是“被要求的”。在

then

链中，您只按顺序等待它们-但在创建承诺时任务已经开始。如果要对操作进行排序，请将它们放入函数中

顺便说一句，您的代码包含多个典型错误，并且始终处于尽可能低的水平：

function openFile(path) {
  return new Promise((resolve, reject) => {
    fs.readFile('./config.json', (err, data) => {
      if (err) reject(err); // never `throw err` in non-promise callbacks!
      else resolve(data);
    });
  });
}
function openJSON(path) {
  return openFile(path).then(JSON.parse);
}
function openConfig(path) {
  return openJSON(path).then(config =>
    new MsTranslator({
      client_id: config.translatorId,
      client_secret: config.translatorSecret
    }, true)
  )
}
function ask(question) {
  return new Promise((resolve, reject) => {
    var rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout
    })
    rl.question(question, ans => {
      rl.close();
      resolve(ans); // always resolve to *something*
    });
  });
}

readConfig('./config.json')
.then(client => {
  console.log('Opening file...')
  return openJSON('./writing/writing.json');
})
.then(writing => {
  console.log('Done parsing file');
  return ask('Which lesson do you want to add? ');
})
.then(lessonId => {
  console.log('Now processing lesson ' + lessonId);
});

承诺不是“被称为”的。在

then

链中，您只按顺序等待它们-但在创建承诺时任务已经开始。如果要对操作进行排序，请将它们放入函数中

顺便说一句，您的代码包含多个典型错误，并且始终处于尽可能低的水平：

function openFile(path) {
  return new Promise((resolve, reject) => {
    fs.readFile('./config.json', (err, data) => {
      if (err) reject(err); // never `throw err` in non-promise callbacks!
      else resolve(data);
    });
  });
}
function openJSON(path) {
  return openFile(path).then(JSON.parse);
}
function openConfig(path) {
  return openJSON(path).then(config =>
    new MsTranslator({
      client_id: config.translatorId,
      client_secret: config.translatorSecret
    }, true)
  )
}
function ask(question) {
  return new Promise((resolve, reject) => {
    var rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout
    })
    rl.question(question, ans => {
      rl.close();
      resolve(ans); // always resolve to *something*
    });
  });
}

readConfig('./config.json')
.then(client => {
  console.log('Opening file...')
  return openJSON('./writing/writing.json');
})
.then(writing => {
  console.log('Done parsing file');
  return ask('Which lesson do you want to add? ');
})
.then(lessonId => {
  console.log('Now processing lesson ' + lessonId);
});

---

您不应该给变量分配新的承诺（这些承诺在创建后立即运行），而应该将它们包装到函数中，这些函数反过来会返回一个新的承诺

为了帮助您理解，这里有一个简化的示例：

function p1 (data) {
    return new Promise(function (resolve, reject) {
        resolve(Object.assign(data, {a:1}));
    });
}

function p2 (data) {
    return new Promise(function (resolve, reject) {
        resolve(Object.assign(data, {b:2}));
    });
}

function p3 (data) {
    return new Promise(function (resolve, reject) {
        resolve(Object.assign(data, {c:3}));
    });
}

p1({z:0})
.then(p2)
.then(p3)
.then((data)=>console.log(data))

这将导致

{z:0，a:1，b:2，c:3}

如果您想尝试一下以上内容，请参见此处：

---

---

另一方面，如果您使用的是承诺，您还应该在final

.catch（）

中处理链中的错误，而不是在中途同步抛出。这就是

拒绝
回调的目的
 您不应该给变量分配新的承诺（这些承诺在创建后立即运行），而应该将它们包装到函数中，这些函数反过来会返回新的承诺

为了帮助您理解，这里有一个简化的示例：

function p1 (data) {
    return new Promise(function (resolve, reject) {
        resolve(Object.assign(data, {a:1}));
    });
}

function p2 (data) {
    return new Promise(function (resolve, reject) {
        resolve(Object.assign(data, {b:2}));
    });
}

function p3 (data) {
    return new Promise(function (resolve, reject) {
        resolve(Object.assign(data, {c:3}));
    });
}

p1({z:0})
.then(p2)
.then(p3)
.then((data)=>console.log(data))

这将导致
{z:0，a:1，b:2，c:3}

如果您想尝试一下以上内容，请参见此处：


另一方面，如果您使用的是承诺，您还应该在final
.catch（）
中处理链中的错误，而不是在中途同步抛出。这就是
拒绝
回调的目的
 你在预先创建承诺，你应该创建返回承诺的函数。你在预先创建承诺，你应该创建返回承诺的函数。