Template Refs | Vue.js

Creating an Application
Reactivity Fundamentals
Class and Style Bindings
Conditional Rendering
Fallthrough Attributes
Single-File Components
Server-Side Rendering (SSR)
Production Deployment
TS with Composition API
Render Functions & JSX
Vue and Web Components
Animation Techniques
While Vue's declarative rendering model abstracts away most of the direct DOM operations for you, there may still be cases where we need direct access to the underlying DOM elements. To achieve this, we can use the special ref attribute:
ref is a special attribute, similar to the key attribute discussed in the v-for chapter. It allows us to obtain a direct reference to a specific DOM element or child component instance after it's mounted. This may be useful when you want to, for example, programmatically focus an input on component mount, or initialize a 3rd party library on an element.
To obtain the reference with Composition API, we can use the useTemplateRef() helper:
When using TypeScript, Vue's IDE support and vue-tsc will automatically infer the type of input.value based on what element or component the matching ref attribute is used on.
In versions before 3.5 where useTemplateRef() was not introduced, we need to declare a ref with a name that matches the template ref attribute's value:
If not using <script setup>, make sure to also return the ref from setup():
The resulting ref is exposed on this.$refs:
Note that you can only access the ref after the component is mounted. If you try to access $refs.inputinput in a template expression, it will be undefinednull on the first render. This is because the element doesn't exist until after the first render!
If you are trying to watch the changes of a template ref, make sure to account for the case where the ref has null value:
See also: Typing Template Refs
This section assumes knowledge of Components. Feel free to skip it and come back later.
ref can also be used on a child component. In this case the reference will be that of a component instance:
If the child component is using Options API or not using <script setup>, theThe referenced instance will be identical to the child component's this, which means the parent component will have full access to every property and method of the child component. This makes it easy to create tightly coupled implementation details between the parent and the child, so component refs should be only used when absolutely needed - in most cases, you should try to implement parent / child interactions using the standard props and emit interfaces first.
An exception here is that components using <script setup> are private by default: a parent component referencing a child component using <script setup> won't be able to access anything unless the child component chooses to expose a public interface using the defineExpose macro:
When a parent gets an instance of this component via template refs, the retrieved instance will be of the shape { a: number, b: number } (refs are automatically unwrapped just like on normal instances).
Note that defineExpose must be called before any await operation. Otherwise, properties and methods exposed after the await operation will not be accessible.
See also: Typing Component Template Refs
The expose option can be used to limit the access to a child instance:
In the above example, a parent referencing this component via template ref will only be able to access publicData and publicMethod.
Requires v3.5 or above
When ref is used inside v-for, the corresponding ref should contain an Array value, which will be populated with the elements after mount:
Try it in the Playground
In versions before 3.5 where useTemplateRef() was not introduced, we need to declare a ref with a name that matches the template ref attribute's value. The ref should also contain an array value:
When ref is used inside v-for, the resulting ref value will be an array containing the corresponding elements:
Try it in the Playground
It should be noted that the ref array does not guarantee the same order as the source array.
Instead of a string key, the ref attribute can also be bound to a function, which will be called on each component update and gives you full flexibility on where to store the element reference. The function receives the element reference as the first argument:
Note we are using a dynamic :ref binding so we can pass it a function instead of a ref name string. When the element is unmounted, the argument will be null. You can, of course, use a method instead of an inline function.