Follow me on Twitter, happy to take your suggestions on topics or improvements /Chris

NGRX is an implementation of the pattern Redux. It’s made for the framework Angular and adds Typescript and reactiveness with RxJS

This article is part of a series:

NGRX — from the beginning, part I, Pub-sub,

NGRX — from the beginning, part II, part II Redux

NGRX — from the beginning, part III, NGRX store, we are here

NGRX — from the beginning, part IV, NGRX store, improving it with enums and interfaces, in progress

NGRX — from the beginning, part V, NGRX effects, in progress

NGRX — from the beginning, part VI, NGRX entity, in progress

If you come into this part with no idea what Redux or Pub-Sub is, I urge you to read part I and part II first. We won’t explain things like Reducer or Action or how we dispatch messages cause that would make this article too long.

In this article, we will cover

Set up and install , we will explain how to scaffold a project and also install the necessary dependencies and we will also add our first state property and Reducer function

, we will explain how to scaffold a project and also install the necessary dependencies and we will also add our first state property and Reducer function Displaying data , here we will cover how to inject the Store service and how to display data from the Store in our markup

, here we will cover how to inject the Store service and how to display data from the Store in our markup Change state, after we’ve shown how to show the data we will here focus on how to change the data or as it is referred to with Redux, to dispatch an action

Set up and install

Ok, we need to do the following:

Scaffolding an Angular project Install @ngrx/store Set up @ngrx/store

Install

Ok, first things first, let’s create ourselves an Angular project by typing the following in the terminal:

ng new NameOfMyProject cd NameOfMyProject

Thereafter we remain in the terminal and enter:

npm install @ngrx/store

This install our library and we are ready to configure our project to @ngrx/store .

Set up

Ok, we have a project let’s set it up. There are two things we need to do:

Import the StoreModule call StoreModule.forRoot() and provide it with an object consisting of a number of state, reducer pairs

Ok, we open up app.module.ts and enter:

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

Lets call StoreModule.forRoot() next. As mentioned above we need to give it an object consists of a number of state, reducer pairs, like so:

{

state: stateReducer,

secondState: secondStateReducer

...

}

Ok, we understand the overall shape so let’s show in real code what this might look like:

const counterReducer = (state = 0, action) => {

switch (action.type) {

case 'INCREMENT': return state + 1;

default: return state;

}

}

Next, in the same file app.module.ts , we need to add our StoreModule to our list of imports , like so:

imports: [

BrowserModule,

AppRoutingModule,

StoreModule.forRoot({

counter: counterReducer

})

]

As you can see we are now providing an object to StoreModule.forRoot() containing our counter , counterReducer pair.

Displaying data

Ok, that covers the bare minimum set up we need to make @ngrx/store work. However, we can’t show our data at this point. To show data we need to inject the Store service into a constructor of the component that aims to display data. Let's go into app.component.ts and add the needed import:

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

And the needed injection into the component class constructor:

constructor(private store: Store<any>) {}

At this point you might wonder about the use of any as a template argument to the Store , let's leave that for now and work on improving it in just a little bit.

Selecting data

Ok, the Store service will let us select data from its inner state if we use the method pipe() and the operator select() , like so:

import { Store, select } from '@ngrx/store'; @Component({

...

})

export class AppComponent {

counter$; constructor(private store: Store<any>) {

this.counter$ = this.store.pipe(

select('counter')

)

}

}

We are importing the select() operator from @ngrx/store and we also assign the result of our pipe() invocation to a variable counter$ . counter$ is an Observable and that means we can use an async pipe to show the content. Let's now head to our app.component.html file and type the following:

My counter: {{ counter$ | async }}

Save an run your project and your browser should now display My counter: 0

With a function selector

So far everything works, but let’s go back to how we inject our Store service in the AppComponent constructor. We gave it the template argument any . We can definitely improve that, but how? The idea is to feed it an interface that represents your Store state. Currently, your Stores state looks like this:

{ counter }

So let's create an interface that corresponds to this, namely:

// app-state.ts export interface AppState {

counter: number;

}

Above we are declaring the only existing state property counter and we declare what type it is as well. Ok, next step is to use AppState for our Stores template, so let's update app.component.ts . First, add this import:

import { AppState } from './app-state';

Let’s now replace any with AppState :

constructor(private store: Store<AppState>){}

We can do more though, we can leverage this by switching from the select() method that takes a string to the one that takes a function, like so:

So this:

this.counter$ = this.store.pipe(

select('counter')

)

Becomes:

this.counter$ = this.store.pipe(

select(state => state.counter)

)

What’s so great about this you ask? Well now we get help from the compiler if we attempt to select a property from the state doesn’t exist, only state.counter would be a valid choice. Also if our state is nested this is the only way we would be able to reach a state like state.products.data for example, if we had a state products that is.

Change state

Ok, great, we can display a state property from our store, what about changing it? For that, we have a dispatch() method that will allow us to send a message to the Store. The message is in the form of an Action object. Ok, let's build out our UI a bit. Go into app.component.html and add the following:

// app.component.html <button (click)="increment()">Increment</button>

Now, head to app.component.ts and add the method increment() , like so:

@Component({}) export class AppComponent {

increment() {

// add dispatch call here }

}

}

Ok, we need to do the following to send a message to the store:

Construct an action object with the message type INCREMENT

Call dispatch() on the Store service instance

Ok, to construct an object we can use an object literal, like so:

const action = { type: 'INCREMENT' };

The reason for using the message INCREMENT lies in how we constructed the counterReducer function, let's look at it quickly:

const counterReducer = (state = 0, action) => {

switch (action.type) {

case 'INCREMENT': return state + 1;

default: return state;

}

}

It’s clear it expects a message that has a property type and for that message type value to be INCREMENT . Ok, looks good, let's make the call to dispatch() :

@Component({})

export class AppComponent {

// constructor omitted for brevity

increment() {

const action = { type: 'INCREMENT' };

this.store.dispatch(action);

}

}

Invoking increment() will now lead to our message being sent to the store and for the counterReducer() to be invoked and for our counter value to be updated by one. Try it yourself.

Summary