Array and object reactivity gotchas in Svelte - Cheat Sheet & Quick Revision

Recall & Review

beginner

Why does directly modifying an array element like arr[0] = 5 not trigger reactivity in Svelte?

Svelte's reactivity tracks assignments to variables, not mutations inside arrays or objects. Changing arr[0] does not reassign arr, so Svelte does not detect the change automatically.

beginner

How can you make Svelte react to changes inside an array after modifying an element?

After changing an element, reassign the array to itself like arr = arr. This tells Svelte the variable changed and triggers updates.

intermediate

What is a common gotcha when updating properties inside an object in Svelte?

Modifying a property like obj.prop = value does not trigger reactivity because the object reference stays the same. You must reassign the object, e.g., obj = {...obj}, to notify Svelte.

intermediate

Why is using methods like push() or splice() on arrays tricky in Svelte reactivity?

These methods mutate the array in place without changing its reference. Svelte won't detect changes unless you reassign the array after mutation.

advanced

What is the recommended pattern to update nested objects reactively in Svelte?

Create a new object with updated nested properties using spread syntax, then reassign the main object. For example, obj = {...obj, nested: {...obj.nested, key: value}}.

In Svelte, which action will trigger reactivity after changing an array element?

A Just change the element, e.g., arr[0] = 5

B Reassign the array variable to itself, e.g., arr = arr

C Call arr.push(5)

D No action needed, Svelte detects all changes automatically

Svelte only tracks assignments to variables. Changing an element alone does not trigger reactivity, but reassigning the array variable does.

Which method does NOT trigger Svelte reactivity by itself when used on an array?

A arr.push(newItem)

B arr = arr.filter(...)

C arr = arr

D arr = [...arr, newItem]

arr.push() mutates the array in place without changing its reference, so Svelte won't detect the change unless you reassign the array.

How do you trigger reactivity after changing a property inside an object in Svelte?

A Directly assign the property, e.g., obj.prop = value

B Call a method on the object

C No need to do anything

D Reassign the object with a new copy, e.g., obj = {...obj}

Svelte tracks variable assignments, so you must reassign the object to a new copy to trigger reactivity.

What happens if you mutate a nested object property without reassigning the parent object in Svelte?

A No reactivity is triggered

B Svelte updates the UI automatically

C Svelte throws an error

D The nested property becomes reactive

Svelte does not detect mutations inside nested objects unless the parent object is reassigned.

Which is the best way to update a nested object property reactively in Svelte?

A Call a function to update the nested property

B obj.nested.key = value

C obj = {...obj, nested: {...obj.nested, key: value}}

D Use a Svelte store

Creating a new object with updated nested properties and reassigning triggers Svelte's reactivity.

Explain why directly modifying an array or object property does not trigger reactivity in Svelte and how to fix it.

Think about how Svelte knows a variable changed.

Describe the recommended pattern to update nested object properties reactively in Svelte.

Focus on creating new objects instead of changing existing ones.

Practice

1. In Svelte, why does directly modifying an array element like arr[0] = 10 not update the UI?

easy

A. Because Svelte does not support arrays at all.

B. Because arrays are immutable in Svelte.

C. Because you must use a special method to update arrays in Svelte.

D. Because Svelte only tracks assignments to the whole variable, not internal mutations.

Solution

1. Step 1: Understand Svelte's reactivity model

   Svelte updates the UI only when a variable is assigned a new value, not when its internal parts change.

2. Step 2: Analyze direct array element modification

   Changing arr[0] = 10 mutates the array but does not assign a new array to arr, so Svelte does not detect the change.

3. Final Answer:

   Because Svelte only tracks assignments to the whole variable, not internal mutations. -> Option D

4. Quick Check:

   Direct mutation ≠ UI update [OK]

Hint: Always reassign arrays to trigger updates in Svelte [OK]

Common Mistakes:

• Thinking direct mutations trigger updates
• Believing arrays are immutable in Svelte
• Using methods without reassignment

2. Which of the following is the correct way to update an object property reactively in Svelte?

easy

A. obj = { ...obj, key: 'value' };

B. obj.key = 'value';

C. obj.key = 'value'; obj.update();

D. Object.assign(obj, { key: 'value' });

Solution

1. Step 1: Recall Svelte's reactivity for objects

   Svelte detects changes only when the whole object variable is reassigned.

2. Step 2: Evaluate each option

   obj = { ...obj, key: 'value' }; uses spread syntax to create a new object and assign it to obj, triggering reactivity. Direct property assignment like obj.key = 'value'; or Object.assign(obj, { key: 'value' }); mutate the object without reassignment, and obj.key = 'value'; obj.update(); calls a non-existent method.

3. Final Answer:

   obj = { ...obj, key: 'value' }; -> Option A

4. Quick Check:

   Reassign object with spread = reactive update [OK]

Hint: Use spread syntax and reassign objects for reactivity [OK]

Common Mistakes:

• Mutating object properties directly
• Expecting methods like obj.update() to exist
• Using Object.assign without reassignment

3. Given the code:

let numbers = [1, 2, 3];
numbers.push(4);

What will Svelte render if you display {numbers.join(',')} immediately after?

medium

A. 1,2,3,4

B. 1,2,3

C. Error: numbers is not reactive

D. 4

Solution

1. Step 1: Understand array mutation with push()

   The push() method changes the array but does not reassign it.

2. Step 2: Check Svelte's reactivity trigger

   Since numbers is not reassigned, Svelte does not detect the change and the UI remains with the old array.

3. Final Answer:

   1,2,3 -> Option B

4. Quick Check:

   Array mutation without reassignment = no UI update [OK]

Hint: Reassign array after mutation to update UI [OK]

Common Mistakes:

• Assuming push triggers UI update
• Expecting automatic reactivity on mutations
• Confusing errors with silent no-update

4. You have this Svelte code:

let user = { name: 'Alice', age: 25 };

function birthday() {
  user.age += 1;
}

Why does calling birthday() not update the UI showing {user.age}?

medium

A. Because the age property is read-only in Svelte.

B. Because Svelte does not support objects with numeric properties.

C. Because the function does not reassign the user object after mutation.

D. Because the function is missing an await keyword.

Solution

1. Step 1: Analyze mutation inside birthday()

   The function increments user.age directly, mutating the object.

2. Step 2: Check reactivity requirements

   Svelte requires reassignment of the whole object variable to detect changes; direct mutation alone does not trigger UI updates.

3. Final Answer:

   Because the function does not reassign the user object after mutation. -> Option C

4. Quick Check:

   Direct mutation without reassignment = no UI update [OK]

Hint: Always reassign objects after changing properties [OK]

Common Mistakes:

• Thinking numeric properties are special
• Assuming await is needed for sync code
• Believing direct mutation triggers UI update

5. How can you correctly update the first element of an array items reactively in Svelte?

hard

A. items = [...items]; items[0] = 'new';

B. items = ['new', ...items.slice(1)];

C. items[0] = 'new'; items = items;

D. items = items; items[0] = 'new';

Solution

1. Step 1: Understand reactivity with arrays

   Direct mutation like items[0] = 'new' does not trigger updates unless followed by reassignment.

2. Step 2: Evaluate each option

   items = ['new', ...items.slice(1)]; creates a new array with the first element replaced, triggering reactivity correctly. items = [...items]; items[0] = 'new'; creates a shallow copy of the array first, then mutates the first element, which is reactive because the reassignment happens before mutation and the array reference changes. items[0] = 'new'; items = items; mutates first then reassigns the same array reference, which may not trigger reactivity reliably. items = items; items[0] = 'new'; reassigns the same array reference then mutates, which does not trigger reactivity.

3. Final Answer:

   items = [...items]; items[0] = 'new'; -> Option A

4. Quick Check:

   Reassign array with spread then mutate = reactive update [OK]

Hint: Reassign array with spread before mutation for reactivity [OK]

Common Mistakes:

• Mutating after reassignment
• Reassigning without changes
• Mutating before reassignment expecting update