Why context shares data without prop drilling in Svelte - Quick Recap

Recall & Review

beginner

What is prop drilling in Svelte?

Prop drilling is when you pass data through many layers of components just to reach a deeply nested child component.

beginner

How does Svelte's context API help avoid prop drilling?

Svelte's context API lets a parent component provide data that any nested child can access directly, without passing props through every intermediate component.

intermediate

Which Svelte functions are used to share and access context data?

The setContext function shares data from a parent, and getContext lets a child component access that data.

intermediate

Why is using context better than prop drilling for deeply nested components?

Context reduces code clutter and makes components simpler by avoiding the need to pass props through components that don't use the data.

advanced

Can context data in Svelte be reactive and update child components automatically?

Yes, if the context data is a Svelte store, child components accessing it will reactively update when the store changes.

What problem does Svelte's context API solve?

A Passing data without prop drilling

B Styling components globally

C Handling user events

D Managing component lifecycle

Svelte's context API allows sharing data directly with nested components, avoiding prop drilling.

Which function sets data in Svelte's context?

A getContext

B setContext

C useContext

D createContext

setContext is used to provide data to the context in a parent component.

If a child component needs data from context, which function does it use?

A getContext

B useState

C setContext

D subscribe

getContext retrieves data from the context inside a child component.

What happens if you try to access context data in a component without a matching setContext?

A It returns an empty object

B It throws an error

C It returns null

D It returns undefined

If no context is set for the key, getContext returns undefined.

How can context data be reactive in Svelte?

A By using lifecycle hooks

B By using plain objects

C By using a Svelte store as context data

D By passing props instead

Using a Svelte store in context makes data reactive and updates components automatically.

Explain how Svelte's context API helps avoid prop drilling and why this is useful.

Think about passing data through many layers versus direct access.

Describe how you would make context data reactive in Svelte and why that matters.

Consider what happens when data changes and components update.

Practice

1. Why does Svelte's context API help avoid prop drilling?

easy

A. Because it allows sharing data directly between components without passing props through every level

B. Because it automatically updates the DOM without any code

C. Because it replaces the need for events between components

D. Because it forces all components to use the same state variable

Solution

1. Step 1: Understand prop drilling

   Prop drilling means passing data through many intermediate components even if they don't need it.

2. Step 2: How context helps

   Context lets a parent share data directly with any child, skipping intermediate components.

3. Final Answer:

   Because it allows sharing data directly between components without passing props through every level -> Option A

4. Quick Check:

   Context avoids prop drilling = D [OK]

Hint: Context shares data directly, skipping intermediate props [OK]

Common Mistakes:

• Thinking context replaces events
• Believing context auto-updates DOM
• Assuming all components share one state variable

2. Which Svelte function is used to provide context data to child components?

easy

A. getContext

B. setContext

C. useContext

D. provideContext

Solution

1. Step 1: Identify context provider function

   In Svelte, setContext is used in a parent to provide data.

2. Step 2: Differentiate from consumer function

   getContext is used in children to access that data, not to provide it.

3. Final Answer:

   setContext -> Option B

4. Quick Check:

   Provide context = setContext [OK]

Hint: Use setContext to provide data, getContext to consume [OK]

Common Mistakes:

• Confusing getContext as provider
• Using React's useContext in Svelte
• Assuming provideContext exists

3. What will be logged by the child component in this Svelte code?

/* Parent.svelte */



/* Child.svelte */

medium

A. Anna

B. undefined

C. Error: getContext not found

D. null

Solution

1. Step 1: Understand setContext usage

   The parent sets context with key 'user' and value { name: 'Anna' }.

2. Step 2: Child accesses context

   The child calls getContext('user') and gets the object, then logs user.name which is 'Anna'.

3. Final Answer:

   Anna -> Option A

4. Quick Check:

   getContext returns provided data = Anna [OK]

Hint: getContext returns parent's data by key [OK]

Common Mistakes:

• Expecting undefined if not passed as prop
• Confusing getContext with props
• Thinking getContext throws error if key missing

4. Identify the error in this Svelte code using context:

/* Parent.svelte */


/* Child.svelte */

medium

A. Context keys must be numbers, not strings

B. setContext must be called inside onMount lifecycle

C. getContext cannot be used in child components

D. The key used in getContext has different capitalization than setContext

Solution

1. Step 1: Compare keys in setContext and getContext

   Parent uses 'theme' (lowercase), child uses 'Theme' (capital T). Keys are case-sensitive.

2. Step 2: Effect of key mismatch

   Because keys differ, getContext returns undefined, causing unexpected behavior.

3. Final Answer:

   The key used in getContext has different capitalization than setContext -> Option D

4. Quick Check:

   Context keys are case-sensitive = A [OK]

Hint: Match context keys exactly, including case [OK]

Common Mistakes:

• Thinking setContext must be in onMount
• Believing getContext can't be used in children
• Assuming keys can be numbers only

5. In a nested Svelte component tree, how does context help when a deeply nested child needs data from a distant ancestor without prop drilling?

/* Grandparent.svelte */


/* Parent.svelte */



/* Child.svelte */

Why is this approach better than passing props through Parent.svelte?

hard

A. Because context automatically updates props in Parent.svelte

B. Because context duplicates data in every component for safety

C. Because context allows Child.svelte to access data directly without Parent.svelte needing to pass props

D. Because context requires less code but still passes props through Parent.svelte

Solution

1. Step 1: Understand nested component data flow

   Without context, data must be passed through Parent.svelte as props even if it doesn't use it.

2. Step 2: How context simplifies this

   Context lets Child.svelte get data directly from Grandparent.svelte, skipping Parent.svelte entirely.

3. Final Answer:

   Because context allows Child.svelte to access data directly without Parent.svelte needing to pass props -> Option C

4. Quick Check:

   Context skips intermediate props = B [OK]

Hint: Context skips intermediate components, direct data access [OK]

Common Mistakes:

• Thinking context updates props automatically
• Believing context duplicates data everywhere
• Assuming context still passes props through all components