RSS

Performance Optimization in Angular 2.0

20 דצמ

 

Angular 2 is very fast J. Its mechanisms: change detection, renderer, compiler and more have been redesigned and buildt from scratch. This brings the question why do we need performance optimization? Because we are addicted to speed! Over the years our applications have become larger and the UI has become more and more complex. In this post I will explain how change detection works (In Angular 1 it is called the digest loop) and how we can optimize it to improve performance.

 

How Angular 2 knows when to update the UI?

Angular 2 works with zone.js library. This library overrides all the functions that we register to async events (i.e setTimeout, setInterval, addEventListener and XMlHttpRequet).

The reason that Angular 2 uses the zone.js is to know when our handler finishes and then the NgZone service (NgZone is a class that wrap the zone service) calls to ApplicationRef.tick() method. The tick() method scans the tree components from top to bottom and calculates in each component the expressions that exist in the template. If the result of the expression is not equal to the previous result, (from the previous tick) Angular will update the DOM property that connects to this expression.

 

 What are the parameters that influence my performance?

Now that we know how Angular 2 works we can build the performance formula.

image

Frequency    – The number of times a tick method is call per second.

Quantity       – The number of expressions that exist in the tree components.

 

What are High Frequency Problems?

Usually the UI changes because we react with the UI events and these events don’t happen in high frequency (All the round brackets in the templates).

High frequency performance problems can often occur when the data needs to be updated in high frequency using timers or communication for example components like monitors, graphs, clocks. When these components cause a tick, the entire tree is recalculated regardless of whether or not the components in the tree need to be updated at such a high frequency.

Below is an example of high frequency performance problem.

image

In the dashboard we have one component that cause a tick every 50ms. This means if we working without any optimizations, all of the components in the tree are calculated every 50ms and this is bad for performance.

To improve the performance we need to reduce the number of ticks per second but still update the specific graph component at 50ms. We need to work with NgZone service and cancel the default behavior of executing the tick function after async events. See code:

image

I use the runOutsideAngular method to execute the run method so any async events that happen inside this method will not cause any tick. The value property will update every 50ms but we will not see the screen updates. We need to call explicitly to detectChanges() method. See code:

image

 

Summary of the High Frequency Problem:

When a component causes too many ticks and the other components don’t need this kind of high frequency refresh rate, we will use the NgZone service to eliminate the tick and the ChangeDetectorRef service to update only the component area in the screen.

 

What is the High Expressions Problem?

In every tick, Angular 2 calculates all the expressions that exist in the components tree. Less expressions means less calculations so the tick method will take less time and this means more time for the UI thread to do other tasks. The question is do we need to calculate each expression in every tick? Answer: of course not.

 

Detach & Reattach Strategy:
A component can detach form the tree components, meaning Angular will not calculate the component expressions on a tick and will not update the component area on the screen. Only when the component reattaches back to the components tree, Angular will calculate it expressions. A detach and reattach methods exist in the ChangeDetectorRef class. Each component can choose when to call this methods.

Notes:

1)    In detach mode the component can still cause a tick.

 

2)    When executing the reattach method, we see the first update only when a tick happens. We can call explicitly to detectChanges method to update the screen.

 

On-push Strategy:

If the state of a component changes because the component inputs are changed, then on-push strategy is recommended. To use the on-push strategy is very easy, see code:

@Component({
    selector :
'user'
,
    template :
`

`,
    changeDetection : ChangeDetectionStrategy.OnPush
})

export class
UserComponent{
    @Input() name:
string
;
    @Input() email:
string
;
    @Input() age:
number
;
}

 

Notes:

1)    We will see the component update on the screen only if one of the inputs is changed (name, email or age).

 

2)    Angular 2 compares expressions that return objects by reference. This means if a property in the object has changed and not the object reference, Angular will not update the component area on the screen. To solve this problem we need to use the ngDoCheck hook and the KeyValueDiffers class (See the NgClass directive code). In case of array we need to use the IterableDiffers class (See the NgFor directive code).

 

Threshold Strategy:

The goal of the threshold strategy is to update the component only if the state has changed significantly.

Example:

This demo shows how we can work with an Observable class and its operators to reduce the amount of updates, meaning less expressions to calculate. The component is detached form the component tree and the update happens only when item comes up from the observable. See code:

Threshold

let threshold = source

          .auditTime(500)

          .scan((acc,curr)=>{

                return {

                    curr,

                    delta: Math.abs(acc.curr – curr)

                }

           })

          .filter(value => value.delta > 15)

          .map(acc => acc.curr)

Up & Down triangle

threshold

        .scan((acc,curr)=>{

             return {

                        curr,

                        isUp: curr – acc.curr > 0

             }

        })

        .map(val => val.isUp)

        .distinctUntilChanged();

 

Link to live demo.

 

Summary:

Angular 2 is Fast, but not enough to overcome huge components tree with high frequency of ticks. In this cases we must optimize and use the NgZone to reduce the number of ticks and the ChangeDetectorRef class to reduce the number of expressions for each tick.

image

These optimizations reduce the number of calculations the UI Thread does per second, meaning more efficiency.

Advertisements
 
השארת תגובה

פורסם ע"י ב- דצמבר 20, 2016 ב- Angular 2.0

 

כתיבת תגובה

הזינו את פרטיכם בטופס, או לחצו על אחד מהאייקונים כדי להשתמש בחשבון קיים:

הלוגו של WordPress.com

אתה מגיב באמצעות חשבון WordPress.com שלך. לצאת מהמערכת / לשנות )

תמונת Twitter

אתה מגיב באמצעות חשבון Twitter שלך. לצאת מהמערכת / לשנות )

תמונת Facebook

אתה מגיב באמצעות חשבון Facebook שלך. לצאת מהמערכת / לשנות )

תמונת גוגל פלוס

אתה מגיב באמצעות חשבון Google+ שלך. לצאת מהמערכת / לשנות )

מתחבר ל-%s

 
%d בלוגרים אהבו את זה: