Reactive objects with reactive in Vue - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the reactive function do in Vue?

It creates a reactive object that Vue tracks for changes, so the UI updates automatically when the object's properties change.

beginner

How do you create a reactive object with Vue's Composition API?

Use <code>import { reactive } from 'vue'</code> and then call <code>const state = reactive({ key: value })</code>.

beginner

Why should you use reactive instead of a plain JavaScript object in Vue?

Because Vue can detect changes in reactive objects and update the UI automatically, while plain objects won't trigger updates.

intermediate

Can you add new properties to a reactive object after creation and have Vue track them?

Yes, Vue 3's reactive system tracks new properties added to reactive objects, so the UI updates when they change.

intermediate

What is the difference between reactive and ref in Vue?

reactive makes an entire object reactive, while ref makes a single value reactive and wraps it in an object with a .value property.

What does Vue's reactive function return?

A A plain JavaScript object

B A function to update state

C A reactive proxy object that tracks changes

D A string representation of the object

The reactive function returns a proxy object that Vue uses to track changes and update the UI.

Which Vue import is needed to use reactive?

A import reactive from 'vuex'

B import { ref } from 'vue'

C import { reactive } from 'vue-router'

D import { reactive } from 'vue'

The reactive function is part of Vue's core and imported from 'vue'.

If you change a property inside a reactive object, what happens?

A Vue updates the UI automatically

B Nothing, you must refresh manually

C Vue throws an error

D The object becomes non-reactive

Vue tracks changes in reactive objects and updates the UI automatically when properties change.

Can you use reactive with arrays?

A Yes, arrays become reactive objects

B No, only plain objects work

C Only if you convert arrays to objects first

D Only with special plugins

Vue's reactive can make arrays reactive, tracking changes like push or pop.

What is a key difference between reactive and ref?

A <code>reactive</code> is for strings only

B <code>ref</code> wraps a single value, <code>reactive</code> wraps an object

C <code>ref</code> cannot be used in templates

D <code>reactive</code> does not track changes

ref is for single values and uses a .value property, while reactive wraps whole objects.

Explain how Vue's reactive function helps keep the UI updated automatically.

Think about how Vue watches for changes in data.

Describe the difference between using reactive and ref in Vue's Composition API.

Consider what kind of data each is best for.

Practice

1. What does the reactive function in Vue do?

easy

A. It converts a reactive object into a plain JavaScript object.

B. It makes an object reactive so Vue tracks its changes automatically.

C. It creates a new Vue component.

D. It registers a global event listener.

Solution

1. Step 1: Understand the purpose of reactive

   The reactive function wraps an object so Vue can track its property changes.

2. Step 2: Compare options with the purpose

   Only It makes an object reactive so Vue tracks its changes automatically. correctly describes this behavior; others describe unrelated Vue features.

3. Final Answer:

   It makes an object reactive so Vue tracks its changes automatically. -> Option B

4. Quick Check:

   reactive() tracks object changes = C [OK]

Hint: Remember: reactive() wraps objects to track changes [OK]

Common Mistakes:

• Confusing reactive() with component creation
• Thinking reactive() converts reactive objects back to plain objects
• Assuming reactive() adds event listeners

2. Which of the following is the correct way to create a reactive object in Vue 3?

easy

A. const state = reactive.count = 0

B. const state = reactive = { count: 0 }

C. const state = reactive([count: 0])

D. const state = reactive({ count: 0 })

Solution

1. Step 1: Check the syntax for reactive object creation

   The correct syntax is calling reactive() with an object: reactive({ count: 0 }).

2. Step 2: Identify syntax errors in other options

   const state = reactive = { count: 0 } uses invalid assignment, C uses array syntax incorrectly, D tries to assign property directly without reactive call.

3. Final Answer:

   const state = reactive({ count: 0 }) -> Option D

4. Quick Check:

   reactive() called with object literal = A [OK]

Hint: Use reactive() with an object inside parentheses [OK]

Common Mistakes:

• Using assignment instead of function call
• Passing array instead of object
• Assigning properties outside reactive()

3. Given this code, what will be logged to the console?

import { reactive } from 'vue'
const state = reactive({ count: 1 })
state.count = 5
console.log(state.count)

medium

A. 5

B. Error: Cannot assign to reactive property

C. undefined

D. 1

Solution

1. Step 1: Understand reactive object property update

   Assigning state.count = 5 updates the reactive property value.

2. Step 2: Check the logged value

   Logging state.count after update outputs the new value 5.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   Updated reactive property logs new value = D [OK]

Hint: Reactive objects update properties directly and reflect changes [OK]

Common Mistakes:

• Thinking reactive objects are immutable
• Expecting old value after update
• Confusing reactive with ref syntax

4. What is wrong with this Vue 3 code snippet?

import { reactive } from 'vue'
const state = reactive({ count: 0 })
state = { count: 5 }

medium

A. You cannot reassign a reactive object variable directly.

B. The reactive function requires an array, not an object.

C. The property count must be declared with ref(), not reactive.

D. Reactive objects cannot have numeric properties.

Solution

1. Step 1: Identify the error in variable reassignment

   The variable state is declared with const, so it cannot be reassigned.

2. Step 2: Understand reactive object usage

   Reactive objects are mutable in their properties but the variable holding them cannot be reassigned if declared const.

3. Final Answer:

   You cannot reassign a reactive object variable directly. -> Option A

4. Quick Check:

   const variable reassignment causes error = A [OK]

Hint: const variables can't be reassigned, only their properties changed [OK]

Common Mistakes:

• Trying to reassign const reactive variables
• Confusing reactive() input types
• Thinking reactive objects restrict property types

5. You want to create a reactive object to track a user's profile with nested address info. Which code correctly makes the entire object reactive so changes to nested properties update the UI?

hard

A. const profile = reactive({ name: 'Alice' }); profile.address = { city: 'NY', zip: '10001' }

B. const profile = { name: 'Alice', address: reactive({ city: 'NY', zip: '10001' }) }

C. const profile = reactive({ name: 'Alice', address: { city: 'NY', zip: '10001' } })

D. const profile = reactive({ name: 'Alice', address: ref({ city: 'NY', zip: '10001' }) })

Solution

1. Step 1: Understand nested reactivity with reactive()

   Using reactive() on the whole object recursively makes nested properties reactive automatically.

2. Step 2: Analyze each option's approach

   const profile = reactive({ name: 'Alice', address: { city: 'NY', zip: '10001' } }) wraps the entire object including nested address, so all changes are reactive. const profile = reactive({ name: 'Alice' }); profile.address = { city: 'NY', zip: '10001' } assigns a plain object to nested property after reactive call, losing reactivity for nested changes. const profile = { name: 'Alice', address: reactive({ city: 'NY', zip: '10001' }) } mixes reactive inside plain object, which breaks reactivity tracking. const profile = reactive({ name: 'Alice', address: ref({ city: 'NY', zip: '10001' }) }) mixes ref inside reactive, which is invalid since reactive expects plain objects.

3. Final Answer:

   const profile = reactive({ name: 'Alice', address: { city: 'NY', zip: '10001' } }) -> Option C

4. Quick Check:

   reactive() wraps whole nested object = B [OK]

Hint: Wrap entire nested object with reactive() for full reactivity [OK]

Common Mistakes:

• Wrapping nested objects separately after reactive() call
• Mixing reactive and plain objects incorrectly
• Assigning plain objects to reactive properties