Reactive data with ref in Vue - Performance & Optimization

Performance: Reactive data with ref

MEDIUM IMPACT

This affects how efficiently Vue tracks and updates changes in reactive data, impacting rendering speed and responsiveness.

Managing a single reactive primitive value in Vue

Vue

import { ref } from 'vue';
const count = ref(0);

function increment() {
  count.value++;
}

ref is optimized for single primitive values, creating a simple reactive wrapper that triggers updates only when the value changes.

📈 Performance Gainreduces reactivity overhead and improves update speed

Managing a single reactive primitive value in Vue

Vue

const count = reactive({ value: 0 });

function increment() {
  count.value++;
}

Using reactive for a single primitive adds unnecessary proxy overhead and can cause more complex reactivity tracking.

📉 Performance Costadds extra proxy layers and triggers more dependency tracking than needed

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Using reactive for primitive	More proxy layers, deeper tracking	Potentially more reflows if updates cascade	Higher paint cost due to extra updates	[X] Bad
Using ref for primitive	Minimal proxy, direct tracking	Single reflow per update	Lower paint cost with targeted updates	[OK] Good

Rendering Pipeline

When a ref's value changes, Vue's reactivity system schedules component updates. The browser then recalculates styles and layouts only for affected components, minimizing work.

→JavaScript Execution

→Style Calculation

→Layout

→Paint

⚠️ BottleneckJavaScript Execution due to reactive dependency tracking

Core Web Vital Affected

INP

This affects how efficiently Vue tracks and updates changes in reactive data, impacting rendering speed and responsiveness.

Optimization Tips

1Use ref for single primitive reactive values to reduce overhead.

2Avoid using reactive for primitives to prevent unnecessary deep proxying.

3Changing a ref value triggers targeted component updates, improving responsiveness.

Performance Quiz - 3 Questions

Why is using ref better than reactive for a single primitive value in Vue?

A Because ref creates a simpler reactive wrapper with less overhead

B Because reactive does not track changes at all

C Because ref disables reactivity for primitives

D Because reactive only works with objects

DevTools: Performance

How to check: Record a performance profile while interacting with the component using ref. Look for minimal scripting time and fewer layout recalculations.

What to look for: Low JavaScript execution time and fewer layout thrashing events indicate good reactive data usage.

Practice

1. What does the ref function in Vue do?

easy

A. Defines a new component

B. Creates a reactive data reference that Vue tracks for changes

C. Imports external libraries

D. Sets up routing between pages

Solution

1. Step 1: Understand the purpose of ref

   ref is used to create reactive data that Vue can track and update the UI when it changes.

2. Step 2: Compare options with ref usage

   Options A, C, and D describe unrelated Vue features like components, imports, and routing, not reactive data.

3. Final Answer:

   Creates a reactive data reference that Vue tracks for changes -> Option B

4. Quick Check:

   ref creates reactive data = B [OK]

Hint: Remember: ref makes data reactive for UI updates [OK]

Common Mistakes:

• Confusing ref with component creation
• Thinking ref imports libraries
• Mixing ref with routing setup

2. Which is the correct way to declare a reactive variable count initialized to 0 using ref in Vue?

easy

A. var count = ref;

B. const count = reactive(0);

C. const count = ref(0);

D. let count = ref = 0;

Solution

1. Step 1: Recall correct ref syntax

   The correct syntax is const count = ref(0); to create a reactive reference with initial value 0.

2. Step 2: Identify incorrect options

   const count = reactive(0); uses reactive incorrectly with a primitive. let count = ref = 0; has invalid assignment syntax. var count = ref; incorrectly assigns the ref function without calling it and uses var which is discouraged in modern Vue code.

3. Final Answer:

   const count = ref(0); -> Option C

4. Quick Check:

   Use const with ref() for reactive variables = D [OK]

Hint: Use const and call ref() with initial value [OK]

Common Mistakes:

• Using reactive() for primitives
• Incorrect assignment syntax
• Using var instead of const

3. Given the code:

import { ref } from 'vue';
const count = ref(5);
count.value++;
console.log(count.value);

What will be logged to the console?

medium

A. 6

B. 5

C. undefined

D. Error: count is not a function

Solution

1. Step 1: Understand ref and .value usage

   count is a reactive reference initialized to 5. Incrementing count.value++ increases it to 6.

2. Step 2: Determine console output

   Logging count.value after increment prints 6.

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Increment ref.value updates value = 6 [OK]

Hint: Remember to use .value to access and update ref data [OK]

Common Mistakes:

• Logging count instead of count.value
• Forgetting to use .value to update
• Expecting original value without increment

4. What is wrong with this Vue code snippet?

import { ref } from 'vue';
const message = ref('Hello');
message = 'Hi';

medium

A. You cannot reassign a ref variable directly; must update .value

B. ref cannot hold string values

C. Missing parentheses when calling ref

D. No import statement for ref

Solution

1. Step 1: Identify how to update ref values

   Ref variables are constants holding reactive objects. You cannot reassign the variable itself; instead, update the inner value with message.value = 'Hi';.

2. Step 2: Check other options

   ref cannot hold string values is false because ref can hold strings. Missing parentheses when calling ref is false because ref is called correctly. No import statement for ref is false because import is present.

3. Final Answer:

   You cannot reassign a ref variable directly; must update .value -> Option A

4. Quick Check:

   Update ref.value, not ref variable = C [OK]

Hint: Change .value property, not the ref variable itself [OK]

Common Mistakes:

• Reassigning ref variable instead of .value
• Thinking ref can't hold strings
• Missing import statement

5. You want to create a reactive counter that increments only if the current count is less than 10. Which Vue code correctly implements this using ref?

hard

A. let count = ref(0);
if (count.value <= 10) {
count.value += 1;
}

B. const count = ref(0);
if (count < 10) {
count++;
}

C. const count = reactive(0);
if (count.value < 10) {
count.value++;
}

D. const count = ref(0);
if (count.value < 10) {
count.value++;
}

Solution

1. Step 1: Use ref and access .value correctly

   const count = ref(0); if (count.value < 10) { count.value++; } correctly declares count with ref(0) and checks count.value < 10 before incrementing count.value++.

2. Step 2: Identify errors in other options

   const count = ref(0); if (count < 10) { count++; } incorrectly compares and increments count without .value. const count = reactive(0); if (count.value < 10) { count.value++; } uses reactive with a primitive, which is incorrect. let count = ref(0); if (count.value <= 10) { count.value += 1; } uses let (allowed but less preferred) and checks <= 10, which allows increment at 10, violating the condition.

3. Final Answer:

   const count = ref(0); if (count.value < 10) { count.value++; } -> Option D

4. Quick Check:

   Use ref with .value and correct condition = A [OK]

Hint: Always use .value to read and write ref data [OK]

Common Mistakes:

• Forgetting .value when reading or writing
• Using reactive() for primitives
• Incorrect comparison operators