Why Reactive data with ref in Vue? - Purpose & Use Cases

The Big Idea

Discover how a tiny change in your code can make your app update itself like magic!

The Scenario

Imagine you have a simple counter on a webpage. Every time you click a button, you want the number to update on the screen.

Without reactive data, you must find the number element in the page and change its text manually each time the button is clicked.

The Problem

Manually updating the page is slow and easy to forget. If you miss updating the number somewhere, the page shows wrong information.

Also, if the number is used in many places, you have to update all of them yourself, which is tiring and error-prone.

The Solution

Using ref in Vue makes the number reactive. When the number changes, Vue automatically updates all places where it is shown.

This means you only change the number once in your code, and the page updates itself perfectly.

Before vs After

✗ Before

let count = 0;
button.onclick = () => {
  count++;
  document.getElementById('count').textContent = count;
};

✓ After

import { ref } from 'vue';
const count = ref(0);
function increment() {
  count.value++;
}

What It Enables

You can build interactive apps where the UI always stays in sync with your data without extra work.

Real Life Example

Think of a shopping cart total that updates instantly when you add or remove items, without needing to refresh the page or write extra update code.

Key Takeaways

Manual updates are slow and error-prone.

ref makes data reactive and UI automatic.

This leads to simpler, more reliable interactive apps.

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