TLDR

Question

我有一个函数以线性方式回调类中的其他函数。

async runTask() {
    debug('runTask');
    debug(this.taskData);

    try {
      // Short circuit for testing
      if (process.env.TASKTIMER) {
        return setTimeout(() => {
          this.taskComplete();
        }, process.env.TASKTIMER);
      }

      // Setup project folder & Git Clone
      await this.pullPackageWait();

      // Create input and output directory
      await this.mkIODirWait();

      // Store task data as json
      await this.writeTaskDataJSONWait();

      // Download Inputs From Amazon
      await this.downloadInputsWait();

      // Link Input files
      await this.linkInputsWait();

      // Download Resources From Amazon
      await this.downloadResourcesWait();

      // Relax permission on tmp directory
      await this.chmodTaskDir();

      // Destroys the job after timeout
      await this.jobTimeout();

      // Determine Handler
      console.log(this.taskData.handler);
      await this.initHandler();
      await this._handler.startJob();
    } catch (err) {
      this.logger.error(err);
      return this.taskError();
    }

我正在尝试按照this的答案将函数调用转换为函数数组。重构后，我的功能如下所示：

 async runTask() {
    debug('runTask');
    debug(this.taskData);

    try {
      // Short circuit for testing
      if (process.env.TASKTIMER) {
        return setTimeout(() => {
          this.taskComplete();
        }, process.env.TASKTIMER);
      }

      let currentFunction = 0;
      const functionsToRun = [
        this.pullPackageWait,
        this.mkIODirWait,
        this.writeTaskDataJSONWait,
        this.downloadInputsWait,
        this.linkInputsWait,
        this.downloadResourcesWait,
        this.chmodTaskDir,
        this.jobTimeout,
      ];

      debug('Before The Loop');
      for (currentFunction; currentFunction < functionsToRun.length; currentFunction++) {
        debug('In The Loop');
        await functionsToRun[currentFunction]();
        console.log('Writing to the file');
        await this.writeState();
      }

      // Determine Handler
      console.log(this.taskData.handler);
      await this.initHandler();
      await this._handler.startJob();
    } catch (err) {
      this.logger.error(err);
      return this.taskError();
    }

使用原始代码，整个程序可以正常运行，但是在转换之后，它似乎在第一个回调处中断。我在转换过程中是否犯了错误？

Answer 1

重构代码中最有可能的错误源是错误的this绑定。请注意以下内容：

this.foo();

不同于：

let foo = this.foo;
foo();

调用this.foo()时，this中的foo()值将与this相同。调用this.foo时，foo()中的this值将是foo()或全局对象，具体取决于您是否启用了严格模式。

有关undefined工作原理的完整说明，请参见我对另一个问题的回答：How does the "this" keyword in Javascript act within an object literal?

TLDR

解决方案是将函数名称存储为字符串：

this

然后将每个函数调用为：

const functionsToRun = [
    'pullPackageWait',
    'mkIODirWait',
    'writeTaskDataJSONWait',
    'downloadInputsWait',
    'linkInputsWait',
    'downloadResourcesWait',
    'chmodTaskDir',
    'jobTimeout',
];

或await this[functionsToRun[index]]();函数：

.bind()

并以您目前的方式称呼他们：

const functionsToRun = [
    this.pullPackageWait.bind(this),
    this.mkIODirWait.bind(this),
    this.writeTaskDataJSONWait.bind(this),
    this.downloadInputsWait.bind(this),
    this.linkInputsWait.bind(this),
    this.downloadResourcesWait.bind(this),
    this.chmodTaskDir.bind(this),
    this.jobTimeout.bind(this),
];

NodeJS将顺序函数调用转换为函数数组

1 个答案:

TLDR