Module lazy loading preview in Angular - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is module lazy loading in Angular?

Module lazy loading means loading Angular modules only when the user needs them, not all at once. This helps apps start faster and saves data.

intermediate

How do you define a lazy loaded module route in Angular?

You use the loadChildren property in the route config with a dynamic import, like:
{ path: 'feature', loadChildren: () => import('./feature/feature.module').then(m => m.FeatureModule) }

beginner

Why is lazy loading useful for large Angular apps?

It reduces the initial load time by loading only needed code. This improves user experience, especially on slow networks or devices.

intermediate

What happens if you forget to add a lazy loaded module to the Angular router?

The module won't load when navigating to its route, causing errors or blank pages because Angular doesn't know to load it on demand.

advanced

Can lazy loaded modules share services with the main app module?

Yes, but services provided in lazy loaded modules have their own instance separate from the main app unless provided in root.

Which Angular router property is used to lazy load a module?

A pathMatch

B component

C loadChildren

D redirectTo

The loadChildren property tells Angular to load a module only when its route is accessed.

What is a key benefit of lazy loading modules?

A Faster initial app load

B More CSS styles

C Larger bundle size

D Automatic testing

Lazy loading reduces the initial bundle size, making the app start faster.

How do you write a lazy loading route for a module named 'AdminModule' in Angular?

A { path: 'admin', loadChildren: () => import('./admin/admin.module').then(m => m.AdminModule) }

B { path: 'admin', component: AdminModule }

C { path: 'admin', redirectTo: 'admin' }

D { path: 'admin', loadModule: AdminModule }

The correct syntax uses loadChildren with a dynamic import returning the module.

If a lazy loaded module provides a service, what is true about that service?

A It is shared globally by default

B It has a separate instance from the main app

C It cannot be injected

D It is always singleton

Services in lazy loaded modules get their own instance unless provided in root.

What happens if you navigate to a route without lazy loading set up for its module?

A Nothing happens

B The module loads automatically

C The app reloads

D Angular throws an error or shows a blank page

Without lazy loading configured, Angular cannot find the module and errors occur.

Explain in simple terms what module lazy loading is and why it helps Angular apps.

Think about loading only what you need when you need it.

Describe how to set up a lazy loaded route in Angular with an example.

Look at the route config object and how it imports the module.

Practice

1. What is the main purpose of lazy loading modules in Angular applications?

easy

A. To load modules only when they are needed, improving startup speed

B. To preload all modules at app start for faster navigation

C. To combine all modules into one big file for simplicity

D. To disable routing and load components manually

Solution

1. Step 1: Understand lazy loading concept

   Lazy loading means delaying the loading of parts of the app until they are needed, not all at once.

2. Step 2: Identify the benefit

   This reduces the initial load time and speeds up app startup by loading only essential code first.

3. Final Answer:

   To load modules only when they are needed, improving startup speed -> Option A

4. Quick Check:

   Lazy loading = load on demand [OK]

Hint: Lazy loading means load modules only when needed [OK]

Common Mistakes:

• Thinking lazy loading loads all modules at start
• Confusing lazy loading with preloading
• Believing lazy loading disables routing

2. Which of the following is the correct syntax to lazy load a module named AdminModule located at ./admin/admin.module.ts in Angular routing?

easy

A. { path: 'admin', loadChildren: () => import('./admin/admin.module').then(m => m.AdminModule) }

B. { path: 'admin', loadChildren: './admin/admin.module#AdminModule' }

C. { path: 'admin', component: AdminModule }

D. { path: 'admin', loadChildren: () => AdminModule }

Solution

1. Step 1: Recall Angular lazy loading syntax

   Since Angular 8+, lazy loading uses dynamic import syntax with loadChildren as a function returning a promise.

2. Step 2: Match syntax to options

   { path: 'admin', loadChildren: () => import('./admin/admin.module').then(m => m.AdminModule) } uses the correct arrow function with import and then to get the module class.

3. Final Answer:

   { path: 'admin', loadChildren: () => import('./admin/admin.module').then(m => m.AdminModule) } -> Option A

4. Quick Check:

   Dynamic import with arrow function = { path: 'admin', loadChildren: () => import('./admin/admin.module').then(m => m.AdminModule) } [OK]

Hint: Use dynamic import with arrow function for lazy loading [OK]

Common Mistakes:

• Using string syntax with # which is deprecated
• Assigning component instead of loadChildren
• Calling loadChildren without import

3. Given this route configuration snippet:

{ path: 'shop', loadChildren: () => import('./shop/shop.module').then(m => m.ShopModule) }

What happens when the user navigates to /shop for the first time?

medium

A. The ShopModule is loaded immediately when the app starts

B. The ShopModule is never loaded and navigation fails

C. The ShopModule is loaded asynchronously only at navigation time

D. The ShopModule is loaded synchronously blocking the UI

Solution

1. Step 1: Understand lazy loading behavior on navigation

   With lazy loading, the module is not loaded at app start but only when the route is visited.

2. Step 2: Apply to given route

   When user navigates to '/shop', Angular triggers the dynamic import to load ShopModule asynchronously.

3. Final Answer:

   The ShopModule is loaded asynchronously only at navigation time -> Option C

4. Quick Check:

   Lazy load triggers on first navigation [OK]

Hint: Lazy loaded modules load on first route visit, not app start [OK]

Common Mistakes:

• Assuming module loads at app start
• Thinking navigation fails without preloading
• Believing loading blocks UI synchronously

4. Consider this incorrect route configuration:

{ path: 'dashboard', loadChildren: './dashboard/dashboard.module#DashboardModule' }

What is the main issue with this code in Angular 17+?

medium

A. DashboardModule should be imported directly, not lazy loaded

B. Missing component property for the route

C. The path should be an array, not a string

D. Using string syntax for loadChildren is deprecated and causes errors

Solution

1. Step 1: Identify deprecated syntax

   Angular versions 8+ require dynamic import syntax for lazy loading, not string with #.

2. Step 2: Explain impact

   Using string syntax causes build or runtime errors because Angular no longer supports it.

3. Final Answer:

   Using string syntax for loadChildren is deprecated and causes errors -> Option D

4. Quick Check:

   String syntax deprecated = Using string syntax for loadChildren is deprecated and causes errors [OK]

Hint: Avoid string syntax; use dynamic import for loadChildren [OK]

Common Mistakes:

• Thinking component is required with loadChildren
• Confusing path type with string vs array
• Believing direct import is mandatory for lazy loading

5. You want to lazy load a feature module ProfileModule only when the user navigates to /profile. The module file is at ./profile/profile.module.ts. Which of the following route configurations correctly implements this with Angular 17+ standards and ensures accessibility and performance?

hard

A. { path: 'profile', loadChildren: () => import('./profile/profile.module').ProfileModule }

B. { path: 'profile', loadChildren: () => import('./profile/profile.module').then(m => m.ProfileModule) }

C. { path: 'profile', component: ProfileModule }

D. { path: 'profile', loadChildren: './profile/profile.module#ProfileModule' }

Solution

1. Step 1: Use correct dynamic import syntax

   Angular 17+ requires loadChildren as a function returning a promise with dynamic import and then to access the module class.

2. Step 2: Verify accessibility and performance

   Lazy loading delays module load until navigation, improving performance. Using this syntax supports Angular's router and accessibility features.

3. Final Answer:

   { path: 'profile', loadChildren: () => import('./profile/profile.module').then(m => m.ProfileModule) } -> Option B

4. Quick Check:

   Dynamic import + then + lazy load = { path: 'profile', loadChildren: () => import('./profile/profile.module').then(m => m.ProfileModule) } [OK]

Hint: Always use dynamic import with then for lazy loading modules [OK]

Common Mistakes:

• Using deprecated string syntax
• Assigning component instead of loadChildren
• Missing .then() after import