Javascript 函数在订阅调用完成之前被调用

我正在从服务器获取数据，但在调用完成之前，函数被调用，返回一个空数组。我是RxJs新手，有人能帮我吗

getRows: (params) => {
      setTimeout(() => {
        const dataAfterSortingAndFiltering = this.sortAndFilter(audits.docs, params.sortModel, params.filterModel);
        const rowsThisPage = dataAfterSortingAndFiltering.slice(0, audits.items.end);
        let lastRow = -1;
        if (dataAfterSortingAndFiltering.length <= params.endRow) {
          lastRow = dataAfterSortingAndFiltering.length;
        }
        params.successCallback(rowsThisPage, lastRow);
      }, 3000);

filterData函数：

sortAndFilter(allOfTheData, sortModel, filterModel) {
  return this.sortData(sortModel, this.filterData(filterModel, allOfTheData));
}

filterData(filterModel, data) {
  const filterKeys = Object.keys(filterModel);
  const filterPresent = filterModel && Object.keys(filterModel).length > 0;
  if (!filterPresent) {
    return data;
  }
  const resultOfFilter = [];
  const filterParams = [];
  for (let i = 0; i < filterKeys.length; i++) {
    filterParams.push(`${filterKeys[i]}=${filterModel[filterKeys[i]].filter}`);
  }
  const params = filterParams.join('&');

  this.auditService.getColumnSearch(params).pipe(first()).subscribe((datas: any) => {
    resultOfFilter.push(...datas.docs);
  });
  return resultOfFilter;
}

sortData(sortModel, data) {
console.log('sortModel got called', sortModel);
console.log('data', data);
const sortPresent = sortModel && sortModel.length > 0;
if (!sortPresent) {
  return data;
}
const resultOfSort = data.slice();
resultOfSort.sort((a, b) => {
  for (let k = 0; k < sortModel.length; k++) {
    const sortColModel = sortModel[k];
    const valueA = a[sortColModel.colId];
    const valueB = b[sortColModel.colId];
    if (valueA == valueB) {
      continue;
    }
    const sortDirection = sortColModel.sort === 'asc' ? 1 : -1;
    if (valueA > valueB) {
      return sortDirection;
    } else {
      return sortDirection * -1;
    }
  }
  return 0;
});
return resultOfSort;

filterData（filterModel，数据）{
常量filterKeys=Object.keys（filterModel）；
常量filterPresent=filterModel&&Object.keys（filterModel）.length>0；
如果（！filterPresent）{
返回数据；
}
常量resultOfFilter=[]；
常量过滤器参数=[]；
for（设i=0；i{
resultofilter.push（…datas.docs）；
});
返回结果过滤器；
}

排序数据功能：

sortAndFilter(allOfTheData, sortModel, filterModel) {
  return this.sortData(sortModel, this.filterData(filterModel, allOfTheData));
}

filterData(filterModel, data) {
  const filterKeys = Object.keys(filterModel);
  const filterPresent = filterModel && Object.keys(filterModel).length > 0;
  if (!filterPresent) {
    return data;
  }
  const resultOfFilter = [];
  const filterParams = [];
  for (let i = 0; i < filterKeys.length; i++) {
    filterParams.push(`${filterKeys[i]}=${filterModel[filterKeys[i]].filter}`);
  }
  const params = filterParams.join('&');

  this.auditService.getColumnSearch(params).pipe(first()).subscribe((datas: any) => {
    resultOfFilter.push(...datas.docs);
  });
  return resultOfFilter;
}

sortData(sortModel, data) {
console.log('sortModel got called', sortModel);
console.log('data', data);
const sortPresent = sortModel && sortModel.length > 0;
if (!sortPresent) {
  return data;
}
const resultOfSort = data.slice();
resultOfSort.sort((a, b) => {
  for (let k = 0; k < sortModel.length; k++) {
    const sortColModel = sortModel[k];
    const valueA = a[sortColModel.colId];
    const valueB = b[sortColModel.colId];
    if (valueA == valueB) {
      continue;
    }
    const sortDirection = sortColModel.sort === 'asc' ? 1 : -1;
    if (valueA > valueB) {
      return sortDirection;
    } else {
      return sortDirection * -1;
    }
  }
  return 0;
});
return resultOfSort;

sortData（sortModel，数据）{
log（'调用了sortModel'，sortModel）；
console.log（'data'，data）；
const sortPresent=sortModel&&sortModel.length>0；
if（！sortPresent）{
返回数据；
}
const resultOfSort=data.slice（）；
resultOfSort.sort（（a，b）=>{
for（设k=0；k值B）{
返回排序方向；
}否则{
返回sortDirection*-1；
}
}
返回0；
});
返回结果排序；

}

---

在服务器调用完成之前，sortData函数将数据返回为[]。

利用

async

和

wait

export class AuditComp {

getRows(params) {
    setTimeout(() => {
        const dataAfterSortingAndFiltering = this.sortAndFilter(audits.docs, params.sortModel, params.filterModel);
        const rowsThisPage = dataAfterSortingAndFiltering.slice(0, audits.items.end);
        let lastRow = -1;
        if (dataAfterSortingAndFiltering.length <= params.endRow) {
            lastRow = dataAfterSortingAndFiltering.length;
        }
        params.successCallback(rowsThisPage, lastRow);
    }, 3000);
}

sortAndFilter(allOfTheData, sortModel, filterModel) {
    return this.sortData(sortModel, this.filterData(filterModel, allOfTheData));
}

sortData(sortModel, data) {
    console.log('sortModel got called', sortModel);
    console.log('data', data);
    const sortPresent = sortModel && sortModel.length > 0;
    if (!sortPresent) {
        return data;
    }
    const resultOfSort = data.slice();
    resultOfSort.sort((a, b) => {
        for (let k = 0; k < sortModel.length; k++) {
            const sortColModel = sortModel[k];
            const valueA = a[sortColModel.colId];
            const valueB = b[sortColModel.colId];
            if (valueA == valueB) {
                continue;
            }
            const sortDirection = sortColModel.sort === 'asc' ? 1 : -1;
            if (valueA > valueB) {
                return sortDirection;
            } else {
                return sortDirection * -1;
            }
        }
        return 0;
    });
    return resultOfSort;
}

async filterData(filterModel, data) {
    const filterKeys = Object.keys(filterModel);
    const filterPresent = filterModel && Object.keys(filterModel).length > 0;
    if (!filterPresent) {
        return data;
    }
    const resultOfFilter = [];
    const filterParams = [];
    for (let i = 0; i < filterKeys.length; i++) {
        filterParams.push(`${filterKeys[i]}=${filterModel[filterKeys[i]].filter}`);
    }
    const params = filterParams.join('&');

    await this.auditService.getColumnSearch(params).pipe(first()).toPromise()
    .then((datas: any) => {
        resultOfFilter.push(...datas.docs);
    });
    return resultOfFilter;
 }
}

导出类AuditComp{
getRows（参数）{
设置超时（（）=>{
const dataAfterSortingAndFiltering=this.sortAndFilter（audits.docs、params.sortModel、params.filterModel）；
const rowsThisPage=dataAfterSortingAndFiltering.slice（0，audits.items.end）；
设lastRow=-1；
如果（DataAfterOrtingandFiltering.0；
if（！sortPresent）{
返回数据；
}
const resultOfSort=data.slice（）；
resultOfSort.sort（（a，b）=>{
for（设k=0；k值B）{
返回排序方向；
}否则{
返回sortDirection*-1；
}
}
返回0；
});
返回结果排序；
}
异步filterData（filterModel，数据）{
常量filterKeys=Object.keys（filterModel）；
常量filterPresent=filterModel&&Object.keys（filterModel）.length>0；
如果（！filterPresent）{
返回数据；
}
常量resultOfFilter=[]；
常量过滤器参数=[]；
for（设i=0；i{
resultofilter.push（…datas.docs）；
});
返回结果过滤器；
}
}

---

如果遇到任何问题，请发表评论。

此处的信息可能会有所帮助：它解释异步操作如何与RxJS一起工作。sortAndFilter函数中调用了Wait，但没有asnc。如果我尝试为sortAndFilter函数设置async，则getRows函数DataAfterOrtingandFiltering中会显示一个名为ZoneAwarePromise的错误