Working with Angular Local Storage
Published: 2022-05-10 16:10:42

---
title: Working with Angular Local Storage
published: true
description: In this article, we'll discuss local storage and its usage from an Angular application's perspective.
tags: 
canonical_url: https://blog.jscrambler.com/working-with-angular-local-storage/
//cover_image: https://blog.jscrambler.com/content/images/2022/04/Jscrambler-Blog-Working-with-Angular-Local-Storage.jpg
---

Storage means a space for putting things for future use. From a web application perspective, storage can be broadly classified into two types: server-side storage and client-side storage. Server-side storage points to the many different types of database storage like SQL, MYSQL, MongoDB, etc. Client-side storage means storing data in the browser itself so that it can be used when required without requesting the server-side database.

In this article, we'll discuss local storage and its usage from an Angular application's perspective. Let's start by trying to understand what local storage is.

## What is Local Storage?

Local storage is client-side storage for web applications. It stays there as long as it's not cleared—unlike session storage, which lasts for the current browser tab session. Local storage provides up to 5MB of storage, allocated separately for each domain. For example, local storage for the website www.abc.com will be different from www.xyz.com.

## Working with Local Storage

The local storage API provides a couple of methods to store, retrieve, remove and clear the storage. Let's see how to use these methods.

### localStorage.setItem

The `setItem` method allows you to add a value to the local storage. It stores data using a key value pair. For example:
```
localStorage.setItem('token','xhja787')
```

The above code stores the data `xhja787` in a key called `token` inside the browser local storage.

***Note: localStorage only stores string values. To store objects or arrays, you need to use JSON.stringify to convert them into a string first.***

Now, let's see how to access the stored data using `getItem`

### localStorage.getItem

`getItem` allows you to read back the data saved in local storage using the same key. For example, to fetch the data stored using the key `token`, you can use the following method:
```
localStorage.getItem('token')
```

### localStorage.removeItem

Once you are done using the data in the local storage, you can remove it using the `removeItem` method. For example:
```
localStorage.removeItem('token')
```

### localStorage.clear

You can clear all of the data out of the local storage using the clear method to wipe the slate clean.
```
localStorage.clear()
```
Now that's all plain JavaScript code to access the local storage. Using local storage in Angular is no different. First, let’s create an Angular application and then we'll create a service wrapper on top of the `localStorage` API.

## Creating the Angular App

You can create the Angular app using the Angular CLI.
```
ng new local-app
```

Once you have the Angular app, you can create an Angular service using the following command:
```
ng g service local
```

Let's add four wrapper methods to add, get, remove and clear storage. Here is how the service looks:
```typescript
import { Injectable } from '@angular/core';

@Injectable({
  providedIn: 'root'
})
export class LocalService {

  constructor() { }

  public saveData(key: string, value: string) {
    localStorage.setItem(key, value);
  }

  public getData(key: string) {
    return localStorage.getItem(key)
  }
  public removeData(key: string) {
    localStorage.removeItem(key);
  }

  public clearData() {
    localStorage.clear();
  }
}
```
You can use the local service by injecting the service into your component. In this Angular example, to use the LocalService in the `app.component.ts` file, you need to inject it by importing it in `AppComponent` and creating an instance in the constructor method.
```
import { Component } from '@angular/core';
import { LocalService } from './local.service';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent {

  constructor(private localStore: LocalService) {

  }
}

```


## Local Storage Uses

Local storage can be used to store pretty much anything you like. It is most commonly used for storing JSON web tokens, user preferences and application settings such as themes.

## How Secure is Local Storage?

When using local storage in Angular, the rule of thumb is to not store anything sensitive. Anything you store in local storage can be accessed by code in your browser. It's ok to store JSON web tokens since they’re already encrypted.

Another good rule of thumb is to encrypt the data before storing it in local storage and decrypt it when fetching from local storage. To encrypt and decrypt data in local storage, you can use a library such as `crypto-js`.

To use it, first install it in your Angular project using `npm`.
```
npm install crypto-js
npm i --save-dev @types/crypto-js
```

Once you have it installed, you can import the library in the `LocalService`.
```
import  *  as CryptoJS from  'crypto-js';
```

Add the following two methods to encrypt and decrypt text:
```typescript
  private encrypt(txt: string): string {
    return CryptoJS.AES.encrypt(txt, this.key).toString();
  }

  private decrypt(txtToDecrypt: string) {
    return CryptoJS.AES.decrypt(txtToDecrypt, this.key).toString(CryptoJS.enc.Utf8);
  }
```

Now, you can use the above two methods to encrypt and decrypt before storing and fetching data from local storage.

```typescript
  public saveData(key: string, value: string) {
    localStorage.setItem(key, this.encrypt(value));
  }

  public getData(key: string) {
    let data = localStorage.getItem(key)|| "";
    return this.decrypt(data);
  }
```

Here is how the complete `local.service.ts` file looks:
```typescript
import { Injectable } from '@angular/core';
import * as CryptoJS from 'crypto-js';

@Injectable({
  providedIn: 'root'
})
export class LocalService {

  key = "123";

  constructor() { }

  public saveData(key: string, value: string) {
    localStorage.setItem(key, this.encrypt(value));
  }

  public getData(key: string) {
    let data = localStorage.getItem(key)|| "";
    return this.decrypt(data);
  }
  public removeData(key: string) {
    localStorage.removeItem(key);
  }

  public clearData() {
    localStorage.clear();
  }

  private encrypt(txt: string): string {
    return CryptoJS.AES.encrypt(txt, this.key).toString();
  }

  private decrypt(txtToDecrypt: string) {
    return CryptoJS.AES.decrypt(txtToDecrypt, this.key).toString(CryptoJS.enc.Utf8);
  }
}

```


Now, let's test this by storing some text in the local storage. In your `app.component.ts` file, import the `LocalService` and create an instance of it in the constructor. In `ngOnInit`, store the data in the local storage using the service method. Here is the `app.component.ts` file:

```typescript
import { Component } from '@angular/core';
import { LocalService } from './local.service';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'local-app';
  constructor(private localStore: LocalService) {

  }

  ngOnInit(): void {
    this.localStore.saveData('id', 'jk123');
  }
}
```
Save the Angular app and run the application. After the app gets loaded, type in `localStorage` from the browser console and you will be able to see the encrypted data in local storage.
```
{
    "id": "U2FsdGVkX1+xovPDV0m0um6MPlrb+p5aG8Rb09TSWaM="
}
```
While trying to access the local storage data inside the application, you can get the decrypted data. For example, try to get the id data from local storage in `ngOnInit`.

```
  ngOnInit(): void {
    this.localStore.saveData('id', 'jk123');
    console.log('decrpted data ', this.localStore.getData('id'));
  }
```

You will be able to see the decrypted data in your browser console.

## Wrapping it Up
In this tutorial, you learned about what `localStorage` is, how and when to use it, and how to encrypt and decrypt data on storing and fetching data respectively from `localStorage`.

We hope you liked this tutorial, and if you want to learn how you can secure your Angular source code against theft and reverse-engineering, be sure to check <a href="https://blog.jscrambler.com/how-to-protect-angular-code-against-theft-and-reverse-engineering/?utm_source=dev.to&utm_medium=referral&utm_campaign=working-angular-storage" target="_blank" class="protect-angular-link">our guide</a>.