如何兑现承诺？

Question

我有一个函数

parseJobs(userId: string) {
    this.getLikedJobs(userId).subscribe(result => {
        result.map(key =>{
            let rows = {
                name : (key as any).jobsUser.firstName,
                jobType: 'Liked'
            }
            let job = {...rows,...(key as any).jobPosting};
            this.result.push(job);
        });
    });

    this.getSavedJobs(userId).subscribe(result => {
        result.map(key =>{
            let rows = {
                name : (key as any).jobsUser.firstName,
                jobType: 'Saved'
            }
            let job = {...rows,...(key as any).jobPosting};
            this.result.push(job);
        });
    });
    return this.result;
}

如何将结果返回到promise，我尽力了，但我不知道该怎么做，可能是因为我有两个observable，

Answer 1

你会承诺两个 observables，然后使用 Promise.all 来获得一个承诺，当一切都完成时：

parseJobs(userId: string) {
    // Create a promise
    const p1 = new Promise(resolve => {
        this.getLikedJobs(userId).subscribe(result => {
            // Resolve with the modified array
            resolve(result.map(key =>{
                let rows = {
                    name : (key as any).jobsUser.firstName,
                    jobType: 'Liked'
                }
                let job = {...rows,...(key as any).jobPosting};
                // In a map, you want to return:
                return job;
            }));
        });
    });
    // Same here:
    const p2 = new Promise(resolve => {
        this.getSavedJobs(userId).subscribe(result => {
            resolve(result.map(key =>{
                let rows = {
                    name : (key as any).jobsUser.firstName,
                    jobType: 'Saved'
                }
                let job = {...rows,...(key as any).jobPosting};
                return job;
            }));
        });
    });
    // Return a promise that will fulfill when both promises fulfill
    //    and concatenate the results
    return Promise.all([p1, p2]).then(result => [].concat(...result));
}

现在您不将结果存储在 this.result 中，而是将其设为承诺值，您将得到如下结果：

parseJobs(1).then(result =>
    console.log(result);
});

您当然仍然可以将结果存储在 this.result 中，但这不是最佳实践，因为它表明一段代码可能会在它可用之前尝试访问它：您将始终使用 then 方法得到结果。

Answer 2

也许你需要这样的东西：

parseJobs(userId: string): Promise<any> {
  let res: Function;
  const resPromise = new Promise((resolve: Function) => {
    // passing resolve function to upper scope
    res = resolve;
  });
  this.getLikedJobs(userId).subscribe(result => {
    ...
    // resolving result promise
    res(result);
  });
  ...
  // unresolved
  return resPromise;
}  

Answer 3

您有 2 个异步调用。所以也有基于这些知识的单一 promise 解决方案。

parseJobs(userId: string) =>
  new Promise(resolve => {

    let result = [];
    const done = (job) => {
      result.push(job);
      if(result.length === 2) {
        resolve(result);
      }
    }

    this.getLikedJobs(userId).subscribe(result => {
      result.map(key =>{
        let rows = {
            name : (key as any).jobsUser.firstName,
            jobType: 'Liked'
        }
        let job = {...rows,...(key as any).jobPosting};
        done(job);
      });
    });

    this.getSavedJobs(userId).subscribe(result => {
      result.map(key =>{
        let rows = {
            name : (key as any).jobsUser.firstName,
            jobType: 'Saved'
        }
        let job = {...rows,...(key as any).jobPosting};
        done(job);
      });
    });

  });

你也可以看看Promise.all方法。