Reactive blocks for side effects in Svelte - Step-by-Step Execution

Concept Flow - Reactive blocks for side effects

Variable changes

↓

Reactive block runs

↓

Side effect happens

↓

Wait for next change

↩Back to Variable changes

When a variable changes, the reactive block runs automatically to perform side effects, then waits for the next change.

Execution Sample

Svelte

let count = 0;

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

count = 1;
count = 2;

This code logs the count value whenever it changes using a reactive block.

Execution Table

Step	Variable 'count'	Reactive Block Triggered	Action	Output
1	0	Yes (initial run)	Log 'Count is 0'	Count is 0
2	1	Yes	Log 'Count is 1'	Count is 1
3	2	Yes	Log 'Count is 2'	Count is 2
4	2	No	No action

💡 No more changes to 'count', reactive block does not run again.

Variable Tracker

Variable	Start	After 1	After 2	Final
count	0	1	2	2

Key Moments - 2 Insights

Why does the reactive block run immediately at the start even before any variable assignment?

The reactive block runs once initially to set up side effects with the current variable value, as shown in Step 1 of the execution_table.

Does the reactive block run if the variable value does not change?

No, the reactive block only runs when the variable changes. Step 4 shows no run because 'count' stayed at 2.

Visual Quiz - 3 Questions

Look at the execution table, what is logged when 'count' changes to 1?

A Count is 2

B Count is 0

C Count is 1

D No log

💡 Hint

Check Step 2 in the execution_table where 'count' is 1 and the reactive block logs the output.

At which step does the reactive block NOT run?

A Step 4

B Step 1

C Step 3

D Step 2

💡 Hint

Look at the 'Reactive Block Triggered' column in the execution_table for Step 4.

If we set 'count = 2' twice in a row, how many times does the reactive block run?

A Twice

B Once

C Three times

D Never

💡 Hint

Refer to the variable_tracker and execution_table showing reactive block runs only on value changes.

Concept Snapshot

Svelte reactive blocks run side effects automatically when variables change.
Syntax: $: { /* side effect code */ }
Runs once initially, then on every variable change.
No run if variable value stays the same.
Used for logging, DOM updates, or other side effects.

Full Transcript

In Svelte, reactive blocks start by running once with the current variable values. When a variable changes, the reactive block runs again to perform side effects like logging. If the variable does not change, the block does not run. This behavior helps keep side effects in sync with data changes automatically.

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