vue.js – What is the difference between ref, toRef and toRefs


reactive creates a deeply reactive proxy object based on a given object. The proxy object will look exactly the same as the given, plain object, but any mutation, no matter how deep it is, will be reactive – this includes all kinds of mutations including property additions and deletions. The important thing is that reactive can only work with objects, not primitives.

For example, const state = reactive({foo: {bar: 1}}) means:

  • is reactive (it can be used in template, computed and watch)
  • is reactive
  • state.baz,, are also reactive even though baz does not yet exist anywhere. This might look surprising (especially when you start to dig how reactivity in vue works). By state.baz being reactiveI mean within your template/computed properties/watches, you can write state.baz literally and expect your logic to be executed again when state.baz becomes available. In fact, even if you write something like {{ state.baz ? state.baz.qux : "default value" }} in your template, it will also work. The final string displayed will reactively reflect state.baz.qux.

This can happen because reactive not only creates a single top level proxy object, it also recursively converts all the nested objects into reactive proxies, and this process continues to happen at runtime even for the sub objects created on the fly. Dependencies on properties of reactive objects are Continuously discovered and tracked at runtime whenever a property access attempt is made against a reactive object. With this in mind, you can work out this expression {{ state.baz ? state.baz.qux : "default value" }} step by step:

  1. the first time it is evaluated, the expression will read baz off state (in other words, a property access is attempted on state for property baz). Being a proxy object, state will remember that your expression depends on its property bazeven though baz does not exist yet. Reactivity off baz is provided by the state object that owns the property.
  2. since state.baz returns undefinedthe expression evaluates to “default value” without bothering looking at state.baz.qux. There is no dependency recorded on state.baz.qux in this round, but this is fine. Because you cannot mutate qux without mutating baz first.
  3. somewhere in your code you assign a value to state.baz: state.baz = { qux: "hello" }. This mutation qualifies as a mutation to the baz property of state, hence your expression is scheduled for re-evaluation. Meanwhile, what gets assigned to state.baz is a sub proxy created on the fly for { qux: "hello" }
  4. Your expression is evaluated again, this time state.baz is not undefined so the expression progresses to state.baz.qux. “hello” is returned, and a dependency on qux property is recorded off the proxy object state.baz. This is what I mean by dependencies are discovered and recorded at runtime as they happen.
  5. some time later you change state.baz.qux = "hi". This is a mutation to the qux property and hence your expression will be evaluated again.

With the above in mind, you should be able to understand this as well: you can store in a separate variable: const foo = Reactivity works off your variable foo just fine. foo points to the same thing that is pointing to – a reactive proxy object. The power of reactivity comes from the proxy object. By the way, const baz = state.baz wouldn’t work the same, more on this later.

However, there are always edge cases to watch for:

  1. the recursive creation of nested proxies can only happen if there is a nested object. If a given property does not exist, or it exists but it is not an object, no proxy can be created at that property. Eg this is why reactivity does not work off the baz variable created by const baz = state.baznor the bar variable of const bar = To make it clear, what it means is that you can use state.baz and in your template/computed/watch, but not baz or bar created above.
  2. if you extract a nest proxy out to a variable, it is detached from its original parent. This can be made clearer with an example. The second assignment below ( = {bar: 3}) does not destroy the reactivity of foobut will be a new proxy object while the foo variable still points the to original proxy object.
const state = reactive({foo: {bar: 1}});
const foo =; = 2; === 2; // true, because foo and are the same = {bar: 3}; === 3; // false, will still be 2  

ref and toRef solve some of these edge cases.


ref is pretty much the reactive that works also with primitives. We still cannot turn JS primitives into Proxy objects, so ref always wraps the provided argument X into an object of shape {value: X}. It does not matter if X is primitive or not, the “boxing” always happens. If an object is given to ref, ref internally calls reactive After the boxing so the result is also deeply reactive. The major difference in practice is that you need to keep in mind to call .value in your js code when working with ref. In your template you dont have to call .value because Vue automatically unwrapps ref in template.

const count = ref(1);
const objCount = ref({count: 1});

count.value === 1; // true
objCount.value.count === 1; // true


toRef is meant to convert a property of a reactive object into a ref. You might be wondering why this is necessary since reactive object is already deeply reactive. toRef is here to handle the two edge cases mentioned for reactive. In summary, toRef can convert any property of a reactive object into a ref that is linked to its original parent. The property can be one that does not exist initially, or whose value is primitive.

In the same example where state is defined as const state = reactive({foo: {bar: 1}}):

  • const foo = toRef(state, 'foo') will be very similar to const foo = but with two differences:
    1. foo is a ref so you need to do foo.value in js;
    2. foo is linked to its parent, so reassigning = {bar: 2} will get reflected in foo.value
  • const baz = toRef(state, 'baz') now works.


toRefs is a utility method used for destructing a reactive object and convert all its properties to ref:

const state = reactive({...});
return {...state}; // will not work, destruction removes reactivity 
return toRefs(state); // works

Leave a Comment