@Injectable()
export class TasksEffects {
constructor(
    private actions$: Actions,private TS: TaskService
){}

@Effect()
onLoadTasksLoadTasks$: Observable<Action> = this.actions$.ofType(tasksActions.ActionTypes.LOAD_TASKS)
    .switchMap(() => {
        return this.TS.index()
            .map((res) => new tasksActions.LoadTasksSuccessAction(res.json()))
            .catch(err => of(new tasksActions.LoadTasksFailAction(err)));
    });

我想每十秒运行一次switchMap功能.这不起作用.

@Effect()
onLoadTasksLoadTasks$: Observable<Action> = this.actions$.ofType(tasksActions.ActionTypes.LOAD_TASKS)
    .switchMap(() => {
        return this.TS.index()
            .map((res) => new tasksActions.LoadTasksSuccessAction(res.json()))
            .catch(err => of(new tasksActions.LoadTasksFailAction(err)));
    }).interval(10000);

类型错误是：

相反,你应该能够使用timer实现你想要的.

import { Observable } from 'rxjs/Observable';
import 'rxjs/add/observable/of';
import 'rxjs/add/observable/timer';
import 'rxjs/add/operator/catch';
import 'rxjs/add/operator/map';
import 'rxjs/add/operator/switchMap';

@Effect()
onLoadTasksLoadTasks$: Observable<Action> = this.actions$
  .ofType(tasksActions.ActionTypes.LOAD_TASKS)
  .switchMap(() => Observable
    .timer(0,10000)
    .switchMap(() => this.TS.index()
      .map((res) => new tasksActions.LoadTasksSuccessAction(res.json()))
      .catch(err => Observable.of(new tasksActions.LoadTasksFailAction(err)))
    )
  );

使用计时器,可以指定初始延迟,并在此设置为零,以便计时器立即触发.之后,它将每十秒触发一次,但是如果收到另一个LOAD_TASKS动作,switchMap将看到它取消订阅并创建一个新的计时器等.

var d = $q.defer();
        var promises = [];
        for(var i = 0; i < urls.length; i++){
            var url = urls[i];
            var p = $http.get(url,{responseType: "arraybuffer"});
            promises.push(p);
        }
        $q.all(promises).then(function(result){
            d.resolve(result);
        },function(rejection){
            d.reject(rejection);
        });
        return d.promise;

编辑：
好吧,经过一番摆弄,这就是我想出来的

var d = $q.defer();
        var promises = [];
        var completedCount = 0;
        for(var i = 0; i < urls.length; i++){
            var url = urls[i];
            var p = $http.get(url,{responseType: "arraybuffer"}).then(function(respose){
              completedCount = completedCount+1;
              var progress = Math.round((completedCount/urls.length)*100);
              $rootScope.$broadcast('download.completed',{progress: progress});
              return respose;
            },function(error){
              return error;
            });
            promises.push(p);
        }
        $q.all(promises).then(function(result){
            d.resolve(result);
        },function(rejection){
            d.reject(rejection);
        });
        return d.promise;

不确定这是否是正确的做法.

我曾经根据所有待处理的http请求制作了一个进度解决方案(显示某个加载的指示符,类似于youtube在顶部进度条上)

JS：

app.controller("ProgressCtrl",function($http) {

    this.loading = function() {
        return !!$http.pendingRequests.length;
    };

});

HTML：

<div id="fixedTopBar" ng-controller="ProgressCtrl as Progress">
    <div id="loading" ng-if="Progress.loading()">
        loading...
    </div>
</div>

.

性交

对于我的最新项目,它不仅仅是请求请求.我开始进入套接字,webworker,文件系统,文件读取器,dataChannel和任何其他使用$q的异步调用.所以我开始研究如何获得所有未决的承诺(包括$http).原来没有任何有角度的解决方案,所以我有点猴子在decorating修补了$q提供商.

app.config(function($provide) {

    $provide.decorator("$q",function($delegate) {
        // $delegate == original $q service

        var orgDefer = $delegate.defer;
        $delegate.pendingPromises = 0;

        // overide defer method 
        $delegate.defer = function() {
            $delegate.pendingPromises++; // increass
            var defer = orgDefer();

            // decreass no mather of success or faliur
            defer.promise['finally'](function() {
                $delegate.pendingPromises--;
            });

            return defer;
        }

        return $delegate
    });

});

app.controller("ProgressCtrl",function($q) {

    this.loading = function() {
        return !!$q.pendingPromises;
    };

});

这可能不适合每个人的生产需求,但它可能对开发人员有用,看看是否有任何未解决的问题留下并永远不会被调用

我使用以下代码进行HTTP调用：

let body = JSON.stringify(params);
        let headers = new Headers({ 'Content-Type': 'application/json' });
        let options = new RequestOptions({ headers: headers });
        this.http.post(url,body,options)
            .timeout(10000,new Error('Timeout exceeded during login'))
            .toPromise()
            .then((res) => {
                ...
            }).catch((err) => {
                ...
            });

目标是编写同步系统.该帖子将返回大量数据,我想让用户了解同步需要多长时间.

import { HttpRequest } from '@angular/common/http';
...

const req = new HttpRequest('POST','/upload/file',file,{
  reportProgress: true,});

当您订阅请求时,您将在每个进度事件中收到订阅：

http.request(req).subscribe(event => {
  // Via this API,you get access to the raw event stream.
  // Look for upload progress events.
  if (event.type === HttpEventType.UploadProgress) {
    // This is an upload progress event. Compute and show the % done:
    const percentDone = Math.round(100 * event.loaded / event.total);
    console.log(`File is ${percentDone}% uploaded.`);
  } else if (event instanceof HttpResponse) {
    console.log('File is completely uploaded!');
  }
});

更多信息here.

$http({method:'POST',url:"http://0.0.0.0:4567/authenticate",params: {Lusername:scope.Lusername,Lpassword:scope.Lpassword}})
 .success(function(){alert("Success")})

在Safari中使用时,它可以正常工作：返回预期的JSON对象并显示警告框.但是在Firefox中,虽然正确返回了JSON对象,但不会触发成功回调.

知道为什么吗？