Enforcing Immutability

We cheated a little in the previous example. We told Angular that all of our inputs, including the actor object, were immutable objects, but we went ahead and updated its properties, violating the immutability principle. As a result we ended up with a sync problem between our models and our views. One way to enforce immutability is using the library Immutable.js.

Because in JavaScript primitive types like string and number are immutable by definition, we should only take care of the objects we are using. In this case, the actor object.

Here's an example comparing a mutable type like an array to an immutable type like a string:

  1. var b = ['C', 'a', 'r'];
  2. b[0] = 'B';
  3. console.log(b) // ['B', 'a', 'r'] => The first letter changed, arrays are mutable
  5. var a = 'Car';
  6. a[0] = 'B';
  7. console.log(a); // 'Car' => The first letter didn't change, strings are immutable

First we need to install the immutable.js library using the command:

  1. npm install --save immutable

Then in our AppComponent we import the library and use it to create an actor object as an immutable.

app/app.component.ts

  1. import { Component } from '@angular/core';
  2. import { MovieComponent } from './movie.component';
  3. import * as Immutable from 'immutable';
  5. @Component({
  6.   selector: 'app-root',
  7.   template: `
  8.     <h1>MovieApp</h1>
  9.     <p>{{ slogan }}</p>
  10.     <button type="button" (click)="changeActor()">
  11.       Change Actor
  12.     </button>
  13.     <app-movie [title]="title" [actor]="actor"></app-movie>`
  14. })
  15. export class AppComponent {
  16.   slogan = 'Just movie information';
  17.   title = 'Terminator 1';
  18.   actor = Immutable.Map({
  19.     firstName: 'Arnold',
  20.     lastName: 'Schwarzenegger'
  21.   })
  23.   changeActor() {
  24.     this.actor = this.actor.merge({ firstName: 'Nicholas', lastName: 'Cage' });
  25.   }
  26. }

Now, instead of creating an instance of an Actor class, we are defining an immutable object using Immutable.Map. Because this.actor is now an immutable object, we cannot change its internal properties (firstName and lastName) directly. What we can do however is create another object based on actor that has different values for both fields - that is exactly what the merge method does.

Because we are always getting a new object when we try to change the actor, there's no point in having two different methods in our component. We removed the methods changeActorProperties and changeActorObject and created a new one called changeActor.

Additional changes have to be made to the MovieComponent as well. First we need to declare the actor object as an immutable type, and in the template, instead of trying to access the object properties directly using a syntax like actor.firstName, we need to use the get method of the immutable.

app/movie.component.ts

  1. import { Component, Input } from '@angular/core';
  2. import { ChangeDetectionStrategy } from '@angular/core';
  3. import * as Immutable from 'immutable';
  5. @Component({
  6.   selector: 'app-movie',
  7.   template: `
  8.     <div>
  9.       <h3>{{ title }}</h3>
  10.       <p>
  11.         <label>Actor:</label>
  12.         <span>{{ actor.get('firstName') }} {{ actor.get('lastName') }}</span>
  13.       </p>
  14.     </div>`,
  15.   changeDetection: ChangeDetectionStrategy.OnPush
  16. })
  17. export class MovieComponent {
  18.   @Input() title: string;
  19.   @Input() actor: Immutable.Map<string, string>;
  20. }

View Example

Using this pattern we are taking full advantage of the "OnPush" change detection strategy and thus reducing the amount of work done by Angular to propagate changes and to get models and views in sync. This improves the performance of the application.

原文: https://angular-2-training-book.rangle.io/handout/change-detection/enforcing_immutability.html