TeoreticQuiz

Vue

Материал для подготовки к собеседованию (Middle / Senior). Ориентир — Vue 3 (Composition API, <script setup>), с пометками отличий от Vue 2 там, где это важно. Термины на английском там, где это принято.

Содержание


Что такое 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 вносит только необходимые изменения.

Как это работает по шагам:

  1. Компонент рендерится → строится дерево VNode (виртуальное представление UI при текущем состоянии).
  2. При изменении реактивных данных Vue создаёт новое дерево VNode.
  3. Новое дерево сравнивается со старым — это diffing (в рамках процесса reconciliation, «согласования»).
  4. 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-show vs v-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 с компиляторными оптимизациями.