Angular 如何将可观测数组求和为数

我如何合计

这个。上传
观察值数组，以便除了每个单独的上传完成百分比外，还可以得到上传的总体百分比

uploadFile(event) {
    // reset the array 
    const filelist = event.target.files;
    const allPercentage: Observable<number>[] = [];
    for (var i = 0; i < filelist.length; i++) {
      const file = filelist[i];
      const filePath = `${file.name}`;
      const fileRef = this.storage.ref(filePath);
      const task = this.storage.upload(filePath, file);
      const _percentage$ = task.percentageChanges();
      this.uploads[i] = _percentage$;
      this.totalPercentage.push(_percentage$);
  }

上传文件（事件）{
//重置阵列
const filelist=event.target.files；
常数百分比：可观察[]=[]；
对于（var i=0；i
一个可能的解决方案是使用
RxJs
操作符。看看它是如何工作的。

当从任何观察值发出值时，您需要重新计算所有上载完成值的总体完成百分比

下面是一个演示解决方案的示例。

这是一个概念的抽象演示，它通过随机时间间隔发送0到100之间的值来模拟文件上载。

只显示单个和总体完成百分比

import { Component } from '@angular/core';
import { combineLatest, Observable } from 'rxjs';

@Component({
  selector: 'my-app',
  template: `
    <ul>
      <li *ngFor="let observable of observables; let i = index">observable {{i + 1}}: {{observable | async}}</li>
    </ul>
    <p>total = {{total}}</p>`,
})
export class AppComponent {
  private readonly OBSERVABLES_COUNT = 10;

  total = 0;
  observables: Observable<number>[] = [];

  constructor() {
    // create observables
    for (let i = 0; i < this.OBSERVABLES_COUNT; i++) {
      this.observables.push(this.createObservable());
    }

    // listen to combined streams
    combineLatest(this.observables).subscribe(values => {
      // when a value is emited from any of the streams, recalculate total
      let total = 0;
      // sum values
      values.forEach(value => total += value);
      // divide by observables count to get average
      total /= this.OBSERVABLES_COUNT;
      // display total
      this.total = total;
    });
  }

  /**
   * This creates an observable roughly simulating a file upload.
   * Values are emitted at a constant random time interval from 0 to 100.
   */
  createObservable(): Observable<number> {
    // create observable
    return Observable.create(observer => {
      // init value
      let value = 0;
      // init interval
      const interval = setInterval(
        () => {
          // increment value
          value += 10;
          // emit it
          observer.next(value);
          // stop when value reaches 100
          if (value === 100) {
            // complete observable
            observer.complete();
          }
        },
        // set a random time interval
        Math.random() * 1000,
      );
      // start with 0
      observer.next(0);
    });
  }
}

从'@angular/core'导入{Component}；
从“rxjs”导入{CombineTest，Observable}；
@组成部分({
选择器：“我的应用程序”，
模板：`

可观测的{{i+1}:{{{observable | async}

总数={{total}}
`，
})
导出类AppComponent{
私有只读可观察对象\u计数=10；
总数=0；
可观测：可观测[]=[]；
构造函数（）{
//创建可观察对象
for（设i=0；i{
//当从任何流中发出值时，请重新计算总计
设total=0；
//和值
forEach（value=>total+=value）；
//除以观测值计数得到平均值
总计/=此。可观测值\u计数；
//显示总数
这个.总计=总计；
});
}
/**
*这将创建一个大致模拟文件上载的可观察对象。
*值以0到100之间的恒定随机时间间隔发出。
*/
createObservable（）：可观察{
//创建可观察的
返回可观察的。创建（观察者=>{
//初始值
设值=0；
//初始间隔
常数间隔=设置间隔(
() => {
//增值
数值+=10；
//发射它
下一步（值）；
//当值达到100时停止
如果（值===100）{
//完全可观测
observer.complete（）；
}
},
//设置一个随机的时间间隔
Math.random（）*1000，
);
//从0开始
观察者：下一个（0）；
});
}
}
一个可能的解决方案是使用
RxJs
操作符。看看它是如何工作的。

当从任何观察值发出值时，您需要重新计算所有上载完成值的总体完成百分比

下面是一个演示解决方案的示例。

这是一个概念的抽象演示，它通过随机时间间隔发送0到100之间的值来模拟文件上载。

只显示单个和总体完成百分比

import { Component } from '@angular/core';
import { combineLatest, Observable } from 'rxjs';

@Component({
  selector: 'my-app',
  template: `
    <ul>
      <li *ngFor="let observable of observables; let i = index">observable {{i + 1}}: {{observable | async}}</li>
    </ul>
    <p>total = {{total}}</p>`,
})
export class AppComponent {
  private readonly OBSERVABLES_COUNT = 10;

  total = 0;
  observables: Observable<number>[] = [];

  constructor() {
    // create observables
    for (let i = 0; i < this.OBSERVABLES_COUNT; i++) {
      this.observables.push(this.createObservable());
    }

    // listen to combined streams
    combineLatest(this.observables).subscribe(values => {
      // when a value is emited from any of the streams, recalculate total
      let total = 0;
      // sum values
      values.forEach(value => total += value);
      // divide by observables count to get average
      total /= this.OBSERVABLES_COUNT;
      // display total
      this.total = total;
    });
  }

  /**
   * This creates an observable roughly simulating a file upload.
   * Values are emitted at a constant random time interval from 0 to 100.
   */
  createObservable(): Observable<number> {
    // create observable
    return Observable.create(observer => {
      // init value
      let value = 0;
      // init interval
      const interval = setInterval(
        () => {
          // increment value
          value += 10;
          // emit it
          observer.next(value);
          // stop when value reaches 100
          if (value === 100) {
            // complete observable
            observer.complete();
          }
        },
        // set a random time interval
        Math.random() * 1000,
      );
      // start with 0
      observer.next(0);
    });
  }
}

从'@angular/core'导入{Component}；
从“rxjs”导入{CombineTest，Observable}；
@组成部分({
选择器：“我的应用程序”，
模板：`

可观测的{{i+1}:{{{observable | async}

总数={{total}}
`，
})
导出类AppComponent{
私有只读可观察对象\u计数=10；
总数=0；
可观测：可观测[]=[]；
构造函数（）{
//创建可观察对象
for（设i=0；i{
//当从任何流中发出值时，请重新计算总计
设total=0；
//和值
forEach（value=>total+=value）；
//除以观测值计数得到平均值
总计/=此。可观测值\u计数；
//显示总数
这个.总计=总计；
});
}
/**
*这将创建一个大致模拟文件上载的可观察对象。
*值以0到100之间的恒定随机时间间隔发出。
*/
createObservable（）：可观察{
//创建可观察的
返回可观察的。创建（观察者=>{
//初始值
设值=0；
//初始间隔
常数间隔=设置间隔(
() => {
//增值
数值+=10；
//发射它
下一步（值）；
//当值达到100时停止
如果（值===100）{
//完全可观测
observer.complete（）；
}
},
//设置一个随机的时间间隔
Math.random（）*1000，
);
//从0开始
观察者：下一个（0）；
});
}
}
它是一个可观测的阵列，还是一个发射阵列的可观测的？任何可观测的阵列？它是一个可观测的阵列，还是一个发射阵列的可观测的？任何可观测的阵列