Vue
Материал для подготовки к собеседованию (Middle / Senior). Ориентир — Vue 3 (Composition API, <script setup>), с пометками отличий от Vue 2 там, где это важно. Термины на английском там, где это принято.
Содержание
- Что такое Vue и его сильные стороны
- Реактивность: как работает
- ref, reactive, toRef, toRefs
- computed
- watch и watchEffect
- Options API vs Composition API
- script setup
- Жизненный цикл компонента
- Props и события
- v-model
- Слоты (slots)
- provide / inject
- Директивы
- Условный рендеринг и списки
- Virtual DOM, шаблоны и рендеринг
- Composables
- Pinia (управление состоянием)
- Vue Router
- Производительность и реактивные подводные камни
- Teleport, Suspense, async-компоненты
- SSR и Nuxt
- Кастомные директивы
- Тестирование
- Отличия Vue 2 и Vue 3
- Вероятные вопросы
Что такое Vue и его сильные стороны
Vue — прогрессивный фреймворк для построения пользовательских интерфейсов. «Прогрессивный» — можно подключить на одну страницу как библиотеку, а можно строить полноценное SPA с роутером и стором.
Ключевые идеи:
- Декларативный рендеринг — описываешь, как UI должен выглядеть при данном состоянии, а Vue сам обновляет DOM при изменении данных.
- Реактивность — при изменении данных представление обновляется автоматически.
- Компонентный подход — UI собирается из переиспользуемых компонентов.
- Однофайловые компоненты (SFC,
.vue) — шаблон, логика и стили в одном файле.
<script setup>
import { ref } from 'vue'
const count = ref(0)
</script>
<template>
<button @click="count++">Кликнули {{ count }} раз</button>
</template>
<style scoped>
button { color: teal; }
</style>
Сильные стороны: мягкая кривая обучения, отличный DX, реактивность «из коробки», SFC, богатая официальная экосистема (Router, Pinia, Nuxt). В сравнении с React — меньше «ручной» работы (реактивность и шаблоны вместо JSX + хуков), но менее гибок в некоторых сценариях.
Реактивность: как работает
Vue 3 строит реактивность на Proxy (ES6). Когда ты оборачиваешь объект в reactive(), Vue создаёт Proxy, который перехватывает чтение (get) и запись (set) свойств (ref() — объект с геттером/сеттером .value, а объект-значение внутри него оборачивается в reactive):
- при чтении реактивного свойства во время рендера/вычисления Vue «запоминает» зависимость (track);
- при записи — оповещает всех, кто от этого свойства зависел, и запускает повторный рендер/пересчёт (trigger).
Компонент читает state.count → Vue регистрирует зависимость (track)
state.count = 5 → Vue находит зависимых и обновляет их (trigger)
Отличие от Vue 2 (важно на собеседовании). Vue 2 использовал Object.defineProperty для геттеров/сеттеров, и у него были ограничения:
- нельзя было отследить добавление новых свойств в объект (нужен был
Vue.set); - нельзя было отследить изменение элемента массива по индексу и изменение
length.
Proxy в Vue 3 снял эти ограничения — новые свойства и изменения массивов реактивны из коробки.
ref, reactive, toRef, toRefs
ref — для примитивов и любых значений; создаёт объект-обёртку с полем .value (track/trigger — через геттер/сеттер .value, не Proxy; объект-значение внутри делается reactive):
import { ref } from 'vue'
const count = ref(0)
console.log(count.value) // 0 — в JS обращаемся через .value
count.value++ // в шаблоне .value писать не нужно — Vue разворачивает автоматически
reactive — для объектов/массивов; возвращает реактивный Proxy (без .value):
import { reactive } from 'vue'
const state = reactive({ count: 0, user: { name: 'Вася' } })
state.count++ // напрямую, без .value
Когда что: ref — универсален (примитивы, а также объекты — тогда .value будет реактивным). reactive — только объекты/массивы. На практике многие используют ref почти везде для единообразия.
Подводный камень reactive: теряет реактивность при деструктуризации или переприсваивании:
let state = reactive({ count: 0 })
let { count } = state // count — просто число, НЕ реактивно
state = { count: 5 } // замена ссылки: шаблон/watch, привязанные к старому Proxy, не узнают о новом объекте
// (если объявить const state — будет TypeError: Assignment to constant variable)
toRef / toRefs решают эту проблему — превращают свойства реактивного объекта в ref, сохраняющие связь:
import { toRefs, toRef } from 'vue'
const state = reactive({ count: 0, name: 'a' })
const { count, name } = toRefs(state) // count, name — ref'ы, связаны со state
const countRef = toRef(state, 'count') // отдельное свойство
Дополнительно: isRef, unref (вернуть .value или само значение), shallowRef/shallowReactive (реактивность только на верхнем уровне — оптимизация), readonly, markRaw (исключить объект из реактивности).
computed
computed — вычисляемое значение, которое кэшируется и пересчитывается только при изменении его зависимостей:
import { ref, computed } from 'vue'
const price = ref(100)
const qty = ref(3)
const total = computed(() => price.value * qty.value) // пересчитается только при смене price/qty
console.log(total.value) // 300
Отличие от метода: метод в шаблоне выполняется при каждом ре-рендере, а computed — только когда изменились зависимости (кэш). Для «производных» данных всегда предпочтительнее computed.
Можно сделать записываемый computed (get/set):
const fullName = computed({
get: () => `${first.value} ${last.value}`,
set: (val) => { [first.value, last.value] = val.split(' ') },
})
watch и watchEffect
Обе функции реагируют на изменения, но по-разному.
watch — следит за конкретным источником(ами) и вызывает колбэк с новым и старым значением; по умолчанию ленивый (не запускается сразу):
import { ref, watch } from 'vue'
const query = ref('')
watch(query, (newVal, oldVal) => {
fetchResults(newVal) // реагируем на изменение query
})
// несколько источников
watch([a, b], ([newA, newB]) => {})
// глубокое слежение за объектом + запуск сразу
watch(source, cb, { deep: true, immediate: true })
watchEffect — запускается сразу и автоматически отслеживает все реактивные значения, использованные внутри (не нужно указывать источник явно):
import { watchEffect } from 'vue'
watchEffect(() => {
console.log(`count = ${count.value}`) // сам поймёт, что зависит от count
})
Когда что: watch — когда нужен доступ к старому значению или точный контроль источника, ленивость; watchEffect — когда удобно «просто следить за тем, что используется». Для производных данных используют computed, а не watch (частая ошибка новичков — считать значение через watch).
Очистка побочных эффектов — onCleanup (в watchEffect) или возврат функции; тайминг — flush: 'post' (после обновления DOM).
Options API vs Composition API
Два стиля написания компонентов.
Options API (традиционный, есть и в Vue 2) — логика распределена по опциям data, methods, computed, watch, хуки жизненного цикла:
export default {
data() { return { count: 0 } },
computed: { double() { return this.count * 2 } },
methods: { inc() { this.count++ } },
mounted() { console.log('смонтирован') },
}
Composition API (Vue 3) — логика организуется по смыслу в функции setup (или <script setup>), с ref/reactive/computed/watch:
import { ref, computed, onMounted } from 'vue'
export default {
setup() {
const count = ref(0)
const double = computed(() => count.value * 2)
const inc = () => count.value++
onMounted(() => console.log('смонтирован'))
return { count, double, inc } // то, что вернули, доступно в шаблоне
}
}
Плюсы Composition API: логику одной фичи можно держать вместе (а не размазывать по data/methods/…); легко выносить в переиспользуемые composables; лучше типизируется TypeScript. Options API проще для новичков и мелких компонентов. Их можно смешивать, но обычно выбирают один стиль.
script setup
<script setup> — синтаксический сахар над Composition API: всё, что объявлено на верхнем уровне, автоматически доступно в шаблоне (не нужно return). Самый рекомендуемый способ в Vue 3.
<script setup>
import { ref } from 'vue'
import ChildComp from './ChildComp.vue' // импортированные компоненты сразу доступны в шаблоне
const count = ref(0)
const inc = () => count.value++
// Props и события — через макросы компилятора (не нужно импортировать)
const props = defineProps({ title: String })
const emit = defineEmits(['update'])
// Что открыть наружу через ref на компонент
defineExpose({ count })
</script>
<template>
<ChildComp :title="props.title" @update="emit('update')" />
<button @click="inc">{{ count }}</button>
</template>
Макросы: defineProps, defineEmits, defineExpose, defineModel (для v-model, с 3.4), withDefaults. С Vue 3.5 дефолты props можно задать и деструктуризацией: const { count = 0 } = defineProps<{ count?: number }>() (reactive props destructure — реактивность сохраняется).
Жизненный цикл компонента
Хуки (Composition API → Options API):
| Composition API | Options API | Когда срабатывает |
|---|---|---|
— (код в setup) |
beforeCreate / created |
до/после инициализации данных |
onBeforeMount |
beforeMount |
перед вставкой в DOM |
onMounted |
mounted |
компонент вставлен в DOM (здесь можно работать с DOM, делать запросы) |
onBeforeUpdate |
beforeUpdate |
перед обновлением DOM после изменения данных |
onUpdated |
updated |
после обновления DOM |
onBeforeUnmount |
beforeUnmount |
перед удалением (здесь чистят таймеры/подписки) |
onUnmounted |
unmounted |
компонент удалён |
import { onMounted, onUnmounted } from 'vue'
onMounted(() => { /* DOM готов, грузим данные */ })
onUnmounted(() => { /* убираем слушатели, таймеры */ })
Дополнительные: onErrorCaptured, onActivated/onDeactivated (для <KeepAlive>), onRenderTracked/onRenderTriggered (отладка реактивности). В <script setup> роль created выполняет сам код setup (выполняется при создании).
Props и события
Props — данные «сверху вниз» (от родителя к ребёнку), односторонний поток (child не должен мутировать props напрямую).
<script setup>
const props = defineProps({
title: { type: String, required: true },
count: { type: Number, default: 0 },
items: { type: Array, default: () => [] }, // объекты/массивы — только через фабрику
})
</script>
События — данные «снизу вверх» (от ребёнка к родителю) через emit:
<!-- Child -->
<script setup>
const emit = defineEmits(['increment'])
function onClick() { emit('increment', 5) }
</script>
<!-- Parent -->
<Child @increment="(val) => count += val" />
Правило: props вниз, события вверх (one-way data flow). Если нужно менять данные родителя — эмитим событие, родитель меняет у себя.
v-model
v-model — двустороннее связывание (синтаксический сахар над :modelValue + @update:modelValue).
На нативном инпуте:
<input v-model="text" />
<!-- эквивалент: <input :value="text" @input="text = $event.target.value" /> -->
Кастомный v-model на компоненте (Vue 3.4+, через defineModel):
<!-- Child -->
<script setup>
const model = defineModel() // двусторонняя связь с родителем
</script>
<template>
<input v-model="model" />
</template>
<!-- Parent -->
<Child v-model="username" />
До 3.4 делали через props.modelValue + emit('update:modelValue', ...). Можно несколько v-model с аргументами: v-model:title, v-model:content.
Модификаторы: .lazy (на change вместо input), .number, .trim.
Слоты (slots)
Слоты позволяют родителю передавать разметку внутрь дочернего компонента.
<!-- Child (Card.vue) -->
<template>
<div class="card">
<header><slot name="header">Заголовок по умолчанию</slot></header>
<slot /> <!-- дефолтный слот -->
<footer><slot name="footer" /></footer>
</div>
</template>
<!-- Parent -->
<Card>
<template #header><h1>Привет</h1></template>
<p>Основной контент</p>
<template #footer>Низ</template>
</Card>
Scoped slots (слоты с данными) — дочерний компонент передаёт данные в слот, родитель их использует:
<!-- Child -->
<slot name="item" :user="user" :index="i" />
<!-- Parent -->
<template #item="{ user, index }">
{{ index }}. {{ user.name }}
</template>
Применение scoped slots — переиспользуемые компоненты списков/таблиц, где родитель управляет отображением каждого элемента.
provide / inject
Механизм передачи данных от предка к потомкам на любой глубине без «проброса props через все уровни» (prop drilling).
// Предок
import { provide, ref } from 'vue'
const theme = ref('dark')
provide('theme', theme) // ключ + значение
// Любой потомок
import { inject } from 'vue'
const theme = inject('theme', 'light') // второй аргумент — значение по умолчанию
Хорошая практика: передавать ref/reactive (реактивно), а мутировать — через предоставленную предком функцию (чтобы поток данных оставался предсказуемым). Для глобального состояния всего приложения обычно берут Pinia, а provide/inject — для «локально глобального» (тема, конфиг, i18n внутри поддерева).
Директивы
Встроенные директивы:
v-bind(:) — привязка атрибута/пропса::href="url",:class,:style.v-on(@) — обработчик события:@click="fn", с модификаторами@click.stop,@submit.prevent,@keyup.enter.v-model— двустороннее связывание.v-if/v-else-if/v-else— условный рендеринг (элемент реально добавляется/удаляется из DOM).v-show— переключение черезdisplay: none(элемент остаётся в DOM).v-for— рендер списка.v-html— вставить HTML (осторожно, XSS),v-text.v-once— отрендерить один раз и не обновлять;v-memo— мемоизация поддерева.
Кастомная директива — для низкоуровневой работы с DOM:
const vFocus = {
mounted: (el) => el.focus(),
}
// <input v-focus />
v-if vs v-show: v-if дешевле, если условие редко меняется (элемент вообще не создаётся); v-show дешевле при частом переключении (элемент уже в DOM, меняется только CSS).
Условный рендеринг и списки
<li v-for="(item, index) in items" :key="item.id">
{{ index }}. {{ item.name }}
</li>
key — обязателен и важен. Vue использует key для сопоставления элементов между рендерами (reconciliation): по нему он понимает, какой элемент переиспользовать, какой создать/удалить. Правильный key — стабильный уникальный идентификатор (обычно id).
Антипаттерн — key по индексу (:key="index"): при вставке/удалении/сортировке индексы сдвигаются, Vue путает элементы → баги с состоянием (например, значения в input «перескакивают»). Индекс допустим только для статичных, не меняющихся списков.
Не использовать v-if и v-for на одном элементе одновременно (в Vue 3 v-if имеет приоритет) — лучше отфильтровать данные через computed.
Virtual DOM, шаблоны и рендеринг
Virtual DOM (VDOM) — это лёгкое представление реального DOM в виде объектов JavaScript (дерево VNode — виртуальных узлов). Прямые операции с настоящим DOM медленные, поэтому Vue сначала работает с VDOM в памяти, а в реальный DOM вносит только необходимые изменения.
Как это работает по шагам:
- Компонент рендерится → строится дерево VNode (виртуальное представление UI при текущем состоянии).
- При изменении реактивных данных Vue создаёт новое дерево VNode.
- Новое дерево сравнивается со старым — это diffing (в рамках процесса reconciliation, «согласования»).
- Vue вычисляет минимальный набор изменений и применяет их к реальному DOM (patch). Всё остальное не трогается.
state изменился
→ новый VDOM (в памяти, быстро)
→ diff со старым VDOM
→ patch: точечно обновить только изменившиеся узлы реального DOM
Из чего получается VDOM. Шаблон (<template>) — это не то, что выполняется напрямую. Компилятор Vue превращает шаблон в render-функцию, которая при вызове возвращает дерево VNode:
// Шаблон <div>{{ msg }}</div> компилируется примерно в:
import { h } from 'vue' // h = hyperscript, создаёт VNode
render() {
return h('div', this.msg)
}
Обычно render-функции не пишут вручную (пишут шаблоны), но их можно использовать для очень динамичного рендера (или JSX). h(тег, пропсы, дети) — базовая функция создания VNode.
Зачем key (связь с этим разделом). При diffing списка key говорит Vue, какой VNode какому реальному узлу соответствует — чтобы переиспользовать узлы, а не пересоздавать. Индекс как key ломает это сопоставление при вставках/удалениях.
Оптимизации компилятора Vue 3
Ключевое отличие Vue 3 от Vue 2: умный компилятор шаблонов, который сильно ускоряет обновления (в Vue 2 diffing честно обходил всё дерево):
- Static hoisting — статические узлы (которые никогда не меняются) создаются один раз и «поднимаются» из render-функции, а не пересоздаются на каждый рендер.
- Patch flags — компилятор помечает динамические узлы флагами (что именно может меняться: текст, класс, пропс). При обновлении Vue проверяет только помеченное, а не весь узел.
- Tree flattening / block tree — динамические узлы собираются в «блок», и Vue при обновлении обходит только их, пропуская статические части.
- Cache handlers — обработчики событий кэшируются, чтобы не создавать новые функции на каждый рендер.
Итог: Vue 3 обновляет DOM заметно эффективнее, потому что «знает» из шаблона, что именно может измениться, и не тратит время на статику.
Сравнение подходов: Virtual DOM (Vue, React) — сравниваем деревья и патчим разницу. Есть и другой подход — компиляция без VDOM (Svelte, отчасти Vue Vapor Mode), где генерируется код, точечно обновляющий DOM. Vue сочетает VDOM с компиляторными оптимизациями, получая баланс гибкости и скорости.
Composables
Composable — функция, инкапсулирующая переиспользуемую реактивную логику (аналог «хуков» в React). Соглашение об именовании — useXxx.
// useCounter.js
import { ref } from 'vue'
export function useCounter(initial = 0) {
const count = ref(initial)
const inc = () => count.value++
const dec = () => count.value--
return { count, inc, dec }
}
<script setup>
import { useCounter } from './useCounter'
const { count, inc } = useCounter(10)
</script>
Composables — главный способ переиспользования логики в Vue 3 (вместо миксинов из Vue 2, у которых были проблемы: неявные источники свойств, конфликты имён). Внутри composable можно использовать ref, computed, watch, хуки жизненного цикла (onMounted и т.д.).
Пример с событием окна и очисткой:
export function useWindowWidth() {
const width = ref(window.innerWidth)
const onResize = () => (width.value = window.innerWidth)
onMounted(() => window.addEventListener('resize', onResize))
onUnmounted(() => window.removeEventListener('resize', onResize))
return { width }
}
Pinia (управление состоянием)
Pinia — официальное решение для глобального состояния в Vue 3 (пришло на смену Vuex). Проще, типобезопаснее, без мутаций.
// stores/counter.js
import { defineStore } from 'pinia'
import { ref, computed } from 'vue'
export const useCounterStore = defineStore('counter', () => {
// state
const count = ref(0)
// getters
const double = computed(() => count.value * 2)
// actions
function increment() { count.value++ }
return { count, double, increment }
})
<script setup>
import { useCounterStore } from '@/stores/counter'
import { storeToRefs } from 'pinia'
const store = useCounterStore()
const { count, double } = storeToRefs(store) // сохраняем реактивность при деструктуризации
store.increment()
</script>
Понятия: state (данные), getters (вычисляемые, как computed), actions (методы, в т.ч. асинхронные — в Pinia нет отдельных «мутаций», как во Vuex).
Pinia vs Vuex: у Pinia проще API, нет мутаций, отличная поддержка TypeScript, модульность без вложенных namespaced-модулей, поддержка Composition-стиля. Vuex считается legacy.
Важно: storeToRefs нужен, чтобы при деструктуризации стора не потерять реактивность (как toRefs для reactive).
Vue Router
Официальный роутер для SPA.
import { createRouter, createWebHistory } from 'vue-router'
const routes = [
{ path: '/', component: Home },
{ path: '/users/:id', component: User, props: true }, // динамический параметр
{
path: '/admin',
component: Admin,
children: [ { path: 'stats', component: Stats } ], // вложенные маршруты
},
{ path: '/about', component: () => import('./About.vue') }, // ленивая загрузка
]
const router = createRouter({
history: createWebHistory(), // history API (без #); альтернатива — createWebHashHistory
routes,
})
В компоненте (Composition API):
import { useRoute, useRouter } from 'vue-router'
const route = useRoute() // текущий маршрут: route.params.id, route.query
const router = useRouter() // навигация: router.push('/users/1')
Навигационные хуки (guards) — контроль переходов (авторизация, подтверждение):
router.beforeEach((to, from) => {
if (to.meta.requiresAuth && !isLoggedIn()) return '/login'
})
Ключевое: динамические (:id) и вложенные маршруты, <router-view> и <router-link>, ленивая загрузка через динамический import (code splitting), guards (beforeEach, beforeEnter, beforeRouteLeave), режимы history (web history vs hash).
Производительность и реактивные подводные камни
v-once/v-memo— пропускать перерисовку статичных/редко меняющихся частей.- Правильные
keyвv-for— стабильные id, не индекс. computedвместо методов для производных данных (кэширование).- Ленивая загрузка компонентов (
defineAsyncComponent) и маршрутов (динамическийimport) — code splitting. shallowRef/shallowReactive— для больших структур, где не нужна глубокая реактивность (например, большой массив данных таблицы) — снижает накладные расходы на отслеживание.- Виртуализация списков — рендерить только видимые элементы (vue-virtual-scroller) для тысяч строк.
v-showvsv-if— выбирать по частоте переключения.markRaw— исключить тяжёлый объект (например, инстанс сторонней библиотеки) из реактивности.
Подводные камни реактивности: потеря реактивности при деструктуризации reactive (использовать toRefs); замена ссылки на reactive-объект; забыть .value у ref в JS-коде; мутировать props напрямую.
Teleport, Suspense, async-компоненты
<Teleport> — рендерит содержимое в другое место DOM (например, модалку в <body>), сохраняя логику внутри компонента:
<Teleport to="body">
<div class="modal">...</div>
</Teleport>
<Suspense> — ожидание асинхронных зависимостей (async setup / async-компонент), показывает fallback, пока грузится:
<Suspense>
<template #default><AsyncComp /></template>
<template #fallback><Spinner /></template>
</Suspense>
Async-компоненты:
import { defineAsyncComponent } from 'vue'
const Heavy = defineAsyncComponent(() => import('./Heavy.vue'))
<KeepAlive> — кэширует состояние компонентов при переключении (например, вкладки), с хуками onActivated/onDeactivated.
<Transition> / <TransitionGroup> — анимации появления/удаления элементов и списков.
SSR и Nuxt
- CSR (Client-Side Rendering) — обычное SPA: HTML собирается в браузере. Минусы — хуже SEO и медленнее первый показ.
- SSR (Server-Side Rendering) — сервер рендерит HTML и отдаёт готовую страницу, затем происходит гидрация (Vue «оживляет» разметку на клиенте). Лучше SEO и Time-to-Content.
- SSG (Static Site Generation) — страницы генерируются заранее в статический HTML.
Nuxt — метафреймворк над Vue: даёт SSR/SSG из коробки, файловый роутинг, серверные маршруты (API), автоимпорты, оптимизации. Аналог Next.js в мире React. На собеседовании достаточно понимать разницу CSR/SSR/SSG и что такое гидрация.
Кастомные директивы
Директива нужна для низкоуровневой работы с DOM там, где компонент избыточен (фокус, автоскролл, клик вне элемента, тултип, ленивая загрузка изображений). Директива — объект с хуками жизненного цикла, которые получают сам DOM-элемент.
// глобальная регистрация
app.directive('focus', {
mounted(el) {
el.focus(); // el — реальный DOM-элемент
}
});
// использование: <input v-focus />
В <script setup> локальная директива — переменная с префиксом v (vFocus):
<script setup>
const vFocus = {
mounted: (el) => el.focus(),
};
</script>
<template><input v-focus /></template>
Хуки директивы (совпадают с фазами компонента): created, beforeMount, mounted, beforeUpdate, updated, beforeUnmount, unmounted. Аргументы хука: el (элемент), binding (.value — переданное значение, .arg — аргумент, .modifiers — модификаторы), vnode.
// v-color:background.important="'red'" → binding.value='red', binding.arg='background', binding.modifiers={important:true}
app.directive('color', {
mounted(el, binding) {
el.style[binding.arg || 'color'] = binding.value;
},
updated(el, binding) { // обновлять при смене значения
el.style[binding.arg || 'color'] = binding.value;
}
});
Классический пример — «клик вне элемента» (закрыть дропдаун): в mounted вешают слушатель на document, в unmounted — снимают (иначе утечка). Правило: не забывать очистку в unmounted.
Тестирование
- Vitest — быстрый тест-раннер (нативно дружит с Vite), совместим с Jest по API. Стандарт для Vue-проектов на Vite.
- Vue Test Utils (VTU) — официальная библиотека для монтирования компонентов и работы с ними в тестах.
- @testing-library/vue — подход «как пользователь» (искать по тексту/роли, а не по деталям реализации).
import { mount } from '@vue/test-utils';
import { describe, it, expect } from 'vitest';
import Counter from './Counter.vue';
describe('Counter', () => {
it('увеличивает счётчик по клику', async () => {
const wrapper = mount(Counter, { props: { start: 0 } });
expect(wrapper.text()).toContain('0');
await wrapper.find('button').trigger('click'); // await — дождаться реактивного обновления
expect(wrapper.text()).toContain('1');
});
it('эмитит событие', async () => {
const wrapper = mount(Counter);
await wrapper.find('button').trigger('click');
expect(wrapper.emitted('increment')).toBeTruthy(); // проверка emit
});
});
Ключевое: mount (полный рендер, с дочерними) vs shallowMount (заглушки дочерних — изоляция); wrapper.find/get для поиска элементов; trigger для событий; await после действия (Vue обновляет DOM асинхронно — nextTick); props, emitted(), setValue для форм. Composables тестируют отдельно как обычные функции. E2E — Cypress/Playwright. Философия: тестировать поведение, а не внутренности.
Отличия Vue 2 и Vue 3
| Аспект | Vue 2 | Vue 3 |
|---|---|---|
| Реактивность | Object.defineProperty (геттеры/сеттеры) |
Proxy (нет ограничений с новыми свойствами и массивами) |
| API | Options API | Options + Composition API, <script setup> |
| Переиспользование логики | миксины (проблемные) | composables |
| Несколько корней в шаблоне | нельзя (один root) | можно (fragments) |
| Teleport / Suspense | нет | есть |
| TypeScript | ограниченно | глубокая поддержка |
| Производительность/размер | — | быстрее, меньше бандл, tree-shaking |
| Реактивные утилиты | Vue.set/Vue.delete нужны |
не нужны |
Также в Vue 3: новый глобальный API (createApp вместо new Vue), emits-опция, множественные v-model, лучшая обработка v-if/v-for приоритета. Vue 2 достиг конца поддержки (EOL) — новые проекты пишут на Vue 3.
Вероятные вопросы
Как устроена реактивность в Vue 3? На Proxy: перехват чтения (track — запомнить зависимость) и записи (trigger — оповестить зависимых). В отличие от Vue 2 (Object.defineProperty) нет проблем с новыми свойствами и изменением массивов по индексу.
ref vs reactive? ref — для любых значений, доступ через .value (в шаблоне разворачивается); reactive — только для объектов/массивов, без .value, но теряет реактивность при деструктуризации/переприсваивании.
Зачем toRefs/storeToRefs? Сохранить реактивность при деструктуризации reactive-объекта/стора (иначе получим «отвязанные» значения).
computed vs method vs watch? computed — кэшируемое производное значение (пересчёт по зависимостям); метод выполняется на каждый рендер; watch — сайд-эффект в ответ на изменение (запрос, синхронизация), не для вычисления данных.
watch vs watchEffect? watch — явный источник, ленивый, есть old/new значения; watchEffect — запускается сразу и сам отслеживает используемые реактивные значения.
Options API vs Composition API? Options — логика по опциям (data/methods/…); Composition — логика по смыслу в setup, легко выносится в composables, лучше для TS и переиспользования.
Что такое composable? Функция useXxx с переиспользуемой реактивной логикой — замена миксинам Vue 2.
Как работает v-model? Сахар над :modelValue + @update:modelValue (в 3.4+ — defineModel). Можно несколько с аргументами.
Как компоненты общаются? Props вниз (child), события emit вверх (parent); provide/inject — через уровни; глобально — Pinia; scoped slots — данные из child в разметку parent.
Зачем key в v-for и почему не индекс? Для корректного сопоставления элементов при обновлении (reconciliation). Индекс ломается при вставке/удалении/сортировке → баги состояния; нужен стабильный id.
v-if vs v-show? v-if реально добавляет/удаляет из DOM (дёшево при редком переключении); v-show переключает display (дёшево при частом).
Хуки жизненного цикла? onMounted (DOM готов — запросы/работа с DOM), onUpdated, onUnmounted/onBeforeUnmount (очистка таймеров/подписок) и др.
Pinia vs Vuex? Pinia — официальный современный стор: проще, без мутаций, отличный TS, модульность. Vuex — legacy.
provide/inject vs Pinia? provide/inject — для «локально глобальных» данных в поддереве без prop drilling; Pinia — для общего состояния всего приложения.
Что такое Teleport и Suspense? Teleport рендерит контент в другое место DOM (модалки); Suspense показывает fallback, пока грузятся асинхронные зависимости.
Как оптимизировать Vue-приложение? Стабильные key, computed вместо методов, ленивая загрузка компонентов/маршрутов, shallowRef/markRaw для больших данных, v-once/v-memo, виртуализация списков.
Основные отличия Vue 2 от Vue 3? Proxy-реактивность, Composition API/<script setup>, composables вместо миксинов, фрагменты (несколько корней), Teleport/Suspense, глубокий TypeScript, быстрее и меньше.
Что такое SSR и гидрация? SSR — рендер HTML на сервере (лучше SEO/первый показ); гидрация — «оживление» серверной разметки на клиенте. Метафреймворк — Nuxt.
Почему нельзя мутировать props? Односторонний поток данных: child не владеет данными родителя. Изменение — через событие, родитель меняет у себя (иначе неявные баги и предупреждения Vue).
Что такое Virtual DOM и как он работает? Лёгкое представление DOM в виде объектов (дерево VNode). При изменении состояния строится новое дерево, сравнивается со старым (diffing/reconciliation), и в реальный DOM применяются только точечные изменения (patch) — это быстрее прямых операций с DOM.
Во что компилируется шаблон Vue? В render-функцию, которая возвращает дерево VNode (через h()). Шаблон напрямую не выполняется — его превращает в render-функцию компилятор Vue.
Чем VDOM Vue 3 быстрее Vue 2? Компилятор шаблонов делает оптимизации: static hoisting (статику не пересоздают), patch flags (проверяют только динамические части узла), block tree (обход только динамических узлов), кэш обработчиков. Vue 2 честно обходил всё дерево.
Virtual DOM или прямое обновление (как Svelte)? VDOM (Vue/React) сравнивает деревья и патчит разницу — гибко. Компиляторный подход без VDOM (Svelte) генерирует код точечного обновления DOM — меньше рантайма. Vue сочетает VDOM с компиляторными оптимизациями.