Quickly understand the onPush change detection strategy in Angular-JS Tutorial-php.cn

This article will give you an in-depth understanding of the onPush change detection strategy in Angular. I hope it will be helpful to you!

Quickly understand the onPush change detection strategy in Angular

Default change detection strategy

By default, Angular uses the ChangeDetectionStrategy.Default strategy for Change detection.

The default strategy does not make any assumptions about the application in advance. Therefore, whenever user events, timers, XHR, promises and other events cause the data in the application to change, all components will Perform change detection.

This means that any event from a click event to data received from an ajax call will trigger change detection.

We can easily see this by defining a getter in the component and using it in the template:

@Component({
  template: `
    <h1>Hello {{name}}!</h1>
    {{runChangeDetection}}
  `
})
export class HelloComponent {
  @Input() name: string;

  get runChangeDetection() {
    console.log(&#39;Checking the view&#39;);
    return true;
  }
}

Copy after login

@Component({
  template: `
    <hello></hello>
    <button (click)="onClick()">Trigger change detection</button>
  `
})
export class AppComponent  {
  onClick() {}
}

Copy after login

After executing the above code, whenever we click the button. Angular will execute a change detection loop, and in the console we can see two lines of "Checking the view" logs.

This technique is called dirty checking. In order to know if the view needs to be updated, Angular needs to access the new value and compare it to the old value to determine if the view needs to be updated.

Now imagine if there is a large application with thousands of expressions, and Angular checks each expression, we may encounter performance problems.

So is there a way for us to proactively tell Angular when to check our components?

OnPush change detection strategy

We can set the ChangeDetectionStrategy of the component to ChangeDetectionStrategy.OnPush.

This will tell Angular that the component only relies on its @inputs(), which only needs to be checked in the following situations:

1. `Input` Reference changes

By setting the onPush change detection detection strategy, we contract with Angular to force the use of immutable objects (or observables as will be introduced later).

The advantage of using immutable objects in the context of change detection is that Angular can determine whether the view needs to be checked by checking whether the reference has changed. This will be much easier than an in-depth inspection.

Let's try modifying an object and see the results.

@Component({
  selector: &#39;tooltip&#39;,
  template: `
    <h1>{{config.position}}</h1>
    {{runChangeDetection}}
  `,
  changeDetection: ChangeDetectionStrategy.OnPush
})
export class TooltipComponent  {

  @Input() config;

  get runChangeDetection() {
    console.log(&#39;Checking the view&#39;);
    return true;
  }
}

Copy after login

@Component({
  template: `
    <tooltip [config]="config"></tooltip>
  `
})
export class AppComponent  {
  config = {
    position: &#39;top&#39;
  };

  onClick() {
    this.config.position = &#39;bottom&#39;;
  }
}

Copy after login

At this time, you can’t see any logs when you click the button. This is because Angular compares the references of the old value and the new value, similar to:

/** Returns false in our case */
if( oldValue !== newValue ) { 
  runChangeDetection();
}

Copy after login

It is worth mentioning that Numbers, booleans, strings, null and undefined are all primitive types. All primitive types are passed by value. Objects, arrays, and functions are also passed by value, but the value is a copy of the reference address.

So in order to trigger change detection on this component, we need to change the reference to this object.

@Component({
  template: `
    <tooltip [config]="config"></tooltip>
  `
})
export class AppComponent  {
  config = {
    position: &#39;top&#39;
  };

  onClick() {
    this.config = {
      position: &#39;bottom&#39;
    }
  }
}

Copy after login

After changing the object reference, we will see that the view has been checked and the new value is displayed.

2. Events originating from the component or its subcomponents

When an event is triggered in a component or its subcomponents, the internal state of the component will be updated. For example:

@Component({
  template: `
    <button (click)="add()">Add</button>
    {{count}}
  `,
  changeDetection: ChangeDetectionStrategy.OnPush
})
export class CounterComponent {
  count = 0;

  add() {
    this.count++;
  }

}

Copy after login

When we click the button, Angular executes a change detection loop and updates the view.

You may think that, as we described at the beginning, every asynchronous API will trigger change detection, but this is not the case.

You will find that this rule only applies to DOM events. The following APIs will not trigger change detection:

@Component({
  template: `...`,
  changeDetection: ChangeDetectionStrategy.OnPush
})
export class CounterComponent {
  count = 0;

  constructor() {
    setTimeout(() => this.count = 5, 0);

    setInterval(() => this.count = 5, 100);

    Promise.resolve().then(() => this.count = 5); 
    
    this.http.get(&#39;https://count.com&#39;).subscribe(res => {
      this.count = res;
    });
  }

  add() {
    this.count++;
  }

Copy after login

Note that you still updated the attribute, so in the next change detection process , for example, if you click the button, the count value will become 6 (5 1).

3. Explicitly perform change detection

Angular provides us with 3 methods to trigger change detection.

The first one is detectChanges() to tell Angular to perform change detection in this component and its subcomponents.

@Component({
  selector: &#39;counter&#39;,
  template: `{{count}}`,
  changeDetection: ChangeDetectionStrategy.OnPush
})
export class CounterComponent { 
  count = 0;

  constructor(private cdr: ChangeDetectorRef) {

    setTimeout(() => {
      this.count = 5;
      this.cdr.detectChanges();
    }, 1000);

  }

}

Copy after login

The second one is ApplicationRef.tick(), which tells Angular to perform change detection on the entire application.

tick() {
 
  try {
    this._views.forEach((view) => view.detectChanges());
    ...
  } catch (e) {
    ...
  }
}

Copy after login

The third is markForCheck(), which does not trigger change detection. Instead, it will detect all ancestor tags with onPush set in the current or next change detection loop.

markForCheck(): void { 
  markParentViewsForCheck(this._view); 
}

export function markParentViewsForCheck(view: ViewData) {
  let currView: ViewData|null = view;
  while (currView) {
    if (currView.def.flags & ViewFlags.OnPush) {
      currView.state |= ViewState.ChecksEnabled;
    }
    currView = currView.viewContainerParent || currView.parent;
  }
}

Copy after login

It should be noted that manually performing change detection is not a "hack". This is Angular's intentional design and is a very reasonable behavior (of course, under reasonable scenarios).

Angular Async pipe

async The pipe subscribes to an Observable or Promise and returns the latest value it emits.

Let us look at an input() is an observable onPush component.

@Component({
  template: `
    <button (click)="add()">Add</button>
    <app-list [items$]="items$"></app-list>
  `
})
export class AppComponent {
  items = [];
  items$ = new BehaviorSubject(this.items);

  add() {
    this.items.push({ title: Math.random() })
    this.items$.next(this.items);
  }
}

Copy after login

@Component({
  template: `
     <div *ngFor="let item of _items ; ">{{item.title}}</div>
  `,
  changeDetection: ChangeDetectionStrategy.OnPush
})
export class ListComponent implements OnInit {
  @Input() items: Observable<Item>;
  _items: Item[];
  
  ngOnInit() {
    this.items.subscribe(items => {
      this._items = items;
    });
  }

}

Copy after login

When we click the button, we cannot see the view update. This is because none of the above-mentioned situations have occurred, so Angular will not check the component in the current change detection cycle.

现在，让我们加上async pipe试试。

@Component({
  template: `
    <div *ngFor="let item of items | async">{{item.title}}</div>
  `,
  changeDetection: ChangeDetectionStrategy.OnPush
})
export class ListComponent implements OnInit {
  @Input() items;
}

Copy after login

现在可以看到当我们点击按钮时，视图也更新了。原因是当新的值被发射出来时，async pipe将该组件标记为发生了更改需要检查。我们可以在源码中看到：

private _updateLatestValue(async: any, value: Object): void {
  if (async === this._obj) {
    this._latestValue = value;
    this._ref.markForCheck();
  }
}

Copy after login

Angular为我们调用markForCheck()，所以我们能看到视图更新了即使input的引用没有发生改变。

如果一个组件仅仅依赖于它的input属性，并且input属性是observable，那么这个组件只有在它的input属性发射一个事件的时候才会发生改变。

Quick tip：对外部暴露你的subject是不值得提倡的，总是使用asObservable()方法来暴露该observable。

onPush和视图查询

@Component({
  selector: &#39;app-tabs&#39;,
  template: `<ng-content></ng-content>`
})
export class TabsComponent implements OnInit {
  @ContentChild(TabComponent) tab: TabComponent;

  ngAfterContentInit() {
    setTimeout(() => {
      this.tab.content = &#39;Content&#39;; 
    }, 3000);
  }
}

Copy after login

@Component({
  selector: &#39;app-tab&#39;,
  template: `{{content}}`,
  changeDetection: ChangeDetectionStrategy.OnPush
})
export class TabComponent {
  @Input() content;
}

Copy after login

<app-tabs>
  <app-tab></app-tab>
</app-tabs>

Copy after login

也许你会以为3秒后Angular将会使用新的内容更新tab组件。

毕竟，我们更新来onPush组件的input引用，这将会触发变更检测不是吗？

然而，在这种情况下，它并不生效。Angular不知道我们正在更新tab组件的input属性，在模板中定义input()是让Angular知道应在变更检测循环中检查此属性的唯一途径。

例如：

<app-tabs>
  <app-tab [content]="content"></app-tab>
</app-tabs>

Copy after login

因为当我们明确的在模板中定义了input()，Angular会创建一个叫updateRenderer()的方法，它会在每个变更检测循环中都对content的值进行追踪。

Quickly understand the onPush change detection strategy in Angular

在这种情况下简单的解决办法使用setter然后调用markForCheck()。

@Component({
  selector: &#39;app-tab&#39;,
  template: `
    {{_content}}
  `,
  changeDetection: ChangeDetectionStrategy.OnPush
})
export class TabComponent {
  _content;

  @Input() set content(value) {
    this._content = value;
    this.cdr.markForCheck();
  }

  constructor(private cdr: ChangeDetectorRef) {}

}

Copy after login

=== onPush++

在理解了onPush的强大之后，我们来利用它创造一个更高性能的应用。onPush组件越多，Angular需要执行的检查就越少。让我们看看你一个真是的例子：

我们又一个todos组件，它有一个todos作为input()。

@Component({
  selector: &#39;app-todos&#39;,
  template: `
     <div *ngFor="let todo of todos">
       {{todo.title}} - {{runChangeDetection}}
     </div>
  `,
  changeDetection: ChangeDetectionStrategy.OnPush
})
export class TodosComponent {
  @Input() todos;

  get runChangeDetection() {
    console.log(&#39;TodosComponent - Checking the view&#39;);
    return true;
  }

}

Copy after login

@Component({
  template: `
    <button (click)="add()">Add</button>
    <app-todos [todos]="todos"></app-todos>
  `
})
export class AppComponent {
  todos = [{ title: &#39;One&#39; }, { title: &#39;Two&#39; }];

  add() {
    this.todos = [...this.todos, { title: &#39;Three&#39; }];
  }
}

Copy after login

上述方法的缺点是，当我们单击添加按钮时，即使之前的数据没有任何更改，Angular也需要检查每个todo。因此第一次单击后，控制台中将显示三个日志。

在上面的示例中，只有一个表达式需要检查，但是想象一下如果是一个有多个绑定（ngIf，ngClass，表达式等）的真实组件，这将会非常耗性能。

我们白白的执行了变更检测！

更高效的方法是创建一个todo组件并将其变更检测策略定义为onPush。例如：

@Component({
  selector: &#39;app-todos&#39;,
  template: `
    <app-todo [todo]="todo" *ngFor="let todo of todos"></app-todo>
  `,
  changeDetection: ChangeDetectionStrategy.OnPush
})
export class TodosComponent {
  @Input() todos;
}

@Component({
  selector: &#39;app-todo&#39;,
  template: `{{todo.title}} {{runChangeDetection}}`,
  changeDetection: ChangeDetectionStrategy.OnPush
})
export class TodoComponent {
  @Input() todo;

  get runChangeDetection() {
    console.log(&#39;TodoComponent - Checking the view&#39;);
    return true;
  }

}

Copy after login

现在，当我们单击添加按钮时，控制台中只会看到一个日志，因为其他的todo组件的input均未更改，因此不会去检查其视图。

并且，通过创建更小粒度的组件，我们的代码变得更具可读性和可重用性。

原文链接： https://netbasal.com/a-comprehensive-guide-to-angular-onpush-change-detection-strategy-5bac493074a4

原文作者：Netanel Basal

译者：淼淼

更多编程相关知识，请访问：编程视频！！

The above is the detailed content of Quickly understand the onPush change detection strategy in Angular. For more information, please follow other related articles on the PHP Chinese website!