Reactive blocks for side effects in Svelte - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a reactive block in Svelte?

A reactive block in Svelte is a special code section that runs automatically whenever the variables it depends on change. It is used to perform side effects or update values reactively.

beginner

How do you write a reactive block in Svelte?

You write a reactive block using the $: label followed by a block of code inside curly braces. For example: $: { console.log(count); } runs whenever count changes.

intermediate

Why use reactive blocks for side effects in Svelte?

Reactive blocks let you run code automatically when data changes, like updating the DOM, logging, or fetching data. This keeps your code simple and avoids manual event handling.

intermediate

Can reactive blocks depend on multiple variables?

Yes, reactive blocks run whenever any variable they use changes. You can use multiple variables inside the block, and Svelte tracks all dependencies automatically.

advanced

What happens if a reactive block updates a variable it depends on?

If a reactive block updates a variable it depends on, it can cause the block to run again, potentially creating an infinite loop. You should avoid such patterns or add conditions to stop looping.

How do you start a reactive block in Svelte?

A $:

B reactive()

C useEffect()

D onMount()

Reactive blocks in Svelte start with the $: label.

When does a reactive block run?

A Whenever any variable inside it changes

B Only once when the component loads

C When the user clicks a button

D Only when explicitly called

Reactive blocks run automatically whenever any variable they use changes.

Which of these is a good use for a reactive block?

A Writing HTML markup

B Styling elements with CSS

C Defining component props

D Fetching data when a variable changes

Reactive blocks are great for side effects like fetching data when variables change.

What risk should you watch for when updating variables inside a reactive block?

A Memory leaks

B Infinite loops

C Syntax errors

D Slow rendering

Updating a variable inside a reactive block that depends on it can cause infinite loops.

Can reactive blocks access variables declared outside them?

A No, only inside variables

B Only if passed as props

C Yes, and they track changes automatically

D Only if declared as constants

Reactive blocks can use any variables in scope and track their changes automatically.

Explain how reactive blocks help manage side effects in Svelte components.

Think about how Svelte tracks variables and runs code when they update.

Describe a potential problem when a reactive block updates a variable it depends on and how to avoid it.

Consider what happens if the block triggers itself continuously.

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