Higher-order components concept in Vue - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a Higher-Order Component (HOC) in Vue?

A Higher-Order Component is a function that takes a component and returns a new enhanced component, adding extra behavior or data without modifying the original component directly.

beginner

How does a Higher-Order Component differ from a regular component in Vue?

A regular component defines UI and behavior directly, while a Higher-Order Component wraps another component to add or modify its behavior without changing its code.

intermediate

Why use Higher-Order Components in Vue?

They help reuse logic across multiple components, keep code DRY (Don't Repeat Yourself), and separate concerns by enhancing components without duplication.

intermediate

What is a simple example of a Higher-Order Component in Vue?

A function that takes a component and returns a new component that adds a loading spinner while data is loading, then shows the original component once ready.

intermediate

Can Higher-Order Components affect component props in Vue?

Yes, HOCs can modify, add, or filter props passed to the wrapped component to control or enhance its behavior.

What does a Higher-Order Component (HOC) do in Vue?

A Wraps a component to add extra behavior

B Creates a new Vue instance

C Defines a template for a component

D Directly modifies the DOM

A HOC wraps a component to enhance or add behavior without changing the original component.

Which of these is a benefit of using Higher-Order Components?

A Making components slower

B Increasing component size

C Reusing logic across components

D Removing component props

HOCs help reuse logic and keep code clean by sharing behavior.

How does a Higher-Order Component receive the component it enhances?

A As a function argument

B By importing it globally

C Through Vuex store

D By modifying the template

HOCs are functions that take a component as an argument and return a new component.

Can Higher-Order Components in Vue modify the props passed to the wrapped component?

A Only in class components

B No, props are always fixed

C Only if using Vuex

D Yes, they can add or change props

HOCs can control or enhance props passed to the wrapped component.

Which Vue feature is commonly used inside a Higher-Order Component to render the wrapped component?

A v-model directive

B <component :is="WrappedComponent" />

C v-for directive

D Vue Router

The syntax dynamically renders the wrapped component inside the HOC.

Explain what a Higher-Order Component is in Vue and why it is useful.

Think about wrapping a component to add features.

Describe a simple example scenario where you might use a Higher-Order Component in Vue.

Consider a feature you want to add to many components without repeating code.

Practice

1. What is the main purpose of a higher-order component (HOC) in Vue?

easy

A. To create a new Vue instance from scratch

B. To replace the Vue router with a new navigation system

C. To wrap a component and add shared logic or styling

D. To directly manipulate the DOM elements inside a component

Solution

1. Step 1: Understand what HOCs do

   Higher-order components wrap existing components to add extra features without changing the original component.

2. Step 2: Identify the correct purpose

   Among the options, only wrapping a component to add shared logic or styling matches the HOC concept.

3. Final Answer:

   To wrap a component and add shared logic or styling -> Option C

4. Quick Check:

   HOC purpose = wrap and add logic [OK]

Hint: HOCs wrap components to add features without changing them [OK]

Common Mistakes:

• Confusing HOCs with routing or Vue instance creation
• Thinking HOCs manipulate DOM directly
• Believing HOCs replace components instead of wrapping

2. Which of the following is the correct syntax to create a higher-order component in Vue 3 using the Composition API?

easy

A. const withLogger = (WrappedComponent) => { return { setup() { return () => h(WrappedComponent) } } }

B. const withLogger = (WrappedComponent) => { return WrappedComponent.setup() }

C. const withLogger = (WrappedComponent) => { return new Vue({ render: () => h(WrappedComponent) }) }

D. const withLogger = (WrappedComponent) => { return () => WrappedComponent }

Solution

1. Step 1: Review HOC syntax in Vue 3

   A HOC is a function that returns a new component wrapping the original. Using setup and render function with h() is correct.

2. Step 2: Check each option

   const withLogger = (WrappedComponent) => { return { setup() { return () => h(WrappedComponent) } } } returns a component object with setup returning a render function that renders WrappedComponent, which is correct.

3. Final Answer:

   const withLogger = (WrappedComponent) => { return { setup() { return () => h(WrappedComponent) } } } -> Option A

4. Quick Check:

   HOC returns component with setup and render [OK]

Hint: HOCs return a new component wrapping the original with setup [OK]

Common Mistakes:

• Calling setup() directly instead of returning a component
• Using new Vue() in Vue 3 Composition API
• Returning the component function without wrapping

3. Given this HOC code in Vue 3:

const withBorder = (WrappedComponent) => {
  return {
    setup() {
      return () => h('div', { style: { border: '2px solid red' } }, [h(WrappedComponent)])
    }
  }
}

const Base = { template: '
Hello
' }
const Enhanced = withBorder(Base)

What will <Enhanced /> render?

medium

A. Hello

B. Hello

C. Hello

D. Error: h() cannot wrap components

Solution

1. Step 1: Understand the HOC rendering

   The HOC wraps the WrappedComponent inside a div with a red border style.

2. Step 2: Predict the rendered output

   Rendering <Enhanced /> produces a div with red border containing the Base component's paragraph.

3. Final Answer:

   <div style="border: 2px solid red"><p>Hello</p></div> -> Option B

4. Quick Check:

   HOC adds border div around component [OK]

Hint: HOCs wrap output in extra elements or logic [OK]

Common Mistakes:

• Ignoring the wrapping div and expecting only <p>
• Thinking h() cannot wrap components
• Assuming no styles are applied

4. Identify the error in this Vue 3 HOC code:

const withTitle = (WrappedComponent) => {
  return {
    setup() {
      return () => h(WrappedComponent)
    }
  }
}

const Base = { template: '
Hi
' }
const Enhanced = withTitle(Base)

// Usage: <Enhanced title="Welcome" />

What is the problem?

medium

A. The HOC does not pass props to WrappedComponent

B. The HOC should use a class component instead

C. The Base component must be a function, not an object

D. The setup function cannot return a render function

Solution

1. Step 1: Check prop forwarding in HOC

   The HOC returns WrappedComponent but does not forward any props it receives.

2. Step 2: Understand consequence

   When using <Enhanced title="Welcome" />, the title prop is lost because it's not passed down.

3. Final Answer:

   The HOC does not pass props to WrappedComponent -> Option A

4. Quick Check:

   Props must be forwarded in HOCs [OK]

Hint: Always forward props from HOC to wrapped component [OK]

Common Mistakes:

• Forgetting to pass props in render function
• Thinking setup can't return render function
• Believing Base must be a function component

5. You want to create a higher-order component withLoading that shows a loading message while data is loading, then renders the wrapped component with the loaded data. Which approach correctly combines HOC logic with Vue 3 Composition API?

hard

A. Create a mixin that adds loading state and use it inside the wrapped component

B. Modify the wrapped component's template directly to add loading message

C. Use a global variable to track loading and conditionally render wrapped component

D. Return a component with setup() that uses ref for loading state, fetches data, and renders loading or wrapped component with props

Solution

1. Step 1: Understand HOC with loading logic

   The HOC should manage loading state internally and decide what to render based on it.

2. Step 2: Identify correct Vue 3 pattern

   Using setup with ref for loading, fetching data, and returning a render function that shows loading or wrapped component with data is correct.

3. Final Answer:

   Return a component with setup() that uses ref for loading state, fetches data, and renders loading or wrapped component with props -> Option D

4. Quick Check:

   HOC manages state and renders conditionally [OK]

Hint: Use setup with state and conditional render in HOC [OK]

Common Mistakes:

• Changing wrapped component template directly
• Using global variables for state
• Confusing mixins with HOCs