Async components for lazy loading in Vue - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define an async component using Vue's defineAsyncComponent.

Vue

import { defineAsyncComponent } from 'vue';

const AsyncComp = [1](() => import('./MyComponent.vue'));

Drag options to blanks, or click blank then click option'

AcreateAsyncComponent

BdefineAsyncComponent

CasyncComponent

DloadAsyncComponent

Attempts:

3 left

💡 Hint

Common Mistakes

Using a non-existent function like createAsyncComponent.

Trying to import the component directly without wrapping.

Vue provides defineAsyncComponent to create async components for lazy loading.

2fill in blank

medium

Complete the code to register the async component in the components option.

Vue

export default {
  components: {
    AsyncComp: [1]
  }
};

Drag options to blanks, or click blank then click option'

AAsyncComp()

BimportAsyncComp

CAsyncComp

DdefineAsyncComponent

Attempts:

3 left

💡 Hint

Common Mistakes

Adding parentheses which calls the component instead of referencing it.

Using the import function name instead of the component variable.

When registering components, use the component variable name without parentheses.

3fill in blank

hard

Fix the error in the async component import syntax.

Vue

const AsyncComp = defineAsyncComponent(() => [1]('./MyComponent.vue'));

Drag options to blanks, or click blank then click option'

Aimport

Brequire

Cfetch

Dload

Attempts:

3 left

💡 Hint

Common Mistakes

Using require which is not supported in ES modules.

Using fetch which is for network requests, not module imports.

Dynamic import is used to lazy load components in Vue async components.

4fill in blank

hard

Fill both blanks to add a loading component and error component to the async component options.

Vue

const AsyncComp = defineAsyncComponent({
  loader: () => import('./MyComponent.vue'),
  loadingComponent: [1],
  errorComponent: [2]
});

Drag options to blanks, or click blank then click option'

ALoadingSpinner

BErrorMessage

CMyComponent

DAsyncComp

Attempts:

3 left

💡 Hint

Common Mistakes

Using the main component itself as loading or error component.

Using the async component variable name instead of actual components.

You can specify components to show while loading or on error by setting loadingComponent and errorComponent.

5fill in blank

hard

Fill all three blanks to create an async component with delay, timeout, and custom error component.

Vue

const AsyncComp = defineAsyncComponent({
  loader: () => import('./MyComponent.vue'),
  delay: [1],
  timeout: [2],
  errorComponent: [3]
});

Drag options to blanks, or click blank then click option'

A300

B5000

CErrorMessage

DLoadingSpinner

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing delay and timeout values.

Using loading component as error component.

Delay and timeout are numbers in milliseconds. The errorComponent is a Vue component to show on failure.

Practice

1. What is the main purpose of using defineAsyncComponent in Vue?

easy

A. To load a component only when it is needed, improving app performance

B. To define a component that updates automatically on data change

C. To create a component that runs only on the server side

D. To make a component that never re-renders after first load

Solution

1. Step 1: Understand what lazy loading means

   Lazy loading means loading something only when it is needed, not before.

2. Step 2: Connect lazy loading to defineAsyncComponent

   This function helps Vue load components only when they are required, saving resources.

3. Final Answer:

   To load a component only when it is needed, improving app performance -> Option A

4. Quick Check:

   Lazy loading = load on demand [OK]

Hint: Async components load only when needed, boosting speed [OK]

Common Mistakes:

• Thinking it updates components automatically
• Confusing with server-side rendering
• Believing it prevents re-renders forever

2. Which of the following is the correct syntax to create an async component in Vue 3?

easy

A. const AsyncComp = async () => import('./MyComp.vue')

B. const AsyncComp = defineAsyncComponent(() => import('./MyComp.vue'))

C. const AsyncComp = defineComponent(async () => import('./MyComp.vue'))

D. const AsyncComp = createAsyncComponent('./MyComp.vue')

Solution

1. Step 1: Recall the Vue 3 async component syntax

   Vue 3 uses defineAsyncComponent with a function returning an import promise.

2. Step 2: Match the syntax with options

   const AsyncComp = defineAsyncComponent(() => import('./MyComp.vue')) matches the correct pattern: defineAsyncComponent(() => import('...')).

3. Final Answer:

   const AsyncComp = defineAsyncComponent(() => import('./MyComp.vue')) -> Option B

4. Quick Check:

   Correct async syntax = defineAsyncComponent + import [OK]

Hint: Use defineAsyncComponent with arrow function returning import [OK]

Common Mistakes:

• Using async arrow function without defineAsyncComponent
• Using defineComponent instead of defineAsyncComponent
• Calling a non-existent createAsyncComponent function

3. Given this Vue code snippet, what will be rendered initially?

const AsyncComp = defineAsyncComponent(() => new Promise(resolve => {
  setTimeout(() => resolve({ template: '
Loaded!
' }), 2000)
}))

export default {
  components: { AsyncComp },
  template: `
    
    
Loading...
  `
}

medium

A. Loading... (fallback content) for 2 seconds, then Loaded!

B. Loaded! immediately without delay

C. Nothing renders until the component loads

D. An error because Suspense cannot be used with async components

Solution

1. Step 1: Understand Suspense fallback behavior

   Suspense shows fallback content while async component loads.

2. Step 2: Analyze the async component delay

   The component resolves after 2 seconds, so fallback shows first.

3. Final Answer:

   Loading... (fallback content) for 2 seconds, then Loaded! -> Option A

4. Quick Check:

   Suspense fallback shows during async load [OK]

Hint: Suspense fallback shows until async component resolves [OK]

Common Mistakes:

• Expecting immediate component render
• Thinking nothing shows during loading
• Believing Suspense cannot wrap async components

4. Identify the error in this async component usage:

import { defineAsyncComponent } from 'vue'

const AsyncComp = defineAsyncComponent(() => import('./MyComp.vue'))

export default {
  components: { AsyncComp },
  template: `
`
}

medium

A. Async component must be registered globally, not locally

B. The template uses instead of self-closing

C. Missing Suspense wrapper to handle loading state

D. The import path './MyComp.vue' is invalid syntax

Solution

1. Step 1: Check async component usage rules

   Async components should be wrapped in <Suspense> to show fallback during loading.

2. Step 2: Analyze the given code

   The code lacks a <Suspense> wrapper, so no loading state is handled.

3. Final Answer:

   Missing Suspense wrapper to handle loading state -> Option C

4. Quick Check:

   Async components need Suspense for loading fallback [OK]

Hint: Always wrap async components in Suspense for loading UI [OK]

Common Mistakes:

• Thinking self-closing tags are mandatory
• Believing async components must be global
• Assuming import path syntax is wrong

5. You want to lazy load two components, CompA and CompB, but only show CompB after CompA finishes loading. How can you achieve this using Vue async components and Suspense?

hard

A. Wrap CompA in Suspense, and inside its default slot, include CompB as a normal component

B. Use defineAsyncComponent for both, wrap both in a single Suspense, and use v-if to show CompB only after CompA loads

C. Load both components with defineAsyncComponent and render them side by side without Suspense

D. Wrap CompA in a Suspense with fallback, then in CompA's mounted hook, render CompB inside another Suspense

Solution

1. Step 1: Understand the loading order requirement

   You want CompB to appear only after CompA finishes loading.

2. Step 2: Use sequential triggering with lifecycle

   Wrap CompA in Suspense; in CompA's mounted hook, dynamically render CompB (async) inside its own Suspense for true sequential loading.

3. Step 3: Why other options fail

   Wrapping both in a single Suspense loads them in parallel (shows both after slowest finishes); loading side-by-side without Suspense skips fallback and loads parallel; including normal CompB in CompA's default slot loads it immediately upon CompA resolution.

4. Final Answer:

   Wrap CompA in a Suspense with fallback, then in CompA's mounted hook, render CompB inside another Suspense -> Option D

5. Quick Check:

   Sequential async = trigger next in mounted [OK]

Hint: Trigger next async component in mounted hook for sequential loading [OK]

Common Mistakes:

• Using single Suspense for parallel loading
• Skipping Suspense for async components
• Treating second component as normal (non-async)