Array and object reactivity gotchas in Svelte - Step-by-Step Execution

Concept Flow - Array and object reactivity gotchas

Initialize reactive array/object

↓

Modify array/object directly

↓

Svelte does NOT detect change

↓

No UI update

↓

Use assignment or methods triggering reactivity

↓

Svelte detects change

↓

UI updates accordingly

Svelte tracks changes only when arrays or objects are reassigned or updated with reactive methods, not when mutated directly.

Execution Sample

Svelte

let items = [1, 2, 3];

function addItem() {
  items.push(4); // direct mutation
  items = items; // triggers reactivity
}

Shows that directly pushing to array doesn't update UI until reassigned.

Execution Table

Step	Action	Array State	Reactivity Triggered?	UI Update
1	Initialize items = [1, 2, 3]	[1, 2, 3]	Yes (initial)	UI shows [1, 2, 3]
2	Call addItem(): Direct push 4 to items	[1, 2, 3, 4]	No	No UI update
3	Assign items = items	[1, 2, 3, 4]	Yes	UI updates to [1, 2, 3, 4]
4	Modify object property directly: { count: 1 } → count = 2	{ count: 2 }	No	No UI update
5	Reassign object to itself	{ count: 2 }	Yes	UI updates to count: 2

💡 Direct mutations do not trigger reactivity; reassignment triggers UI update.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5
items	[1, 2, 3]	[1, 2, 3, 4]	[1, 2, 3, 4]	-	-
obj	{ count: 1 }	-	-	{ count: 2 }	{ count: 2 }

Key Moments - 2 Insights

Why doesn't pushing an item to the array update the UI immediately?

Because Svelte only tracks changes when the variable is reassigned. Direct mutations like push do not trigger reactivity (see execution_table step 2).

How can we make Svelte detect changes after mutating an object property?

By reassigning the object to itself after mutation, which triggers reactivity and UI update (see execution_table steps 4 and 5).

Visual Quiz - 3 Questions

Look at the execution table, what is the array state after step 2?

A [4]

B [1, 2, 3, 4]

C [1, 2, 3]

D []

💡 Hint

Check the 'Array State' column for step 2 in the execution_table.

At which step does the UI update to show the new array with 4 included?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at the 'UI Update' column in the execution_table for when the UI changes.

If we remove the reassignment 'items = items;' in addItem(), what happens to the UI?

A UI shows an error

B UI updates immediately

C UI never updates to show the new item

D UI updates after a delay

💡 Hint

Refer to the key moment about direct mutation without reassignment.

Concept Snapshot

Svelte reactivity for arrays and objects requires reassignment.
Direct mutations like push or property changes do NOT trigger UI updates.
Always reassign the variable (e.g., items = items) after mutation.
This ensures Svelte detects changes and updates the UI.
Remember: reactivity tracks assignments, not mutations.

Full Transcript

In Svelte, when you change an array or object directly, like pushing an item or changing a property, the UI does not update automatically. This is because Svelte's reactivity system only notices when you assign a new value to a variable. So, after mutating an array or object, you must reassign it to itself to trigger the UI update. For example, after pushing to an array, write 'items = items;' to make Svelte update the display. The same applies to objects: change a property, then reassign the object. This way, Svelte knows to refresh the UI. Without reassignment, changes stay invisible on screen.

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