NgRx效果使无限循环的Angular应用崩溃

Question

我对NGRx还是很陌生，我试图在我的小项目上使用效果，因为日期决定使用外部数据，因此我决定将其放入效果中，因此应用程序现在在运行“ npm start”后因无限循环而崩溃，它只是停止工作。这是回购Github Repo

的链接

count.effects.ts

import { Injectable } from '@angular/core';
import { Actions, Effect, ofType } from '@ngrx/effects';
import {
  countActionsType,
  CountUpdatedAtAction,
} from './reducers/count/count.actions';
import { map } from 'rxjs/operators';

@Injectable()
export class AppEffects {
  constructor(private actions$: Actions) {}

  @Effect()
  updatedAt$() {
    return this.actions$.pipe(
      ofType(
        countActionsType.increase,
        countActionsType.decrease,
        countActionsType.clear,
        countActionsType.updatedAt
      ),
      map(() => {
        return new CountUpdatedAtAction({
          updatedAt: Date.now(),
        });
      })
    );
  }
}

count.reducer.ts

import { CountActions, countActionsType } from './count.actions';

export const COUNT_NODE = 'count';

export interface ICountState {
  count: number;
  updatedAt: number;
}

const initialState: ICountState = {
  count: 0,
  updatedAt: Date.now(),
};

export const countReducer = (state = initialState, actions: CountActions) => {
  switch (actions.type) {
    case countActionsType.increase:
      return {
        ...state,
        count: state.count + 1,
      };
    case countActionsType.decrease:
      return {
        ...state,
        count: state.count - 1,
      };
    case countActionsType.clear:
      return {
        ...state,
        count: 0,
      };
    case countActionsType.updatedAt:
      return {
        ...state,
        updatedAt: actions.payload.updatedAt,
      };
    default:
      return state;
  }
};

count.actions.ts

import { Action } from '@ngrx/store';

export enum countActionsType {
  increase = '[COUNT] increase',
  decrease = '[COUNT] decrease',
  clear = '[COUNT] clear',
  updatedAt = '[COUNT] updated at',
}

export class CountIncreaseAction implements Action {
  readonly type = countActionsType.increase;
}

export class CountDecreaseAction implements Action {
  readonly type = countActionsType.decrease;
}

export class CountClearAction implements Action {
  readonly type = countActionsType.clear;
}

export class CountUpdatedAtAction implements Action {
  readonly type = countActionsType.updatedAt;

  constructor(
    public payload: {
      updatedAt: number;
    }
  ) {}
}

export type CountActions =
  | CountIncreaseAction
  | CountDecreaseAction
  | CountClearAction
  | CountUpdatedAtAction;

count.components.ts

import { Component } from '@angular/core';
import { Store, select } from '@ngrx/store';
import { ICountState } from './reducers/count/count.reducer';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';
import { selectCount, selectUpdatedAt } from './reducers/count/count.selectors';
import {
  CountIncreaseAction,
  CountDecreaseAction,
  CountClearAction,
} from './reducers/count/count.actions';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.scss'],
})
export class AppComponent {
  public count$: Observable<number> = this.store$.pipe(select(selectCount));
  public isButtonDisabled$: Observable<boolean> = this.count$.pipe(
    map((count) => count <= 0)
  );
  public updatedAt$: Observable<number> = this.store$.pipe(
    select(selectUpdatedAt)
  );

  constructor(private store$: Store<ICountState>) {}

  increase() {
    this.store$.dispatch(new CountIncreaseAction());
  }

  decrease() {
    this.store$.dispatch(new CountDecreaseAction());
  }

  clear() {
    this.store$.dispatch(new CountClearAction());
  }
}

Answer 1

这很简单，当您调度某些动作（包括countActionsType.updatedAt）时，就会触发效果。 在效果内部，您调度了一个名为CountUpdatedAtAction的操作，类型为countActionsType.updatedAt。

那是你的无限循环：）

每次更新时，效果都会尝试一次又一次地更新：P

要执行此操作，只需删除以下位置的countActionsType.updatedAt：

ofType(
        countActionsType.increase,
        countActionsType.decrease,
        countActionsType.clear,
        countActionsType.updatedAt // <--- remove this
      ),