Reactive blocks for side effects in Svelte - Performance & Optimization

Performance: Reactive blocks for side effects

MEDIUM IMPACT

This affects how efficiently the browser updates the UI and runs side effects when reactive data changes.

Running side effects when reactive data changes

Svelte

let count = 0;

$: if (count !== 0) {
  console.log('Count changed:', count);
  // side effect runs only when count changes and meets condition
}

The reactive block runs conditionally, reducing unnecessary executions and improving responsiveness.

📈 Performance GainReduces side effect runs by filtering, improving INP and reducing main thread blocking.

Running side effects when reactive data changes

Svelte

let count = 0;

$: {
  console.log('Count changed:', count);
  // heavy side effect here
}

This reactive block runs on every change of any reactive dependency inside, potentially causing unnecessary side effects and blocking rendering.

📉 Performance CostTriggers multiple side effect executions and can block rendering for tens of milliseconds if side effects are heavy.

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Unconditional reactive block with heavy side effects	Multiple DOM updates if side effects modify DOM	Multiple reflows if layout changes	High paint cost due to frequent updates	[X] Bad
Conditional reactive block limiting side effects	Minimal DOM updates only when needed	Single or no reflows if no layout changes	Low paint cost due to fewer updates	[OK] Good

Rendering Pipeline

Reactive blocks trigger JavaScript code execution when reactive dependencies change, which can cause style recalculations and layout if DOM updates happen inside. Efficient reactive blocks minimize unnecessary executions and DOM changes.

→JavaScript Execution

→Style Calculation

→Layout

→Paint

⚠️ BottleneckJavaScript Execution and Layout when side effects cause DOM changes

Core Web Vital Affected

INP

This affects how efficiently the browser updates the UI and runs side effects when reactive data changes.

Optimization Tips

1Run side effects in reactive blocks only when necessary using conditions.

2Avoid heavy computations or DOM changes inside reactive blocks without filtering.

3Use DevTools Performance panel to identify and optimize costly reactive block executions.

Performance Quiz - 3 Questions

What is the main performance risk of running side effects in reactive blocks without conditions?

A The browser caches the side effects, so performance is not affected.

B Side effects only run once, so no performance risk exists.

C Side effects run too often, blocking the main thread and causing slow input response.

D Reactive blocks automatically batch side effects, so no extra cost.

DevTools: Performance

How to check: Record a performance profile while interacting with the component. Look for long tasks caused by reactive block executions and check if they coincide with unnecessary side effect runs.

What to look for: Look for frequent scripting time spikes and layout shifts caused by reactive blocks running too often.

Practice

1. What does a reactive block labeled with $: do in Svelte?

easy

A. It runs the code inside automatically whenever referenced variables change.

B. It defines a new component in Svelte.

C. It creates a CSS style block scoped to the component.

D. It pauses the component rendering until a condition is met.

Solution

1. Step 1: Understand the role of $: in Svelte

   The $: label creates a reactive block that runs code automatically when variables it uses change.

2. Step 2: Identify the behavior of reactive blocks

   Reactive blocks are used for side effects like logging or updating related data, triggered by variable changes.

3. Final Answer:

   It runs the code inside automatically whenever referenced variables change. -> Option A

4. Quick Check:

   Reactive block = auto-run on variable change [OK]

Hint: Reactive blocks run code when variables they use change [OK]

Common Mistakes:

• Thinking reactive blocks define components
• Confusing reactive blocks with CSS or styling
• Believing reactive blocks pause rendering

2. Which of the following is the correct syntax to create a reactive block in Svelte?

easy

A. $: { console.log(count); }

B. reactive: { console.log(count); }

C. @reactive { console.log(count); }

D. #: { console.log(count); }

Solution

1. Step 1: Recall the syntax for reactive blocks in Svelte

   Svelte uses the $: label followed by a block or statement to create reactive code.

2. Step 2: Match the correct syntax

   $: { console.log(count); } uses $: { ... } which is the correct way to write a reactive block.

3. Final Answer:

   $: { console.log(count); } -> Option A

4. Quick Check:

   Reactive block syntax = $: [OK]

Hint: Look for the $: label before the block [OK]

Common Mistakes:

• Using 'reactive:' or '@reactive' which are invalid
• Confusing with other symbols like '#' or '@'
• Missing the $: label entirely

3. Consider this Svelte code:

let count = 0;

$: console.log(`Count is ${count}`);

function increment() {
  count += 1;
}

What happens when the increment() function is called?

medium

A. The console logs 'Count is 0' every time.

B. Nothing is logged because reactive blocks don't run on function calls.

C. The console logs 'Count is 1', 'Count is 2', etc., each time increment is called.

D. An error occurs because reactive blocks cannot use template strings.

Solution

1. Step 1: Understand reactive block behavior with variable changes

   The reactive block logs the current value of count whenever count changes.

2. Step 2: Analyze what happens on calling increment()

   Calling increment() increases count by 1, triggering the reactive block to log the updated count.

3. Final Answer:

   The console logs 'Count is 1', 'Count is 2', etc., each time increment is called. -> Option C

4. Quick Check:

   Reactive block logs on variable change = The console logs 'Count is 1', 'Count is 2', etc., each time increment is called. [OK]

Hint: Reactive blocks run when variables they use change [OK]

Common Mistakes:

• Thinking reactive blocks run only once
• Believing reactive blocks ignore function-triggered changes
• Assuming template strings cause errors

4. Identify the error in this Svelte reactive block code:

let name = 'Alice';

$: {
  console.log('Name is ' + Name);
}

medium

A. Reactive blocks cannot use console.log.

B. Variable Name is undefined due to case sensitivity.

C. Missing semicolon after let name declaration.

D. Reactive blocks must be inside a function.

Solution

1. Step 1: Check variable usage inside reactive block

   The reactive block uses Name with uppercase 'N', but the variable declared is name lowercase.

2. Step 2: Understand JavaScript case sensitivity

   JavaScript variables are case sensitive, so Name is undefined, causing a runtime error.

3. Final Answer:

   Variable Name is undefined due to case sensitivity. -> Option B

4. Quick Check:

   Case sensitivity error = Variable Name is undefined due to case sensitivity. [OK]

Hint: Check variable names for exact case match [OK]

Common Mistakes:

• Assuming console.log is disallowed in reactive blocks
• Thinking semicolon omission causes error here
• Believing reactive blocks must be inside functions

5. You want to update a variable doubleCount automatically whenever count changes, using a reactive block. Which code correctly achieves this?

let count = 1;
let doubleCount;

// Choose the correct reactive block

hard

A. $: doubleCount = count / 2;

B. $: { doubleCount = count + 2; }

C. $: doubleCount == count * 2;

D. $: doubleCount = count * 2;

Solution

1. Step 1: Understand the goal to update doubleCount as twice count

   The reactive block should assign doubleCount to count * 2 whenever count changes.

2. Step 2: Evaluate each option for correctness

   $: doubleCount = count * 2; correctly assigns doubleCount = count * 2;. $: { doubleCount = count + 2; } adds 2 instead of multiplying. $: doubleCount == count * 2; uses comparison operator == instead of assignment. $: doubleCount = count / 2; divides instead of multiplying.

3. Final Answer:

   $: doubleCount = count * 2; -> Option D

4. Quick Check:

   Correct reactive assignment = $: doubleCount = count * 2; [OK]

Hint: Use = for assignment, * 2 for doubling [OK]

Common Mistakes:

• Using == instead of = for assignment
• Adding instead of multiplying
• Dividing instead of multiplying