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;
}

如何将结果返回承诺，我尽力了，但我不知道该怎么做，也许是因为我有两个可观察的内容，

Answer 1

你会宣传这两个可观察者，然后使用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中，但这不是最佳做法，因为它表明一段代码可能会在它可用之前尝试访问它：你总是会使用{{ 1}}获取结果的方法。

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个异步调用。因此，基于这些知识，还有一个单一的承诺解决方案。

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方法。

如何回报承诺？

3 个答案: