Question

在我的有角度的应用程序中，我需要将数据存储到在初始阶段为空的数组。

示例：

someFunction() {

 let array = [];

 console.log("step 1");

 this.service.getRest(url).subscribe(result => { 

   result.data.forEach(element => {

   console.log("step 2");

    array.push(element); // Pushing all the objects comes from res.data     

   });

   console.log("step 3");

 });

   console.log("step 4");

}

在这里，我已按步骤顺序列出了console.log()。

调用函数时的顺序

步骤1 第4步 第2步步骤3

在第1步之后，第4步调用，然后在第2步之后。因此，如果i console.log(array)代替第4步，它将再次给出空数组。

但是它代替了step 2 and 3的值。从服务中出来的值是空的。

因此，我总是在array中得到空值。

即使有一段时间的服务调用和响应返回，也请帮助我将数据存储到变量中。

尝试修改代码很长时间，但无法正常工作。

修改：

我在下面提供了我目前正在使用的 stackblitz 链接https://stackblitz.com/edit/angular-x4a5b6-ng8m4z

实时应用程序

在此演示中，看到文件https://stackblitz.com/edit/angular-x4a5b6-ng8m4z?file=src%2Fapp%2Fquestion.service.ts

我在哪里使用服务呼叫。如果我放async getQuestions() {}，则错误为questions.forEach of undefined

在 service.ts

中

    jsonData: any = [
    {
      "elementType": "textbox",
      "class": "col-12 col-md-4 col-sm-12",
      "key": "project_name",
      "label": "Project Name",
      "type": "text",
      "value": "",
      "required": false,
      "minlength": 3,
      "maxlength": 20,
      "order": 1
    },
    {
      "elementType": "textbox",
      "class": "col-12 col-md-4 col-sm-12",
      "key": "project_desc",
      "label": "Project Description",
      "type": "text",
      "value": "",
      "required": true,
      "order": 2
    },
    {
      "elementType": "dropdown",
      "key": 'project',
      "label": 'Project Rating',
      "options": [],
      "order": 3
    }
  ];

  getQuestions() {

    let questions: any = [];

    //In the above JSON having empty values in "options": [],

    this.jsonData.forEach(element => {
      if (element.elementType === 'textbox') {
        questions.push(new TextboxQuestion(element));
      } else if (element.elementType === 'dropdown') {

        //Need to push the data that comes from service result (res.data) to the options

        questions.push(new DropdownQuestion(element));

        console.log("step 1");

      //The service which  i call in real time..

        // return this.http.get(element.optionsUrl).subscribe(res => {

        //res.data has the following array, Using foreach pushing to elements.options.

      //   [
      //   { "key": 'average', "value": 'Average' },
      //   { "key": 'good', "value": 'Good' },
      //   { "key": 'great', "value": 'Great' }
      // ],

        // res.data.forEach(result => {
          console.log("step 2");
        //   element.options.push(result);
        // });
        // console.log(element.options) give values as the above [
      //   { "key": 'average'...
        console.log("step 3");
                // console.log(element.options) give values as the above [
      //   { "key": 'average'...
        // });
        console.log("step 4");
      //But here console.log(element.options) gives empty 
      }
    });

    return questions.sort((a, b) => a.order - b.order);
  }

Answer 1

第一步是将函数getQuestion转换为Observable。

为什么有必要？因为您需要调用this.http.get（element.optionsUrl）。这是异步的（所有http.get返回均可观察到）。并且您需要等待被调用完成才能获取数据。可以观察到的好处是，在“订阅功能”内部您拥有数据。

因此，我们必须考虑“服务返回可观察的东西，组件订阅了服务”。

好吧，让这个问题。主要问题是我们需要多次调用http.get。众所周知，对http的所有调用都是异步的，因此如何确保我们拥有所有数据（请记住，只有数据进入了subscribe函数。由于我们不希望有多个subscribe-最好是没有订阅服务，我们需要使用forkJoin。ForkJoin需要一个调用数组，并返回结果数组。

因此，首先创建一个可观察数组，然后返回该可观察数组。稍等片刻！我们不想返回带有选项的数组，我们想要一个可观察的问题。为此，尽管返回了observable数组，我们仍返回了使用此observable数组的对象。我在响应的底部放了一个简单的例子

getQuestions():Observable<any[]> { //See that return an Observable

    let questions: any = [];

    //First we create an array of observables
    let observables:Observable<any[]>[]=[];
    this.jsonData.forEach(element => {
      if (element.elementType === 'dropdown') {
        observables.push(this.http.get(element.optionsUrl))
      }
    }
    //if only want return a forkjoin of observables we make
    //return forkJoin(observables)
    //But we want return an Observable of questions, so we use pipe(map)) to transform the response

    return forkJoin(observables).pipe(map(res=>
    {  //here we have and array like-yes is an array of array-
       //with so many element as "dowpdown" we have in question
       // res=[
       //      [{ "key": 'average', "value": 'Average' },...],
       //        [{ "key": 'car', "value": 'dog },...],
       // ],
       //as we have yet all the options, we can fullfit our questions
       let index=0;
       this.jsonData.forEach((element) => { //see that have two argument, the 
                                                  //element and the "index"
          if (element.elementType === 'textbox') {
             questions.push(new TextboxQuestion(element));
          } else if (element.elementType === 'dropdown') {
               //here we give value to element.options
               element.option=res[index];
               questions.push(new DropdownQuestion(element));
               index++;
          }
       })
       return question
    }))
 }

注意：关于如何使用“ of”转换返回可观察值的函数：简单示例

import { of} from 'rxjs';

getData():any
{
   let data={property:"valor"}
   return data;
}
getObservableData():Observable<any>
{
   let data={property:"observable"}
   return of(data);
}
getHttpData():Observable<any>
{
    return this.httpClient.get("myUrl");
}
//A component can be call this functions as
let data=myService.getData();
console.log(data)
//See that the call to a getHttpData is equal than the call to getObservableData
//It is the reason becaouse we can "simulate" a httpClient.get call using "of" 
myService.getObservableData().subscribe(res=>{
     console.log(res);
}
myService.getHttpData().subscribe(res=>{
     console.log(res);
}

注2：使用forkJoin和map

getData()
{
    let observables:Observables[];

    observables.push(of({property:"observable"});
    observables.push(of({property:"observable2"});

    return (forkJoin(observables).pipe(map(res=>{
        //in res we have [{property:"observable"},{property:"observable2"}]
        res.forEach((x,index)=>x.newProperty=i)
        //in res we have [{property:"observable",newProperty:0},
        //                {property:"observable2",newProperty:1}]
       }))
}

更新还有其他方法可以做这些事情。我认为最好有一个返回完整的“问题”的函数。

//You have
jsonData:any=....
//So you can have a function that return an observable
jsonData:any=...
getJsonData()
{
   return of(this.jsonData)
}
//Well, what about to have a function thah return a fullFilled Data?
getFullFilledData()
{
   let observables:Observables[]=[];
   this.jsonData.forEach(element => {
      if (element.elementType === 'dropdown') {
         observables.push(this.http.get(element.optionsUrl))
      }
   })
   return forkJoin(observables).pipe(map(res=>
      let index = 0;
      this.jsonData.forEach((element) => {
      if (element.elementType === 'dropdown') {
         element.options = res[index];
         index++;
      }
   })
   return this.jsonData
   }))
}

通过这种方式，您无需更改组件。如果您调用getFullfilledData，则您拥有（订阅中）数据

查看stackblitz

Answer 2

您的步骤4在下标逻辑之外。在第3步之后将其移入其中，并将最后执行。

可观察对象发送三种类型的通知：下一个，错误和完成。 https://angular.io/guide/observables 如果要处理肯定的响应，则必须在下一个通知的内部放置每个logik。

myObservable.subscribe(
 x => console.log('Observer got a next value: ' + x),
 err => console.error('Observer got an error: ' + err),
 () => console.log('Observer got a complete notification')
);

如果您有多个可观察对象并且想要一个接一个地处理它们，像concatMap这样的平滑策略也可能会让您感兴趣。 https://medium.com/@shairez/a-super-ninja-trick-to-learn-rxjss-switchmap-mergemap-concatmap-and-exhaustmap-forever-88e178a75f1b

Answer 3

1-

好吧，这里有一个具体的用例，您可以使用不同的方法来获得相同的结果，但是通常您可以尝试使用 async await ：

async someFunction() {
    this.asyncResult = await this.httpClient.get(yourUrl).toPromise();
    console.log("step 4");
  }

您不再需要订阅，一旦从“ yourUrl”中获取了数据， Observable将被转换为Promise，并且Promise被解决了，然后将返回的数据存储在“ asyncResult”变量中。此时，将执行最后一个控制台， here you'll find a little use case。

PS： this.httpClient.get(yourUrl)在您的this.service.getRest(url)中实现

2-

或仅将您的console.log("step 4");移动到 subscribe 方法范围内以确保顺序。 （JavaScript具有著名的异步行为，请在google上获取更多详细信息）

Answer 4

您的函数正在调用异步API调用，因此您将无法在.subscribe（）函数之前或之后获取array的值。并且您需要在函数之外声明数组。

然后，只要获取数据，只需调用另一个函数即可。

let array = [];

someFunction() {


 this.service.getRest(url).subscribe(result => { 

   result.data.forEach(element => {

    array.push(element); // Pushing all the objects comes from res.data     

   });

   this.anotherFunction();

 });

  anotherFunction()
  {
     console.log(this.array)//you can access it here 
  }

}

Answer 5

查看以下时间轴：

不能保证在步骤4之前将退回服务，因此在步骤4中将不保证array会被填满。确保使用填充数组的推荐方法是在服务回调中移动数组处理逻辑，这将与图片中的第二个向下箭头相对应。

如何处理数据来自服务的延迟？

5 个答案: