Array and object reactivity gotchas in Svelte - Performance & Optimization

Performance: Array and object reactivity gotchas

MEDIUM IMPACT

This affects how quickly the UI updates when arrays or objects change, impacting interaction responsiveness and visual stability.

Updating an array element to trigger UI reactivity

Svelte

let items = [1, 2, 3];
items[0] = 10;
items = items; // Reassignment triggers reactivity

Reassigning the array signals Svelte to update the UI immediately.

📈 Performance GainSingle reactive update; avoids stale UI and improves input responsiveness.

Updating an array element to trigger UI reactivity

Svelte

let items = [1, 2, 3];
items[0] = 10; // Direct mutation
// No reassignment, so UI does not update

Svelte does not detect direct mutations inside arrays without reassignment, so the UI won't update.

📉 Performance CostBlocks UI update until manual reassignment; causes stale UI and poor INP.

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Direct mutation without reassignment	No DOM update triggered	0 reflows but stale UI	No paint triggered	[X] Bad
Mutation followed by reassignment	Minimal DOM update triggered	1 reflow per update	Paint triggered for changed nodes	[OK] Good
Replacing entire array/object	DOM updates as needed	1 reflow per update	Paint triggered for changed nodes	[OK] Good

Rendering Pipeline

When arrays or objects are mutated directly without reassignment, Svelte's reactive system does not detect changes, so the rendering pipeline skips updating the affected DOM nodes. When reassignment occurs, Svelte schedules a reactive update that triggers style calculation, layout, paint, and composite stages for the changed elements.

→Reactive Update Scheduling

→Style Calculation

→Layout

→Paint

→Composite

⚠️ BottleneckReactive Update Scheduling and Layout due to unnecessary or missing updates

Core Web Vital Affected

INP

This affects how quickly the UI updates when arrays or objects change, impacting interaction responsiveness and visual stability.

Optimization Tips

1Always reassign arrays or objects after mutating them to trigger Svelte reactivity.

2Avoid direct mutations without reassignment to prevent stale UI and poor input responsiveness.

3Use immutable patterns or spread syntax to create new arrays/objects for clearer reactivity.

Performance Quiz - 3 Questions

Why does directly mutating an array element in Svelte without reassignment often fail to update the UI?

A Because Svelte only tracks assignments to variables for reactivity

B Because arrays are immutable in JavaScript

C Because the browser blocks updates on direct mutations

D Because direct mutations cause layout thrashing

DevTools: Svelte Devtools and Browser Performance panel

How to check: Use Svelte Devtools to inspect reactive updates; open Performance panel, record while interacting, and check if UI updates correspond to mutations.

What to look for: Look for missing reactive updates after mutations and delayed UI changes indicating no reactivity; check for unnecessary reflows or paints.

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