Skip to content

Vue 3 Spickzettel

Progressives JavaScript-Framework zum Bauen von Benutzeroberflächen.

01

Erste Schritte

Hello World & Kommentare

Eine Vue-3-App beginnt mit createApp() und mount() auf einem DOM-Element. Interpolation nutzt doppelte geschweifte Klammern {{ }}, um reaktive Daten zu rendern. HTML-Kommentare erscheinen im gerenderten DOM; für Kommentare, die nicht entweichen, /* */ innerhalb von <script>-Blöcken nutzen.

vue3
<!-- index.html -->
<div id="app">
  <p>{{ message }}</p>
  <!-- This is an HTML comment, visible in DOM -->
</div>

<script type="module">
  import { createApp } from 'vue'

  createApp({
    data() {
      return { message: 'Hello Vue 3!' }
    }
  }).mount('#app')
</script>

SFC-Struktur (Single File Component)

Ein SFC bündelt template, script und style in einer .vue-Datei. <script setup> ist die empfohlene Syntax für die Composition API — knapp und ohne Boilerplate. scoped-Stile gelten nur für die aktuelle Komponente und verhindern Ausbluten. Jedes SFC kompiliert zu einem JavaScript-Modul.

vue3
<template>
  <button @click="count++">Count: {{ count }}</button>
</template>

<script setup>
import { ref } from 'vue'
const count = ref(0)
</script>

<style scoped>
button { color: #42B883; }
</style>

App-Instanz & Mount

createApp liefert eine auf sich selbst begrenzte Anwendungsinstanz — kein globaler Vue-Zustand, sodass sich mehrere unabhängige Apps auf einer Seite mounten lassen. Plugins registrieren, globale Werte bereitstellen und die Konfiguration setzen, bevor mount() aufgerufen wird. Nach dem Mount greifen weitere Config-Änderungen nicht mehr.

vue3
import { createApp } from 'vue'
import App from './App.vue'

const app = createApp(App)

// global config / plugins before mounting
app.config.errorHandler = (err) => console.error(err)
app.provide('apiKey', '12345')

app.mount('#app')

Projekt-Scaffolding (Vite)

npm create vue@latest ist das offizielle Scaffolding-Werkzeug und bietet optionales TypeScript, Router, Pinia und Vitest-Setup. Es nutzt Vite für sofortigen Dev-Server-Start und HMR. create-vite ist das niedrigstufigere Werkzeug, wenn du ein minimales Template ohne Vues Meinungen willst.

vue3
# scaffold a new Vue project with Vite
npm create vue@latest my-app
cd my-app
npm install
npm run dev       # start dev server (HMR)
npm run build     # production build to /dist

# or with create-vite directly
npm create vite@latest my-app -- --template vue-ts

defineOptions & defineProps

defineProps, defineEmits und defineOptions sind Compile-Zeit-Makros — sie müssen nicht importiert werden. defineProps deklariert den Prop-Vertrag der Komponente mit Laufzeitvalidierung. defineOptions erlaubt name, inheritAttrs und andere Optionen, die sich in <script setup> nicht direkt ausdrücken lassen.

vue3
<script setup>
// declare props with types and defaults
const props = defineProps({
  title: String,
  count: { type: Number, default: 0 }
})

// declare emits
const emit = defineEmits(['update', 'delete'])

// additional non-reactive options
defineOptions({ name: 'MyButton', inheritAttrs: false })
</script>
02

Template-Syntax

Textinterpolation

{{ }} rendert Text sicher (HTML-escapiert). v-once friert ein Binding nach dem ersten Rendern ein, für statische Inhalte. v-html injiziert rohes HTML — nur auf vertrautem Inhalt nutzen, um XSS zu vermeiden. Innerhalb von {{ }} ist jeder einzelne JavaScript-Ausdruck erlaubt, aber keine Anweisungen wie Zuweisungen oder var-Deklarationen.

vue3
<template>
  <p>{{ message }}</p>
  <!-- renders the value of message -->

  <!-- one-time binding (no updates after render) -->
  <span v-once>{{ initialCount }}</span>

  <!-- raw HTML (sanitize to avoid XSS!) -->
  <div v-html="rawHtmlContent"></div>

  <!-- expressions are supported -->
  <p>{{ count * 2 }}</p>
  <p>{{ isReady ? 'Yes' : 'No' }}</p>
  <p>{{ message.split('').reverse().join('') }}</p>
</template>

Attribut-Binding

v-bind (Kurzform :) bindet Attribute reaktiv. Bei class kannst du ein Objekt (truthy Schlüssel greifen), ein Array oder einen String übergeben. style akzeptiert ein Objekt mit camelCase- oder kebab-case-Schlüsseln. Die dynamische Argument-Syntax :[expr] lässt den Attributnamen selbst reaktiv werden — nützlich für Eventnamen oder lokalisierte Attribute.

vue3
<template>
  <!-- bind an attribute -->
  <img v-bind:src="imageUrl" />
  <img :src="imageUrl" />  <!-- shorthand -->

  <!-- bind class -->
  <div :class="{ active: isActive, error: hasError }"></div>
  <div :class="['btn', isActive && 'active']"></div>

  <!-- bind style -->
  <div :style="{ color: textColor, fontSize: size + 'px' }"></div>

  <!-- dynamic attribute name -->
  <button :[eventName]="handler">Click</button>
</template>

Boolesche & Mehrwert-Attribute

Bei booleschen Attributen wie disabled oder checked rendert Vue das Attribut nur, wenn der Wert truthy ist. class und style sind besonders: Vue verschmilzt statische und gebundene Werte, statt sie zu ersetzen. Bei Formulareingaben v-model statt manuellem :value und @input bevorzugen.

vue3
<template>
  <!-- boolean attribute: presence depends on value -->
  <input :disabled="isDisabled" />
  <button :disabled="!canSubmit">Submit</button>

  <!-- class merging: bound class merges with static class -->
  <div class="card" :class="{ highlighted: isFeatured }"></div>

  <!-- style merging: bound style merges with static style -->
  <div style="color: red" :style="{ fontSize: '14px' }"></div>

  <!-- form attributes: value is bound with v-model instead -->
  <input v-model="text" />
</template>

Modifikatoren & Ausdrücke

Modifikatoren sind Postfixe mit einem Punkt und kennzeichnen besondere Behandlung. Event-Modifikatoren (.prevent, .stop, .once, .self) umhüllen den Handler mit der entsprechenden DOM-Methode. Key-Modifikatoren (.enter, .esc, .ctrl) filtern Events nach Taste. v-model-Modifikatoren (.trim, .number, .lazy) transformieren den Eingabewert vor der Zuweisung.

vue3
<template>
  <!-- .prevent calls event.preventDefault() -->
  <form @submit.prevent="onSubmit">...</form>

  <!-- .stop calls event.stopPropagation() -->
  <button @click.stop="doStuff">Click</button>

  <!-- .once runs handler only one time -->
  <button @click.once="init">Init</button>

  <!-- .trim and .lazy modifiers on v-model -->
  <input v-model.trim="email" />
  <input v-model.lazy="text" />

  <!-- chain multiple modifiers -->
  <input @keyup.enter.ctrl="onCombo" />
</template>

Template-Refs

Template-Refs geben direkten Zugriff auf DOM-Elemente. Ein ref() mit demselben Namen wie das ref-Attribut deklarieren — Vue weist den DOM-Knoten nach dem Mount zu. Zugriff innerhalb von onMounted (oder später); vor dem Mount ist die ref null. Bei v-for wird die ref zu einem Array von Elementen. Auf Refs verzichten, wenn reaktive Datenflüsse genügen.

vue3
<script setup>
import { ref, onMounted } from 'vue'

// declare a ref matching the template ref attribute
const inputEl = ref(null)

onMounted(() => {
  // access the DOM node after mount
  inputEl.value.focus()
})
</script>

<template>
  <input ref="inputEl" />
</template>
03

Direktiven

v-if / v-else-if / v-else

v-if rendert Elemente bedingt — sie werden dem DOM hinzugefügt/entfernt. v-else-if und v-else ketten an ein vorangehendes v-if. Mehrere Elemente in <template v-if> wickeln, wenn du kein Extra-Wrapper-Element willst. v-if hat höhere Umschaltkosten (DOM-Erzeugung), aber niedrigere Initialkosten als v-show, wenn die Bedingung falsch ist.

vue3
<template>
  <div v-if="type === 'A'">Type A</div>
  <div v-else-if="type === 'B'">Type B</div>
  <div v-else-if="type === 'C'">Type C</div>
  <div v-else>Unknown type</div>

  <!-- use <template> for invisible wrapper -->
  <template v-if="showHeader">
    <h1>Title</h1>
    <p>Subtitle</p>
  </template>
</template>

v-show vs. v-if

v-if nutzen, wenn sich die Bedingung selten ändert — Elemente werden zerstört und neu erzeugt, was Renderkosten spart, wenn verborgen. v-show für häufig umgeschaltete Elemente (Tabs, Dropdowns) — das Element bleibt im DOM und nur display:none kippt, das Umschalten ist also billig. v-show funktioniert nicht mit <template> oder v-else.

vue3
<template>
  <!-- v-if removes from DOM when false -->
  <p v-if="isVisible">I'm created/destroyed</p>

  <!-- v-show just toggles display:none -->
  <p v-show="isVisible">I'm always in DOM, just hidden</p>
</template>

<script setup>
import { ref } from 'vue'
const isVisible = ref(true)
</script>

v-for & :key

v-for iteriert Arrays, Objekte oder einen Zahlenbereich. Das :key-Attribut ist PFLICHT für Identitäts-Tracking — es lässt Vue DOM-Knoten beim Umordnen effizient wiederverwenden. Eine stabile eindeutige id als key nutzen; niemals den Array-Index (bricht, wenn Items sich bewegen). v-for hat auf demselben Element höhere Priorität als v-if — beides auf einem Element vermeiden.

vue3
<template>
  <!-- iterate over array -->
  <li v-for="item in items" :key="item.id">
    {{ item.name }}
  </li>

  <!-- iterate with index -->
  <li v-for="(item, index) in items" :key="item.id">
    {{ index }}: {{ item.name }}
  </li>

  <!-- iterate over object -->
  <li v-for="(value, key) in user" :key="key">
    {{ key }}: {{ value }}
  </li>

  <!-- range (1 to n) -->
  <span v-for="n in 10" :key="n">{{ n }}</span>
</template>

v-model-Bindings

v-model ist Zweiweg-Binding für Formulareingaben: Es synchronisiert den Eingabewert mit reaktivem State. Eine einzelne Checkbox bindet an einen Boolean; mehrere Checkboxen mit demselben v-model binden an ein Array angehakter Werte. Modifikatoren nutzen: .lazy (Sync bei change statt input), .number (in Zahl casten), .trim (Whitespace strippen).

vue3
<template>
  <!-- text input -->
  <input v-model="text" />

  <!-- multi-line textarea -->
  <textarea v-model="message"></textarea>

  <!-- checkbox (single = boolean, multiple = array) -->
  <input type="checkbox" v-model="isChecked" />
  <input type="checkbox" value="apple" v-model="fruits" />
  <input type="checkbox" value="banana" v-model="fruits" />

  <!-- radio -->
  <input type="radio" value="A" v-model="picked" />

  <!-- select -->
  <select v-model="selected">
    <option value="a">A</option>
    <option value="b">B</option>
  </select>
</template>

Eigene Direktiven

Eigene Direktiven erlauben direkte DOM-Manipulation. In <script setup> ist jede Variable namens vSomething (camelCase) automatisch als v-something im Template verfügbar. Das Direktiven-Objekt hat Lifecycle-Hooks: mounted, updated, unmounted usw. Komponenten statt Direktiven bevorzugen, wenn du Reaktivität brauchst — Direktiven sind für Low-Level-DOM-Arbeit wie Fokus, Tooltips oder Drag.

vue3
<script setup>
// local directive: function form (mounted + updated)
const vFocus = {
  mounted: (el) => el.focus()
}

// global registration
// app.directive('focus', { mounted: el => el.focus() })
</script>

<template>
  <input v-focus />
</template>
04

Computed-Properties

Einfaches Computed

computed erzeugt einen gecachten Getter, der nur neu auswertet, wenn sich seine Dependencies ändern. Anders als ein Methodenaufruf liefert wiederholter Zugriff den gecachten Wert, bis eine Dependency sich aktualisiert. In <script> über .value zugreifen; in Templates unwrapt Vue automatisch. computed statt Methoden, wann immer der Wert von reaktivem State abhängt — schneller und deklarativ.

vue3
<script setup>
import { ref, computed } from 'vue'

const firstName = ref('John')
const lastName = ref('Doe')

// computed caches based on dependencies
const fullName = computed(() => {
  return firstName.value + ' ' + lastName.value
})

// access via .value in script
console.log(fullName.value)  // 'John Doe'
</script>

<template>
  <!-- use without .value in template -->
  <p>{{ fullName }}</p>
</template>

Beschreibbares Computed

Standardmäßig ist computed nur lesend, aber du kannst einen Getter und Setter liefern. Der Setter wird aufgerufen, wenn du .value zuweist. Nützlich für Zweiweg-Binding auf abgeleitetem State, etwa einen Vornamen-Eingabewert zurück auf Vor-/Nachname-Felder zu synchronisieren. Endlosschleifen vermeiden — Setter dürfen die eigenen Dependencies des Computed nicht so setzen, dass er sich selbst erneut auslöst.

vue3
<script setup>
import { ref, computed } from 'vue'

const firstName = ref('John')
const lastName = ref('Doe')

const fullName = computed({
  get() {
    return firstName.value + ' ' + lastName.value
  },
  set(newValue) {
    [firstName.value, lastName.value] = newValue.split(' ')
  }
})

// assignment triggers the setter
fullName.value = 'Jane Smith'
</script>

Computed vs. Methoden

Computed-Properties cachen ihr Ergebnis anhand der Dependencies — sie laufen nur neu, wenn sich items ändert. Methoden laufen bei jedem Rendern neu, egal was sich änderte. computed für aus reaktivem State abgeleitete Werte; Methoden für Aktionen mit Parametern oder Nebenwirkungen. Computed macht die Absicht auch klarer: 'dieser Wert ist abgeleitet' vs. 'tue dies'.

vue3
<script setup>
import { ref, computed } from 'vue'

const items = ref([1, 2, 3, 4, 5])

// computed: cached, re-runs only if items changes
const doubled = computed(() =>
  items.value.map(x => x * 2)
)

// method: re-runs on every render
function getDoubled() {
  return items.value.map(x => x * 2)
}
</script>

<template>
  <!-- cached, no recompute on unrelated re-renders -->
  <p>{{ doubled }}</p>

  <!-- re-invoked on every render -->
  <p>{{ getDoubled() }}</p>
</template>

Computed-Getter-Fallstricke

Computed-Getter müssen rein sein: keine Nebenwirkungen (keine Mutationen, kein async, keine Fetches). Date.now() oder Math.random() nicht aufrufen — sie sind nicht reaktiv, das Computed aktualisiert sich also nicht. Für eine Nebenwirkung lieber einen Watcher nutzen. Brauchst du async, awaited computed nicht — watch + eine ref oder async setup mit Suspense verwenden.

vue3
<script setup>
import { ref, computed } from 'vue'

const date = ref(new Date())

// BAD: non-reactive Date.now() — won't update
const badTime = computed(() => Date.now())

// BAD: side effect inside computed
const count = ref(0)
const bad = computed(() => {
  count.value++   // never mutate state in computed!
  return count.value
})

// GOOD: pure function of reactive state
const formatted = computed(() =>
  date.value.toLocaleDateString()
)
</script>

Computed in der Options-API

In der Options-API werden computed in der computed-Option deklariert. Sie werden als this.total angesprochen (kein .value, keine Klammern) — Vue unwrapt automatisch. Beschreibbares computed nutzt get/set-Funktionen. Computed-Properties werden neben data und methods auf der Komponenteninstanz exponiert, alle über this zugänglich.

vue3
<script>
export default {
  data() {
    return { price: 100, quantity: 2 }
  },
  computed: {
    total() {
      return this.price * this.quantity
    },
    discounted: {
      get() { return this.total * 0.9 },
      set(v) { this.price = v / 0.9 / this.quantity }
    }
  },
  methods: {
    checkout() { console.log(this.total) }
  }
}
</script>
05

Watcher

Einfaches watch

watch führt einen Callback aus, wenn sich die beobachtete Quelle ändert. Die Quelle kann eine ref, eine Eigenschaft eines reaktiven Objekts (via Getter) oder ein Array von Quellen sein. Der Callback erhält (newValue, oldValue). Einen Getter () => x.y nutzen, um verschachtelte reaktive Eigenschaften zu beobachten. Watcher sind für Nebenwirkungen (fetch, log, persist) — nicht zum Ableiten von State (dafür computed).

vue3
<script setup>
import { ref, watch } from 'vue'

const question = ref('')

// watch a ref
watch(question, (newValue, oldValue) => {
  console.log('changed from', oldValue, 'to', newValue)
})

// watch a getter (computed source)
watch(
  () => question.value.length,
  (newLen) => {
    if (newLen > 100) console.warn('Too long!')
  }
)
</script>

Deep-Watch & Immediate

deep: true lässt watch bei Änderungen an jeder verschachtelten Eigenschaft eines Objekts feuern — nützlich, aber teuer bei großen Strukturen. immediate: true feuert den Callback sofort beim Setup (oldValue ist beim ersten Aufruf undefined). Deep-Watch auf riesigen Objekten vermeiden — lieber einen spezifischen Getter () => obj.specificField beobachten für bessere Performance.

vue3
<script setup>
import { reactive, watch } from 'vue'

const user = reactive({
  name: 'Alice',
  address: { city: 'NYC', zip: '10001' }
})

// deep: watch nested property changes
watch(
  () => user.address,
  (newAddr) => console.log('address changed', newAddr),
  { deep: true }
)

// immediate: run callback right away
watch(
  user,
  (val) => saveToServer(val),
  { deep: true, immediate: true }
)
</script>

watchEffect (auto-getrackt)

watchEffect führt den Callback sofort aus und trackt automatisch jede darin gelesene reaktive Dependency. Ändert sich irgendeine getrackte Dep, läuft der Callback erneut. Anders als watch gibst du keine Quelle an — sie wird abgeleitet. watchEffect nutzen, wenn du den oldValue nicht brauchst und automatisches Dependency-Tracking willst. Praktisch, um Subscriptions einzurichten, die mehrere reaktive Quellen lesen.

vue3
<script setup>
import { ref, watchEffect } from 'vue'

const a = ref(1)
const b = ref(2)

// runs immediately and tracks dependencies automatically
watchEffect(() => {
  console.log('a + b =', a.value + b.value)
})
// logs: a + b = 3

a.value = 10  // logs: a + b = 12

// stop the watcher
const stop = watchEffect(() => { /* ... */ })
stop()  // cleanup
</script>

watch vs. watchEffect

watch wählen, wenn du brauchst: oldValue, lazy Ausführung (ersten Lauf überspringen) oder eine bestimmte Quelle explizit beobachten. watchEffect wählen, wenn: sofortige Ausführung gewollt, oldValue nicht gebraucht oder Nebenwirkungen mehrere reaktive Werte berühren und Auto-Tracking gewollt ist. watch mit einer Array-Quelle liefert im Callback Arrays neuer/alter Werte.

vue3
<script setup>
import { ref, watch, watchEffect } from 'vue'

const count = ref(0)

// watch: lazy, explicit source, has oldValue
watch(count, (newVal, oldVal) => {
  console.log('count changed:', oldVal, '->', newVal)
})

// watchEffect: eager, auto-tracked, no oldValue
watchEffect(() => {
  console.log('count is', count.value)
})
// logs immediately: count is 0

// watch multiple sources
const a = ref(1), b = ref(2)
watch([a, b], ([newA, newB], [oldA, oldB]) => {
  console.log('a or b changed')
})
</script>

Watcher-Cleanup & Flush

Der onCleanup-Callback (3. Argument) registriert eine Aufräumfunktion, die vor dem nächsten Watcher-Aufruf läuft — perfekt, um laufende Requests abzubrechen, Timer zu leeren oder sich abzumelden. flush: 'post' lässt den Watcher laufen, nachdem Vue das DOM aktualisiert hat (nützlich, wenn du das aktualisierte DOM lesen willst). 'sync' läuft synchron bei Dep-Änderung — selten nötig und kann Performanceprobleme verursachen.

vue3
<script setup>
import { ref, watch } from 'vue'

const id = ref(1)

// cleanup function: runs before next callback
watch(id, (newId, oldId, onCleanup) => {
  const controller = new AbortController()
  fetch(`/api/user/${newId}`, { signal: controller.signal })
    .then(r => r.json())

  // cancel previous request when id changes again
  onCleanup(() => controller.abort())
}, { flush: 'post' })

// flush: 'pre' (default) | 'post' (after DOM update) | 'sync'
</script>
06

Bedingtes Rendern

v-if vs. v-show

v-if fügt Elemente dem DOM wirklich hinzu/entfernt sie — höhere Initialkosten, aber keine Kosten, wenn verborgen. v-show rendert das Element immer und kippt display:none — billigeres Umschalten, aber das Element existiert auch verborgen. v-if für Bedingungen, die sich selten ändern (oder wenn verborgene Elemente gar nicht existieren sollen). v-show für häufig umgeschaltete UI wie Tabs, Dropdowns, Modals.

vue3
<template>
  <!-- v-if: element removed from DOM when false -->
  <div v-if="isLoggedIn">Welcome back</div>

  <!-- v-show: element stays, display toggles -->
  <div v-show="isLoggedIn">Welcome back</div>
</template>

<!-- v-show compiles to: -->
<!-- <div style="display: none;">Welcome back</div> when false -->

<!-- v-if does not render the element at all when false -->

v-if mit v-else-Kette

v-else-if und v-else müssen unmittelbar auf ein v-if (oder ein anderes v-else-if) folgen — kein anderes Element darf dazwischen stehen. Die Kette wertet von oben nach unten aus und stoppt bei der ersten truthy Bedingung. Das finale v-else fängt alle übrigen Fälle. Dieses Muster ist super für statusbasierte UI (loading, error, empty, success).

vue3
<template>
  <div v-if="status === 'loading'">Loading...</div>
  <div v-else-if="status === 'error'">Error occurred</div>
  <div v-else-if="status === 'empty'">No items</div>
  <div v-else>
    <ul>
      <li v-for="item in items" :key="item.id">{{ item.name }}</li>
    </ul>
  </div>
</template>

<template>-Wrapper für v-if

<template> ist ein logischer Wrapper, der nicht ins DOM rendert — perfekt, um mehrere Elemente unter ein v-if oder v-for zu gruppieren, ohne Extra-HTML zu ergänzen. So bleibt dein Markup semantisch (keine herrenlosen divs). Bei v-for auf template brauchst du weiterhin :key auf dem Template-Element selbst.

vue3
<template>
  <!-- group elements under one condition, no wrapper div -->
  <template v-if="showProfile">
    <h2>{{ user.name }}</h2>
    <p>{{ user.bio }}</p>
    <button @click="edit">Edit</button>
  </template>

  <!-- combine v-if with v-for on template -->
  <template v-for="item in items" :key="item.id">
    <dt>{{ item.term }}</dt>
    <dd>{{ item.def }}</dd>
  </template>
</template>

v-if vs. v-for-Priorität

v-if und v-for nie auf demselben Element nutzen. In Vue 3 hat v-if höhere Priorität und läuft also vor v-for — die Schleifenvariable ist noch nicht verfügbar, was Fehler verursacht. Stattdessen das Array mit einer computed-Property filtern (bevorzugt) oder inline .filter(). Wenn es sein muss, ein umhüllendes <template v-for> mit einem inneren v-if nutzen.

vue3
<template>
  <!-- AVOID: v-if and v-for on same element -->
  <!-- In Vue 3, v-if has higher priority than v-for -->
  <!-- so 'item' is not defined when v-if evaluates -->
  <li v-for="item in items" v-if="item.active" :key="item.id">
    {{ item.name }}
  </li>

  <!-- GOOD: filter first, then iterate -->
  <li
    v-for="item in items.filter(i => i.active)"
    :key="item.id"
  >
    {{ item.name }}
  </li>

  <!-- BEST: use computed for the filtered list -->
</template>

Transition mit v-if

Ein v-if-(oder v-show-)Element in <Transition> wickeln, um Eintritt/Austritt zu animieren. Vue ergänzt Klassen zu den richtigen Zeitpunkten: v-enter-from, v-enter-active, v-enter-to (und v-leave-*). CSS-Übergänge auf diesen Klassen definieren. name='fade' ersetzt das 'v-'-Präfix durch 'fade-'. Transition unterstützt nur ein einziges Kindelement — für Listen TransitionGroup nutzen.

vue3
<template>
  <Transition name="fade">
    <p v-if="show">Hello</p>
  </Transition>
</template>

<style>
.fade-enter-active, .fade-leave-active {
  transition: opacity 0.3s;
}
.fade-enter-from, .fade-leave-to {
  opacity: 0;
}
</style>
07

Listen-Rendering

v-for mit Arrays

v-for iteriert Arrays und legt jedes Item und (optional) den Index offen. :key IMMER an einen stabilen eindeutigen Wert wie item.id binden — das lässt Vue alte und neue Knoten beim Umordnen matchen und erhält Komponenten-Zustand und DOM effizient. Index als key zu nutzen bricht, wenn Items eingefügt/entfernt/umgeordnet werden, und verursacht subtile Bugs.

vue3
<script setup>
import { ref } from 'vue'
const items = ref([
  { id: 1, name: 'Apple' },
  { id: 2, name: 'Banana' },
  { id: 3, name: 'Cherry' }
])
</script>

<template>
  <!-- always provide :key with stable unique id -->
  <li v-for="item in items" :key="item.id">
    {{ item.name }}
  </li>

  <!-- with index (avoid as :key) -->
  <li v-for="(item, index) in items" :key="item.id">
    {{ index + 1 }}. {{ item.name }}
  </li>
</template>

v-for mit Objekten & Bereich

v-for über ein Objekt iteriert standardmäßig Werte; das zweite Argument ist der Schlüssel, das dritte der Index. Die Objekt-Iterationsreihenfolge folgt Object.keys() (Einfügereihenfolge bei Stringschlüsseln). v-for mit einer Zahl n iteriert von 1 bis n (inklusiv, nicht 0 bis n-1). Für gefilterte oder sortierte Listen lieber eine computed-Property statt inline Logik, für Lesbarkeit und Caching.

vue3
<template>
  <!-- iterate object: (value, key, index) -->
  <div v-for="(value, key, index) in user" :key="key">
    {{ index }}. {{ key }}: {{ value }}
  </div>

  <!-- iterate a number range (1 to n inclusive) -->
  <span v-for="n in 10" :key="n">{{ n }} </span>
  <!-- 1 2 3 4 5 6 7 8 9 10 -->

  <!-- use v-for of computed for derived lists -->
  <li v-for="todo in doneTodos" :key="todo.id">
    {{ todo.text }}
  </li>
</template>

Änderungserkennung bei Listen

Vue 3 nutzt Proxy-basierte Reaktivität, sodass Array-Mutationen mit push, pop, splice, sort, reverse alle Updates auslösen — keine besonderen Vorbehalte (anders als Vue 2). Das ganze Array zu ersetzen (items.value = newArray) funktioniert ebenfalls, weil der Wert-Setter der ref die Reaktivität auslöst. Filter/map erzeugen neue Arrays — zurück zuweisen, um zu aktualisieren.

vue3
<script setup>
import { ref } from 'vue'

const items = ref([1, 2, 3])

// MUTATION methods (Vue 3 detects these via Proxy)
items.value.push(4)        // add
items.value.pop()          // remove last
items.value.splice(1, 1)   // remove at index
items.value.sort()         // sort

// REPLACEMENT (always reactive)
items.value = items.value.filter(n => n > 1)
items.value = [...items.value, 5]
</script>

TransitionGroup für Listen

TransitionGroup animiert v-for-Listen: Eintritt, Austritt UND Bewegung (wenn Items ihre Position wechseln). Anders als Transition rendert er ein echtes Element (via tag gesetzt). Jedes Kind BRAUCHT einen eindeutigen :key. Die .list-move-Klasse animiert Items, die zu ihren neuen Positionen gleiten, wenn die Liste umordnet — ein polierter Effekt, den plain CSS nicht erreicht. leave-active braucht position: absolute für weiche Bewegungen.

vue3
<template>
  <TransitionGroup name="list" tag="ul">
    <li v-for="item in items" :key="item.id">
      {{ item.text }}
    </li>
  </TransitionGroup>
</template>

<style>
.list-enter-active, .list-leave-active {
  transition: all 0.5s ease;
}
.list-enter-from, .list-leave-to {
  opacity: 0;
  transform: translateX(30px);
}
/* animate items moving to new positions */
.list-move {
  transition: transform 0.5s ease;
}
</style>

Performance: v-memo

v-memo ist ein Optimierungshinweis. Vue überspringt das Neu-Rendern des Elements, außer sich einer der Werte im Dependency-Array ändert. Bei großen Listen, wo sich die meisten Items pro Update nicht ändern, kann das Neu-Renders dramatisch reduzieren. Nur nutzen, wenn du ein Performanceproblem gemessen hast — voreilige Optimierung ergänzt Komplexität und Risiko veralteter UI.

vue3
<template>
  <!-- skip re-render of this item unless 'id' or 'selected' changes -->
  <div
    v-for="item in hugeList"
    :key="item.id"
    v-memo="[item.id, item.id === selectedId]"
  >
    {{ item.name }} — {{ item.id === selectedId ? '★' : '' }}
  </div>
</template>
08

Event-Behandlung

Inline-Handler

@click (Kurzform von v-on:click) bindet einen Klick-Handler. Inline-Anweisungen (count++) funktionieren für einfache Fälle. Ein Methodenname (greet) erhält automatisch das native Event als erstes Argument. Um eigene Argumente UND das Event zu übergeben, die Methode explizit mit $event aufrufen: greet('hi', $event).

vue3
<script setup>
import { ref } from 'vue'
const count = ref(0)
const name = ref('Vue')

function greet(event) {
  alert('Hello ' + name.value)
  // event is the native DOM event
  console.log(event.target.tagName)
}
</script>

<template>
  <!-- inline statement -->
  <button @click="count++">Add</button>

  <!-- method reference (auto-receives event) -->
  <button @click="greet">Greet</button>

  <!-- call with custom args (use $event for native event) -->
  <button @click="greet($event)">Greet</button>
</template>

Event-Modifikatoren

Event-Modifikatoren ketten nach dem Eventnamen mit einem Punkt. .prevent und .stop sind am häufigsten (Formularabsenden, Event-Bubbling). .self stellt sicher, dass der Handler nur feuert, wenn das Element selbst (nicht ein Kind) geklickt wird. .passive sagt dem Browser, dass der Handler preventDefault nicht aufruft, und ermöglicht weicheres Scrollen — wichtig für Touch-/Scroll-Handler.

vue3
<template>
  <!-- .prevent: call preventDefault() -->
  <form @submit.prevent="onSubmit">...</form>

  <!-- .stop: call stopPropagation() -->
  <div @click="outer">
    <button @click.stop="inner">Won't bubble</button>
  </div>

  <!-- .self: only trigger if event.target === current element -->
  <div @click.self="onSelf">Only direct clicks</div>

  <!-- .once: handler removed after first invocation -->
  <button @click.once="init">Init once</button>

  <!-- .capture: use capture phase instead of bubble -->
  <div @click.capture="onCapture">...</div>

  <!-- .passive: improve scroll perf (no preventDefault) -->
  <div @scroll.passive="onScroll">...</div>
</template>

Key- & System-Modifikatoren

Key-Modifikatoren filtern Tastatur-Events nach Tastennamen (.enter, .esc, .delete, .space, .tab, .up, .down, .left, .right). System-Modifikatoren (.ctrl, .alt, .shift, .meta) verlangen, dass diese Taste gehalten wird. .exact stellt sicher, dass KEINE anderen System-Modifikatoren gehalten werden — @click.ctrl.exact feuert nur bei Ctrl+Klick, nicht bei Ctrl+Shift+Klick. Kebab-case für Tasten nutzen, die Vue nicht aliasiert (page-down).

vue3
<template>
  <!-- key modifiers: only fire on specific keys -->
  <input @keyup.enter="submit" />
  <input @keyup.esc="cancel" />
  <input @keyup.delete="remove" />

  <!-- system modifiers: ctrl, alt, shift, meta -->
  <button @click.ctrl="openInNewTab">Ctrl+Click</button>
  <input @keyup.alt.enter="altEnter" />

  <!-- .exact: no other modifiers can be pressed -->
  <button @click.ctrl.exact="onCtrlOnly">Ctrl only</button>

  <!-- any key code via kebab-case (deprecated but works) -->
  <input @keyup.page-down="onPageDown" />
</template>

Eigene Events mit emit

Kindkomponenten emittieren Events, um nach oben zu kommunizieren. defineEmits deklariert die Eventnamen (für Validierung und IDE-Hinweise genutzt). Der Parent lauscht mit @event-name. Payloads werden als zusätzliche Argumente an emit übergeben und vom Handler des Parents empfangen. Konvention: kebab-case-Eventnamen in Templates (my-event), camelCase in defineEmits (myEvent) — Vue konvertiert automatisch.

vue3
<!-- ChildButton.vue -->
<script setup>
const emit = defineEmits(['increment', 'delete'])

function onClick() {
  // emit with payload
  emit('increment', 1)
}
</script>

<template>
  <button @click="onClick">+1</button>
</template>

<!-- Parent.vue -->
<template>
  <ChildButton @increment="onIncrement" @delete="remove" />
</template>

<script setup>
function onIncrement(amount) {
  console.log('incremented by', amount)
}
</script>

v-model auf Komponenten

defineModel() ist das moderne (Vue 3.4+) Makro für Zweiweg-Binding auf Komponenten — er liefert eine ref, die sich automatisch mit dem v-model des Parents synchronisiert. Für mehrere Bindings benannte Modelle nutzen: v-model:fieldName. Unter der Haube emittiert das 'update:modelValue' (oder 'update:fieldName') und der Parent synchronisiert die gebundene ref. Älterer Code nutzt defineProps + defineEmits manuell.

vue3
<!-- CustomInput.vue -->
<script setup>
const model = defineModel()
</script>

<template>
  <input :value="model" @input="model = $event.target.value" />
</template>

<!-- Parent.vue -->
<template>
  <CustomInput v-model="text" />
</template>

<!-- multiple v-models (Vue 3.4+) -->
<template>
  <UserForm v-model:name="name" v-model:email="email" />
</template>
09

Formular-Bindings

Text & Textarea

v-model auf Texteingaben synchronisiert bei jedem input-Event. Bei textarea v-model direkt auf das Element setzen (nicht als :value — mehrzeiliger Inhalt im Attribut funktioniert nicht). Modifikatoren: .lazy synchronisiert bei blur/change (weniger Updates), .trim strippt Whitespace, .number castet den Wert in eine Number. Modifikatoren verketten: v-model.lazy.trim.

vue3
<script setup>
import { ref } from 'vue'
const text = ref('')
const message = ref('')
</script>

<template>
  <!-- text input: binds on every keystroke -->
  <input v-model="text" placeholder="Type here" />
  <p>You typed: {{ text }}</p>

  <!-- textarea: insert tags inside, not :value -->
  <textarea v-model="message" rows="4"></textarea>
  <p>Preview: {{ message }}</p>

  <!-- .lazy: sync on 'change' (blur) instead of 'input' -->
  <input v-model.lazy="text" />

  <!-- .trim: strip leading/trailing whitespace -->
  <input v-model.trim="text" />

  <!-- .number: cast to Number (NaN if invalid) -->
  <input v-model.number="age" type="number" />
</template>

Checkbox & Radio

Eine einzelne Checkbox bindet an einen Boolean (checked = true). Mehrere Checkboxen, die dasselbe v-model teilen, binden an ein Array ihrer value-Attribute — Anhaken ergänzt den Wert, Abhaken entfernt ihn. Radiobuttons, die ein v-model teilen, binden den Wert der gewählten Option an die ref. true-value / false-value-Attribute nutzen, um die boolesche Zuordnung anzupassen.

vue3
<script setup>
import { ref } from 'vue'
const agreed = ref(false)
const fruits = ref([])     // array for multi-checkbox
const picked = ref('')     // string for radio
</script>

<template>
  <!-- single checkbox -> boolean -->
  <input type="checkbox" v-model="agreed" /> I agree

  <!-- multiple checkboxes with same v-model -> array -->
  <input type="checkbox" value="apple" v-model="fruits" /> Apple
  <input type="checkbox" value="banana" v-model="fruits" /> Banana
  <input type="checkbox" value="cherry" v-model="fruits" /> Cherry
  <p>Selected: {{ fruits }}</p>

  <!-- radio: value binds to the chosen option -->
  <input type="radio" value="A" v-model="picked" /> A
  <input type="radio" value="B" v-model="picked" /> B
</template>

Select

Bei <select> geht v-model auf das select-Element (nicht die Optionen) und synchronisiert mit dem Wert der gewählten Option. Eine deaktivierte Platzhalter-Option mit leerem Wert für die 'bitte wählen'-UX nutzen. Bei dynamischen Optionen diese mit v-for rendern und :value binden. Das multiple-Attribut ergänzen, um Mehrfachauswahl zu erlauben — v-model bindet dann an ein Array gewählter Werte.

vue3
<script setup>
import { ref } from 'vue'
const selected = ref('')
const multi = ref([])

const options = [
  { value: 'a', label: 'Option A' },
  { value: 'b', label: 'Option B' }
]
</script>

<template>
  <!-- single select -->
  <select v-model="selected">
    <option disabled value="">Please select</option>
    <option value="a">A</option>
    <option value="b">B</option>
  </select>

  <!-- dynamic options -->
  <select v-model="selected">
    <option v-for="opt in options" :key="opt.value" :value="opt.value">
      {{ opt.label }}
    </option>
  </select>

  <!-- multi-select (hold Ctrl/Cmd) -> array -->
  <select v-model="multi" multiple>
    <option value="x">X</option>
    <option value="y">Y</option>
  </select>
</template>

Formular-Absenden & Validierung

@submit.prevent nutzen, um das Absenden zu handhaben und gleichzeitig das Standard-Seiten-Neuladen zu verhindern. Reaktive Formularobjekte gruppieren verwandte Felder. Für Validierung sind Bibliotheken wie VeeValidate oder Zod + ein Composable bei komplexen Formularen beliebt, aber eine einfache validate()-Funktion, die ein errors-Objekt liefert, reicht bei kleinen Formularen gut. Immer default verhindern, um SPA-artige Absendungen zu ermöglichen.

vue3
<script setup>
import { reactive, ref } from 'vue'

const form = reactive({
  email: '',
  password: ''
})
const errors = ref({})

function validate() {
  errors.value = {}
  if (!form.email.includes('@')) errors.value.email = 'Invalid email'
  if (form.password.length < 6) errors.value.password = 'Too short'
  return Object.keys(errors.value).length === 0
}

function onSubmit() {
  if (!validate()) return
  // submit form...
}
</script>

<template>
  <form @submit.prevent="onSubmit">
    <input v-model.trim="form.email" />
    <span v-if="errors.email">{{ errors.email }}</span>

    <input type="password" v-model="form.password" />
    <span v-if="errors.password">{{ errors.password }}</span>

    <button type="submit">Submit</button>
  </form>
</template>

v-model mit eigenen Komponenten

Formularfelder zur Wiederverwendung in eigene Komponenten wickeln. defineModel() liefert eine ref, die den Wert des Parents liest und via 'update:modelValue'-Emit zurückschreibt. Die Komponente bindet :value an das Modell und @input aktualisiert es. Dieses Muster erlaubt ein konsistentes Designsystem aus Formulareingaben (BaseInput, BaseSelect, BaseCheckbox), das mit v-model wie native Elemente funktioniert.

vue3
<!-- BaseInput.vue -->
<script setup>
const model = defineModel()

defineProps({
  label: String,
  type: { type: String, default: 'text' }
})
</script>

<template>
  <label>
    {{ label }}
    <input
      :type="type"
      :value="model"
      @input="model = $event.target.value"
    />
  </label>
</template>

<!-- Usage -->
<template>
  <BaseInput v-model="email" label="Email" type="email" />
</template>
10

Komponenten

Komponenten definieren & nutzen

Eine Komponente ist eine .vue-Datei mit template, script und optionalem style. Importieren (in <script setup> lokal automatisch registriert) und als eigenes HTML-Tag nutzen. Komponentennamen sind im Skript PascalCase und dürfen im Template kebab-case sein (my-button) — Vue normalisiert sie. Global registrierte Komponenten (app.component) sind überall ohne Import verfügbar.

vue3
<!-- MyButton.vue -->
<template>
  <button class="btn"><slot /></button>
</template>

<!-- App.vue -->
<script setup>
import MyButton from './MyButton.vue'
</script>

<template>
  <MyButton>Click me</MyButton>
</template>

Dynamische Komponenten

<component :is='...'> rendert eine Komponente dynamisch — der Wert kann ein registrierter Namensstring, ein importiertes Komponentenobjekt oder ein defineAsyncComponent sein. In <keep-alive> wickeln, um den Komponentenzustand (Formulareingabe, Scrollposition) beim Umschalten zwischen Tabs zu erhalten. Für Komponentenobjekte shallowRef (nicht ref) nutzen, um den Deep-Reaktivitäts-Overhead zu vermeiden.

vue3
<script setup>
import { ref, shallowRef } from 'vue'
import HomeTab from './HomeTab.vue'
import PostsTab from './PostsTab.vue'
import ArchiveTab from './ArchiveTab.vue'

const tabs = { HomeTab, PostsTab, ArchiveTab }
const current = shallowRef('HomeTab')

// keep component state when switching (e.g. form input)
import { keep-alive } from 'vue' // not real — use the tag
</script>

<template>
  <button v-for="(comp, name) in tabs" :key="name" @click="current = name">
    {{ name }}
  </button>

  <keep-alive>
    <component :is="tabs[current]" />
  </keep-alive>
</template>

Asynchrone Komponenten

defineAsyncComponent lädt eine Komponente lazy beim ersten Rendern — der Chunk wird bei Bedarf geholt und verkleinert das initiale Bündel. Lade-/Fehlerzustände konfigurieren für eine weiche UX. Mit Suspense kombinieren, um mehrere asynchrone Komponenten zu koordinieren. Der Loader liefert ein Promise des Komponentenmoduls (Vite/Webpack splitten automatisch anhand des dynamischen import()).

vue3
<script setup>
import { defineAsyncComponent } from 'vue'

// lazy-load on first use (code-split)
const HeavyChart = defineAsyncComponent(() =>
  import('./HeavyChart.vue')
)

// with loading, error, delay, timeout states
const AdminPanel = defineAsyncComponent({
  loader: () => import('./AdminPanel.vue'),
  loadingComponent: LoadingSpinner,
  errorComponent: ErrorMsg,
  delay: 200,        // show loading after 200ms
  timeout: 5000      // error if not loaded in 5s
})
</script>

<template>
  <HeavyChart />
  <AdminPanel />
</template>

Komponenten-v-model (mehrfach)

Benannte Modelle lassen eine einzelne Komponente mehrere Zweiweg-Bindings exponieren. defineModel('name') deklariert jedes. Der Parent nutzt v-model:name='...'. Super für Formularkomponenten, die mehrere Felder bündeln (z. B. eine Adresskomponente mit Straße, Stadt, PLZ). Das Standard-v-model (ohne Name) mappt auf 'modelValue'.

vue3
<!-- UserForm.vue -->
<script setup>
const firstName = defineModel('firstName')
const lastName = defineModel('lastName')
</script>

<template>
  <input v-model="firstName" />
  <input v-model="lastName" />
</template>

<!-- Parent.vue -->
<template>
  <UserForm
    v-model:firstName="form.first"
    v-model:lastName="form.last"
  />
</template>

Rekursive & zirkuläre Komponenten

Eine Komponente kann sich über ihren Dateinamen selbst referenzieren (Auto-Selbstreferenz). Perfekt für Baumstrukturen (Dateibäume, Kommentar-Threads, Menüs). Bei zirkulären Referenzen zwischen zwei Komponenten (A importiert B, B importiert A) für eine davon defineAsyncComponent nutzen oder in beforeCreate importieren. Vue handhabt rekursive Komponenten, aber auf Endlosschleifen achten — immer einen Basisfall haben (keine Kinder).

vue3
<!-- TreeNode.vue -->
<script setup>
defineProps({
  node: Object
})

// a component can reference itself by its filename
// TreeNode.vue can use <TreeNode /> recursively
</script>

<template>
  <div>
    {{ node.label }}
    <ul v-if="node.children?.length">
      <li v-for="child in node.children" :key="child.id">
        <TreeNode :node="child" />
      </li>
    </ul>
  </div>
</template>
11

Props

Props deklarieren

defineProps deklariert den Eingabevertrag einer Komponente. Die Laufzeitdeklaration unterstützt type, default, required und validator. Die typbasierte Deklaration von Vue 3 (nur TS) gibt Typsicherheit, verliert aber die Laufzeitvalidierung (mit volar + einer Validator-Bibliothek nutzen). Defaults für Objekte/Arrays müssen eine Factory-Funktion nutzen: default: () => [].

vue3
<script setup>
// runtime declaration (validates types)
const props = defineProps({
  title: String,
  count: { type: Number, default: 0 },
  items: { type: Array, required: true },
  callback: { type: Function, default: () => {} },
  status: {
    type: String,
    validator: (v) => ['active', 'idle'].includes(v)
  }
})

// type-based declaration (TS only, no runtime validation)
const props2 = defineProps<{
  title: string
  count?: number
}>()
</script>

Prop-Benennung & -Übergabe

Props sollten in JS camelCase sein (greetingMessage) und in Templates kebab-case (greeting-message) — HTML ist schreibunabhängig, kebab-case ist also sicherer. Vue konvertiert automatisch zwischen beiden. Statische String-Props nutzen plain Attributsyntax; dynamische Werte :prop. Zahlen/Booleans/Objekte immer mit : übergeben, damit sie nicht als Strings behandelt werden.

vue3
<!-- Child.vue -->
<script setup>
defineProps({
  greetingMessage: String,
  userId: Number
})
</script>

<!-- Parent.vue -->
<template>
  <!-- kebab-case in templates (HTML-friendly) -->
  <Child greeting-message="Hello" :user-id="42" />

  <!-- camelCase also works in SFC templates -->
  <Child greetingMessage="Hello" :userId="42" />
</template>

Einweg-Datenfluss

Props sind nur lesend — nie direkt mutieren. Vue warnt im Dev-Modus. Um einen Prop-Wert zu ändern, ein Event emittieren und den Parent aktualisieren lassen (Einweg-Datenfluss). Für eine lokale Arbeitskopie eine ref aus dem Prop initialisieren und via watch synchronisieren. Das sauberste Zweiweg-Muster ist v-model mit defineModel, das den Emit-und-Update-Tanz abstrahiert.

vue3
<!-- BAD: mutating a prop -->
<script setup>
const props = defineProps(['count'])

function inc() {
  props.count++  // WARNING: don't mutate props!
}
</script>

<!-- GOOD: emit to parent, or use local copy -->
<script setup>
import { ref, watch } from 'vue'
const props = defineProps(['count'])
const emit = defineEmits(['update:count'])

// local copy that syncs with prop
const local = ref(props.count)
watch(() => props.count, v => local.value = v)

function inc() {
  local.value++
  emit('update:count', local.value)
}
</script>

Prop-Validierung & Defaults

Vue validiert Props im Dev-Modus und warnt bei Fehlschlag (nicht in Produktion). type akzeptiert einen Konstruktor (String, Number, Boolean, Array, Object, Function, Symbol) oder ein Array davon. Objekt- und Array-Defaults MÜSSEN Funktionen sein, die eine neue Instanz liefern — sonst würden sich alle Komponenten dieselbe Default-Referenz teilen (Mutations-Bugs). Validatoren laufen nach den Typchecks.

vue3
<script setup>
const props = defineProps({
  // type can be an array of allowed types
  value: { type: [String, Number], required: true },

  // object/array default MUST be a factory function
  list: {
    type: Array,
    default: () => []
  },

  // custom validator
  age: {
    type: Number,
    validator: (v) => v >= 0 && v <= 150
  },

  // multiple checks combined
  email: {
    type: String,
    required: true,
    validator: (v) => v.includes('@')
  }
})
</script>

Boolean-Casting & Attribut-Durchfall

Boolesche Props haben besonderes Casting: Vorhandensein ohne Wert heißt true. Der Attribut-Durchfall reicht Nicht-Prop-Attribute (class, style, id, data-*) automatisch an das Root-Element weiter. Mehrere Roots verlangen explizites v-bind='$attrs' auf dem gewünschten Element. Den Durchfall mit defineOptions({ inheritAttrs: false }) deaktivieren für volle Kontrolle.

vue3
<!-- prop declared as Boolean -->
<script setup>
defineProps({
  disabled: Boolean,
  active: Boolean
})
</script>

<!-- Parent -->
<template>
  <MyButton disabled />       <!-- disabled = true -->
  <MyButton :disabled="false" /> <!-- disabled = false -->
  <MyButton />                <!-- disabled = undefined -->
</template>

<!-- Attribute fallthrough: non-prop attributes
     land on the root element automatically -->
<template>
  <!-- <MyButton data-id="5" class="large" /> -->
  <!-- the data-id and class merge onto the <button> root -->
  <button>...</button>
</template>
12

Emits

Deklarieren & Emittieren

defineEmits deklariert Events, die eine Komponente emittieren kann. Die Objektform erlaubt Validatoren, die die Payload empfangen und false zurückgeben, um zu warnen (Dev-Modus). Emits gehen den Baum hinauf — Parents lauschen mit @event-name. Emits immer explizit deklarieren: Er dokumentiert die API, ermöglicht Ausschluss vom Attribut-Durchfall und unterstützt Validierung. emit() nimmt den Eventnamen plus optionale Payload-Argumente.

vue3
<script setup>
// declare emits (with optional validation)
const emit = defineEmits({
  // null-ish = no validation
  click: null,

  // function = validate payload
  submit: (payload) => {
    if (!payload.email) {
      console.warn('submit needs email')
      return false
    }
    return true
  }
})

function handleSubmit() {
  emit('submit', { email: '[email protected]', name: 'Alice' })
}
</script>

Emits empfangen

Parents lauschen mit @event-name (oder v-on:event-name). Der Handler erhält jede emittierte Payload. Inline-Arrow-Funktionen sind praktisch für einfache Transformationen (@increment='n => count += n'). Methodenhandler erhalten die Payload automatisch als erstes Argument. Native DOM-Events auf dem Root-Element einer Komponente fallen durch, außer sie sind in emits deklariert — 'click' zu deklarieren macht es stattdessen zum eigenen Event.

vue3
<!-- Child.vue -->
<script setup>
const emit = defineEmits(['increment', 'delete'])

function click() {
  emit('increment', 5)
}
</script>

<template>
  <button @click="click">+5</button>
</template>

<!-- Parent.vue -->
<template>
  <!-- inline handler -->
  <Child @increment="n => count += n" />

  <!-- method handler -->
  <Child @increment="onIncrement" @delete="onDelete" />
</template>

<script setup>
function onIncrement(amount) {
  console.log('incremented by', amount)
}
</script>

v-model-Implementierung

v-model auf einer Komponente ist Zucker für :modelValue + @update:modelValue. Das Kind erhält den Wert über einen modelValue-Prop und emittiert update:modelValue zum Synchronisieren. Das ist das manuelle Muster; defineModel() (Vue 3.4+) umhüllt es. Für benanntes v-model (v-model:foo) den Prop-Namen foo und das Event update:foo nutzen. So lassen sich Formularkomponenten bauen, die wie native Eingaben funktionieren.

vue3
<!-- CustomInput.vue (manual implementation) -->
<script setup>
const props = defineProps(['modelValue'])
const emit = defineEmits(['update:modelValue'])

function onInput(e) {
  emit('update:modelValue', e.target.value)
}
</script>

<template>
  <input
    :value="modelValue"
    @input="onInput"
  />
</template>

<!-- Parent -->
<template>
  <CustomInput v-model="text" />
</template>

Emit-Validierung

Emit-Validatoren empfangen die Payload-Argumente und geben false zurück, um eine Dev-Modus-Warnung auszulösen. Sie verhindern das Emit nicht — sie warnen nur. Das fängt Vertragsverletzungen früh in der Entwicklung. Nutzen, um erwartete Payload-Formen zu dokumentieren. In Produktion werden Validatoren entfernt, sich also nicht auf sie für Sicherheit oder Kontrollfluss verlassen.

vue3
<script setup>
const emit = defineEmits({
  // no validation
  click: null,

  // validate payload; return false to warn
  change: (value) => {
    if (typeof value !== 'string') {
      console.warn('change payload must be string')
      return false
    }
    return true
  },

  // validate multiple args
  update: (id, value) => {
    if (!id || value === undefined) return false
    return true
  }
})

// validation runs on emit
emit('change', 123)  // warns: must be string
</script>

Events vs. Props: Wann was

Dem Einweg-Datenfluss folgen: Props hinunter, Events hinauf. Für Zweiweg-Binding v-model nutzen (Props + Emit-Zucker). Bei tief verschachtelter Kommunikation wird Props-Drilling schmerzhaft — provide/inject für Dependency Injection oder einen Store (Pinia) für geteilten State nutzen. Events sind für 'etwas ist passiert'-Benachrichtigungen; Props für 'hier sind deine Daten'.

vue3
<!-- Parent-to-child: props (down) -->
<template>
  <Child :data="parentData" :config="config" />
</template>

<!-- Child-to-parent: emits (up) -->
<template>
  <Child @change="onChange" @submit="onSubmit" />
</template>

<!-- Two-way: v-model (combines both) -->
<template>
  <Child v-model="value" />
</template>

<!-- For complex state, prefer provide/inject or a store -->
13

Slots

Standard-Slot

Slots erlauben einem Parent, Inhalte in das Template einer Kindkomponente zu injizieren. Das <slot>-Element ist der Platzhalter. Der Kinderinhalt des Parents füllt den Standard-Slot. Slots ermöglichen Komposition: Card kümmert sich um das Wrapper-Styling, der Parent steuert den inneren Inhalt. Ohne Slots bräuchtest du einen Prop für jedes mögliche innere Element — Slots sind weit flexibler.

vue3
<!-- Card.vue -->
<template>
  <div class="card">
    <slot />
  </div>
</template>

<!-- Usage -->
<template>
  <Card>
    <p>This goes into the default slot</p>
    <button>Action</button>
  </Card>
</template>

Benannte Slots

Benannte Slots lassen eine Komponente mehrere Inhaltsplatzhalter haben. Mit <slot name='foo' /> deklarieren, mit <template #foo> füllen. Das # ist die Kurzform von v-slot:. Der unbenannte Slot ist der 'default'-Slot — Inhalt ohne Template-Wrapper landet dort. Benannte Slots sind perfekt für Layouts (header, sidebar, main, footer), wo der Parent jede Region füllt.

vue3
<!-- Layout.vue -->
<template>
  <header><slot name="header" /></header>
  <main><slot /></main>
  <footer><slot name="footer" /></footer>
</template>

<!-- Usage with # shorthand -->
<template>
  <Layout>
    <template #header>
      <h1>My Page Title</h1>
    </template>

    <!-- default slot (no #name) -->
    <p>Main content here</p>

    <template #footer>
      <p>© 2025</p>
    </template>
  </Layout>
</template>

Slot-Props (Scoped Slots)

Scoped Slots erlauben einem Kind, Daten an den Slotinhalt des Parents zurückzureichen. Das Kind bindet Daten an <slot :item='item'>; der Parent empfängt sie via v-slot='{ item }' (oder #default='{ item }'). Das ist das Fundament wiederverwendbarer Listenkomponenten (Datentabelle, virtuelle Liste): das Kind übernimmt die Iteration, der Parent steuert das Rendern jedes Items.

vue3
<!-- List.vue -->
<template>
  <ul>
    <li v-for="item in items" :key="item.id">
      <slot :item="item" :index="index" />
    </li>
  </ul>
</template>

<script setup>
defineProps(['items'])
</script>

<!-- Usage: receive slot props via v-slot -->
<template>
  <List :items="todos">
    <template #default="{ item, index }">
      <input type="checkbox" v-model="item.done" />
      <span :class="{ done: item.done }">{{ index }}: {{ item.text }}</span>
    </template>
  </List>
</template>

Slot-Fallback-Inhalt

Slot-Fallback-Inhalt steht zwischen <slot> und </slot>. Er rendert nur, wenn der Parent keinen Slot-Inhalt liefert. Super für sinnvolle Defaults — ein Button-Label, eine Leerzustand-Meldung, ein Platzhalter. Übergibt der Parent auch nur einen leeren String, wird der Fallback überschrieben.

vue3
<!-- Button.vue -->
<template>
  <button>
    <slot>Click here</slot>  <!-- fallback content -->
  </button>
</template>

<!-- Usage -->
<template>
  <Button />             <!-- renders "Click here" -->
  <Button>Save</Button>  <!-- renders "Save" -->
</template>

Render-Scope & Slot-Nutzung

Slot-Inhalt wird im Scope des PARENTS gerendert — er kann auf den Parent-Zustand zugreifen, aber nicht direkt auf den des Kindes (außer via Slot-Props). Diese Trennung lässt ein Kind die Mechanik übernehmen (Paginierung, Virtualisierung, Fetchen), während der Parent die Präsentation steuert. Das Scoped-Slot-Muster (FancyList + UserCard) ist eine mächtige Kompositionstechnik — das Kind besitzt den Datenfluss, der Parent das Rendering.

vue3
<!-- FancyList.vue (scoped slot pattern) -->
<script setup>
const props = defineProps(['items', 'pageSize'])
import { ref, computed } from 'vue'

const page = ref(1)
const paged = computed(() =>
  props.items.slice((page.value - 1) * props.pageSize, page.value * props.pageSize)
)
</script>

<template>
  <div v-for="item in paged" :key="item.id">
    <slot :item="item" :page="page" />
  </div>
</template>

<!-- Usage: parent fully controls rendering -->
<FancyList :items="users" :pageSize="10">
  <template #default="{ item, page }">
    <UserCard :user="item" />
    <small>Page {{ page }}</small>
  </template>
</FancyList>
14

Lifecycle-Hooks

Composition-API-Hooks

Lifecycle-Hooks laufen in bestimmten Stadien. onMounted feuert, nachdem das DOM gerendert ist (sicher, um auf Elemente zuzugreifen, Canvas-Bibliotheken zu starten, Daten zu holen). onUpdated feuert nach jedem reaktiven Update — hier State zu mutieren vermeiden (Endlosschleife). onUnmounted ist zum Aufräumen (Timer, Listener, Subscriptions). Hooks müssen synchron im Setup aufgerufen werden, dürfen aber mehrfach aufgerufen werden.

vue3
<script setup>
import {
  onBeforeMount, onMounted,
  onBeforeUpdate, onUpdated,
  onBeforeUnmount, onUnmounted,
  onActivated, onDeactivated,
  onErrorCaptured
} from 'vue'

onBeforeMount(() => console.log('before mount'))
onMounted(() => console.log('mounted — DOM ready'))
onBeforeUpdate(() => console.log('before re-render'))
onUpdated(() => console.log('after re-render'))
onBeforeUnmount(() => console.log('before unmount'))
onUnmounted(() => console.log('unmounted — cleanup'))
</script>

Setup vs. Created

In <script setup> läuft der gesamte Skriptkörper während der Komponenteninitialisierung — äquivalent zu beforeCreate + created in der Options-API. Es gibt keinen separaten created()-Hook. Top-Level-Code (Deklarationen, Funktionsaufrufe, sogar async-Arbeit) läuft einmal pro Instanz. Fürs Datenholen ein üblicher Startpunkt (onMounted ist aber auch fein — der Fetch startet so oder so gleich).

vue3
<script setup>
// <script setup> runs BEFORE the component is mounted
// (equivalent to beforeCreate + created in Options API)

import { ref } from 'vue'

// this code runs once per component instance,
// before reactive state is exposed to the template
const count = ref(0)
console.log('component created, count =', count.value)

// no need for created() hook — just run code here
fetch('/api/data')
  .then(r => r.json())
  .then(data => { /* ... */ })
</script>

Mounted & Cleanup

Setup/Cleanup-Paare sind essenziell: Jeden Listener, Timer, jede Subscription oder jeden Observer, der in onMounted ergänzt wird, MUSS in onUnmounted entfernt werden. Nicht aufzuräumen verursacht Speicherlecks und Zombie-Handler auf zerstörten Komponenten. Das Muster: addEventListener in onMounted, removeEventListener in onUnmounted. Bei Watchern die zurückgegebene stop-Funktion nutzen, oder sie räumen beim Unmount automatisch auf.

vue3
<script setup>
import { ref, onMounted, onUnmounted } from 'vue'

const windowWidth = ref(window.innerWidth)

function onResize() {
  windowWidth.value = window.innerWidth
}

onMounted(() => {
  // setup side effects after DOM is ready
  window.addEventListener('resize', onResize)
  console.log('mounted')
})

onUnmounted(() => {
  // ALWAYS clean up to avoid memory leaks
  window.removeEventListener('resize', onResize)
})
</script>

KeepAlive-Hooks

Ist eine Komponente in <KeepAlive> gewickelt, wird sie beim Wegwechseln nicht unmountet — sie wird deaktiviert (gecacht). onActivated und onDeactivated feuern beim Zeigen/Verbergen. Nutzen, um Arbeit anzuhalten/fortzusetzen (Polling, Videowiedergabe), ohne volles Setup/Tear-down. onMounted feuert weiterhin einmal (erste Aktivierung); onUnmounted feuert nie, solange gecacht. Diese Hooks erlauben es, Ressourcennutzung für gecachte Tabs zu optimieren.

vue3
<script setup>
import { onActivated, onDeactivated } from 'vue'

// these fire when the component is wrapped in <KeepAlive>
// and is being shown (activated) or hidden (deactivated)
onActivated(() => {
  console.log('component shown again — resume polling')
  startPolling()
})

onDeactivated(() => {
  console.log('component hidden but not unmounted — pause')
  stopPolling()
})

// onMounted fires only once (first show)
// onActivated fires every time it's re-shown
</script>

Error Captured

onErrorCaptured fängt Fehler von Nachkommenkomponenten (in Templates, Render, Lifecycle, Watchern). Er erhält (error, instance, info). false zurückgeben, um zu verhindern, dass der Fehler zu übergeordneten errorCaptured-Handlern und dem globalen errorHandler propagiert. Für Grenzkomponenten nutzen, die Kinderfehler sanft behandeln (wie React Error Boundaries). Mit Suspense für async-Fehlerzustände kombinieren.

vue3
<script setup>
import { onErrorCaptured, ref } from 'vue'

const error = ref(null)

onErrorCaptured((err, instance, info) => {
  // err: the error thrown
  // instance: component that threw
  // info: lifecycle hook or event name where it occurred
  error.value = err.message
  console.error('Captured:', err, info)

  // return false to stop propagation to parent
  return false
})
</script>

<template>
  <div v-if="error" class="error">{{ error }}</div>
  <slot v-else />
</template>
15

Composition API

ref vs. reactive

ref() funktioniert mit jedem Wert (Primitive, Objekte). Reaktiver Zugriff braucht .value in JS, unwrapt aber automatisch in Templates. reactive() funktioniert nur auf Objekten/Arrays — kein .value nötig. ref für Primitive und ersetzbare Werte; reactive für gruppierten State. Faustregel: ref() für Einzelwerte, reactive() für State-Objekte. Mischen ist fein — refs unwrap-en innerhalb reaktiver Objekte automatisch.

vue3
<script setup>
import { ref, reactive } from 'vue'

// ref: works with any value, access via .value
const count = ref(0)
count.value++
console.log(count.value)  // 1

// reactive: only for objects/arrays, no .value needed
const state = reactive({ count: 0, user: { name: 'A' } })
state.count++
console.log(state.count)  // 1

// refs auto-unwrap in templates and reactive objects
const wrapper = reactive({ count })  // wrapper.count === count.value
</script>

reactive-Fallstricke

Reaktive Objekte haben zwei Fallstricke: Die Variable lässt sich nicht neu zuweisen (state = newObj) — stattdessen Eigenschaften mutieren (state.list = []). Destructuring verliert die Reaktivität, weil die destrukturierte Variable ein Snapshot ist. toRefs() nutzen, um reaktive Eigenschaften in verknüpfte refs zu konvertieren. Diese Fallstricke sind, warum viele Entwickler ref() bevorzugen — ersetzbar (einfach .value setzen) und destructuring-freundlich.

vue3
<script setup>
import { reactive, ref } from 'vue'

const state = reactive({ list: [1, 2, 3] })

// PITFALL 1: replacing the whole object loses reactivity
// state = reactive({ list: [4, 5] })  // ERROR: reassign

// GOOD: mutate properties
state.list = [4, 5]

// PITFALL 2: destructuring loses reactivity
let { list } = state  // 'list' is now plain
// list.push(4) won't trigger updates

// FIX: use toRefs to keep reactivity
import { toRefs } from 'vue'
const { list } = toRefs(state)  // now list is a ref
</script>

toRef & toRefs

toRef() konvertiert eine einzelne reaktive Eigenschaft in eine verknüpfte ref (eine zu mutieren wirkt auf die andere). toRefs() konvertiert ALLE Eigenschaften — nützlich, um reaktiven State aus Composables zurückzugeben und Destructuring zu erhalten. Ohne toRefs verlieren destrukturierte Werte ihre Reaktivität. Muster: Das Composable liefert toRefs(state), sodass Konsumenten destrukturieren können, ohne die Reaktivität zu brechen.

vue3
<script setup>
import { reactive, toRef, toRefs } from 'vue'

const state = reactive({
  count: 0,
  name: 'Alice'
})

// toRef: single property -> ref (stays linked to state)
const countRef = toRef(state, 'count')

// toRefs: all properties -> object of refs
const { count, name } = toRefs(state)

countRef.value++      // updates state.count
count.value++         // also updates state.count
console.log(state.count)  // 2
</script>

computed & watch im Setup

In <script setup> werden computed() und watch() importiert und direkt aufgerufen. computed erzeugt eine abgeleitete ref; watch führt einen Callback bei Quellenänderung aus. watch kann eine einzelne ref, einen Getter, ein Array von Quellen oder ein reaktives Objekt nehmen. Das sind die Kernprimitiven der Composition API — kombinieren, um Logik in Composables zu kapseln.

vue3
<script setup>
import { ref, computed, watch } from 'vue'

const a = ref(1)
const b = ref(2)

// computed: derived value, cached
const sum = computed(() => a.value + b.value)

// watch: side effect on change
watch(sum, (newSum) => {
  console.log('sum changed to', newSum)
})

// watch multiple sources
watch([a, b], ([newA, newB]) => {
  console.log('a or b changed:', newA, newB)
})
</script>

shallowRef & shallowReactive

shallowRef und shallowReactive verzichten auf tiefe Reaktivität — nur die Referenz/Eigenschaften der obersten Ebene werden getrackt. Das verbessert die Performance bei großen Datenstrukturen dramatisch (z. B. das Datenarray eines Charts, ein 3D-Szenengraph), wo tiefes Tracking Verschwendung wäre. triggerRef() nutzen, um Vue nach einer tiefen Mutation manuell zu benachrichtigen. Nur greifen, wenn du ein Performanceproblem gemessen hast.

vue3
<script setup>
import { shallowRef, shallowReactive, triggerRef } from 'vue'

// shallowRef: only .value changes trigger updates
// (deep changes to .value properties do NOT)
const big = shallowRef({ items: [1, 2, 3] })
big.value.items.push(4)       // NO update triggered
big.value = { items: [1,2,3,4] }  // update triggered

// force update after deep mutation
big.value.items.push(5)
triggerRef(big)  // tells Vue to re-render

// shallowReactive: only root-level props are reactive
const state = shallowReactive({ user: { name: 'A' } })
state.count = 1            // reactive
state.user.name = 'B'      // NOT reactive
</script>
16

Composables

Ein Composable schreiben

Ein Composable ist eine Funktion, die wiederverwendbare reaktive Logik kapselt. Konvention: useSomething benennen. Sie nutzt Composition-API-Hooks (onMounted usw.), die an den Lifecycle der konsumierenden Komponente binden. Refs und Methoden zurückgeben. Die Komponente destrukturiert sie. Composables sind das Vue-Äquivalent zu React-Hooks — sie erlauben es, zustandsbehaftete Logik zu teilen ohne Render-Props oder HOCs.

vue3
<!-- useMousePosition.js -->
import { ref, onMounted, onUnmounted } from 'vue'

export function useMousePosition() {
  const x = ref(0)
  const y = ref(0)

  function update(e) {
    x.value = e.pageX
    y.value = e.pageY
  }

  onMounted(() => window.addEventListener('mousemove', update))
  onUnmounted(() => window.removeEventListener('mousemove', update))

  return { x, y }
}

<!-- In component -->
<script setup>
import { useMousePosition } from './useMousePosition'
const { x, y } = useMousePosition()
</script>

Zustandsbehaftetes Composable (geteilter State)

Wird State auf Modulebene deklariert (außerhalb der Funktion), ist er ein Singleton — alle Komponenten, die das Composable nutzen, teilen denselben State. Eine leichtgewichtige Alternative zu Pinia für einfachen globalen State. readonly() nutzen, um State ohne direkte Mutation zu exponieren — Komponenten müssen login/logout aufrufen, um ihn zu ändern. Bei komplexen Apps Pinia bevorzugen (besseres devtools, Persistenz, SSR-Unterstützung).

vue3
<!-- useUser.js -->
import { reactive, readonly } from 'vue'

// module-scoped state — shared across all consumers
const state = reactive({
  user: null,
  loading: false
})

export function useUser() {
  async function login(credentials) {
    state.loading = true
    state.user = await fetch('/api/login', {
      method: 'POST',
      body: JSON.stringify(credentials)
    }).then(r => r.json())
    state.loading = false
  }

  function logout() {
    state.user = null
  }

  return {
    user: readonly(state.user),  // expose read-only
    loading: readonly(state.loading),
    login,
    logout
  }
}

useFetch-Composable

Dieses Composable umhüllt fetch mit Lade-/Fehlerzustand und holt erneut, wenn sich eine reaktive url ändert. isRef() prüft, ob die Eingabe eine ref ist; unref() unwrapt sie (liefert den Wert für refs, sonst Identität). refresh zurückzugeben erlaubt dem Konsumenten, manuell neu zu holen. Dieses Muster (reaktive Eingabe + automatischer Neulauf + Zustand exponieren) ist Brot und Butter der Composables fürs Datenholen.

vue3
<!-- useFetch.js -->
import { ref, watchEffect, isRef, unref } from 'vue'

export function useFetch(url) {
  const data = ref(null)
  const error = ref(null)
  const loading = ref(true)

  async function doFetch() {
    loading.value = true
    error.value = null
    try {
      const res = await fetch(unref(url))
      if (!res.ok) throw new Error('HTTP ' + res.status)
      data.value = await res.json()
    } catch (e) {
      error.value = e.message
    } finally {
      loading.value = false
    }
  }

  // re-fetch when url ref changes
  if (isRef(url)) {
    watchEffect(doFetch)
  } else {
    doFetch()
  }

  return { data, error, loading, refresh: doFetch }
}

Composable mit Cleanup

Composables, die Nebenwirkungen registrieren (Listener, Timer, Subscriptions), MÜSSEN aufräumen — typisch via onUnmounted innerhalb des Composables. Das bindet das Aufräumen an die Komponente, die das Composable konsumiert, sodass der Konsument sich nicht erinnern muss. Ein großer Vorteil von Composables gegenüber Utility-Funktionen: Sie nehmen am Komponentenlebenszyklus teil.

vue3
<!-- useEventListener.js -->
import { onUnmounted } from 'vue'

export function useEventListener(target, event, callback) {
  target.addEventListener(event, callback)

  // auto-cleanup when the consuming component unmounts
  onUnmounted(() => {
    target.removeEventListener(event, callback)
  })
}

<!-- Usage -->
<script setup>
import { useEventListener } from './useEventListener'
import { ref } from 'vue'

const key = ref('')
useEventListener(window, 'keydown', (e) => {
  key.value = e.key
})
// listener is removed automatically on unmount
</script>

Composable-Konventionen

Diese Konventionen folgen: (1) Composables mit use-Präfix benennen; (2) refs zurückgeben (nicht plain Werte — plain Werte verlieren die Reaktivität); (3) refs oder Getter als Eingaben akzeptieren für Flexibilität; (4) onUnmounted fürs Aufräumen nutzen; (5) fokussiert halten (ein Anliegen pro Composable). Diese Konventionen machen Composables untereinander komponierbar und vorhersagbar nutzbar.

vue3
<!-- DO: name with 'use' prefix, return refs -->
export function useCounter(initial = 0) {
  const count = ref(initial)
  const inc = () => count.value++
  const dec = () => count.value--
  return { count, inc, dec }
}

<!-- AVOID: returning plain values (loses reactivity) -->
export function badCounter() {
  let count = 0  // plain variable — NOT reactive!
  return { count, inc: () => count++ }
}

<!-- DO: accept refs/getters for flexible inputs -->
export function useSearch(query) {
  // query can be a ref, a getter, or a plain value
  return watchEffect(() => fetch('/api?q=' + unref(query)))
}
17

Reaktivität im Detail

Reaktive Proxy-Mechanik

Vue 3s Reaktivität nutzt Proxy (ES6). reactive() liefert einen Proxy, der get abfängt (um Dependencies zu tracken) und set (um Updates auszulösen). Das Originalobjekt wird nicht verändert — du bekommst eine umhüllte Version. isReactive() prüft, ob etwas ein reaktiver Proxy ist. Das ist mächtiger als Vue 2s Object.defineProperty-Ansatz, der neue Eigenschaftszugänge nicht erkennen konnte.

vue3
<script setup>
import { reactive, isReactive, isProxy } from 'vue'

const state = reactive({ count: 0 })

// reactive() wraps the object in a Proxy
// reads/writes are tracked and trigger updates
state.count++  // triggers re-render

// the original object is NOT reactive
const raw = { count: 0 }
const wrapped = reactive(raw)
console.log(raw === wrapped)         // false
console.log(isReactive(wrapped))     // true
console.log(isReactive(raw))         // false
console.log(isProxy(wrapped))        // true
</script>

ref-Unwrap-Regeln

ref-Unwrap-Regeln: In <script> über .value zugreifen; in Templates und innerhalb reaktiver Objekte unwrap-en refs automatisch zu ihrem .value. Deshalb funktioniert {{ count }} im Template ohne .value. Das Auto-Unwrap ist flach — verschachtelte refs in Arrays/Maps unwrap-en nicht. Reaktive Objekte, die refs enthalten, mutieren den ref-Wert bei Zuweisung: state.count = 5 setzt count.value = 5.

vue3
<script setup>
import { ref, reactive } from 'vue'

const count = ref(0)
const state = reactive({ count })

// in JS: ref needs .value
count.value = 1

// in reactive object: ref auto-unwraps
console.log(state.count)  // 1 (not count.value)
state.count = 5           // updates count.value

// in templates: ref auto-unwraps
// {{ count }} renders count.value
</script>

<template>
  <p>{{ count }}</p>  <!-- 5, not [object Object] -->
</template>

Effect & track/trigger (Internas)

effect() ist die niedrigstufige Primitive hinter der Reaktivität — er führt eine Funktion aus, track-t jeden reaktiven Lesevorgang darin und läuft erneut, wenn sich ein getrackter Wert ändert. computed, watch, watchEffect und Komponenten-Rendering bauen alle auf effect auf. effect() ruft man im App-Code selten direkt auf — computed/watch/watchEffect bevorzugen — aber es ist die Engine. Es zu verstehen hilft, Umordnung und Timing nachzuvollziehen.

vue3
<script setup>
import { ref, effect } from 'vue'

const count = ref(0)

// effect runs immediately, then re-runs on dep change
effect(() => {
  console.log('count is', count.value)
})
// logs: count is 0

count.value = 10
// logs: count is 10

// internally:
// - effect tracks dependencies accessed inside it
// - setting count.value triggers all tracked effects
</script>

markRaw & readonly

markRaw() schließt ein Objekt dauerhaft aus der Reaktivität aus — nützlich für Drittanbieter-Klasseninstanzen (Charts, Maps, Spielzustand), die eigene Updatemechanismen haben und nicht in einen Proxy gewickelt werden sollen. readonly() erzeugt eine nur-lesende Sicht auf ein reaktives Objekt — Mutationsversuche warnen im Dev-Modus. readonly nutzen, um State aus Composables/Stores zu exponieren und direkte Mutation zu verhindern.

vue3
<script setup>
import { reactive, markRaw, readonly, isReadonly } from 'vue'

// markRaw: opt a value OUT of reactivity forever
const bigChart = markRaw(new HeavyChartLib())
const state = reactive({ chart: bigChart })
// state.chart mutations won't trigger Vue updates
// (use chart's own API to update it)

// readonly: make a reactive object read-only
const original = reactive({ count: 0 })
const frozen = readonly(original)
frozen.count = 5
// warning: target is readonly (dev mode)

console.log(isReadonly(frozen))  // true
</script>

Eigene ref (Factory)

customRef() erlaubt es, Dependency-Tracking und Auslösung explizit zu steuern. Die Factory erhält track() und trigger() — track() in get() aufrufen, um die Dependency zu registrieren, trigger() in set(), um Updates zu melden. Das ermöglicht Muster wie debounce-te refs, lazy refs oder von Storage getragene refs. Mächtig, aber sparsam einsetzen — meist ist watchEffect + eine normale ref klarer.

vue3
<script setup>
import { customRef } from 'vue'

// debounce a ref's updates
function debouncedRef(value, delay = 200) {
  let timeout
  return customRef((track, trigger) => ({
    get() {
      track()  // tell Vue this value is a dependency
      return value
    },
    set(newValue) {
      clearTimeout(timeout)
      timeout = setTimeout(() => {
        value = newValue
        trigger()  // notify Vue of the change
      }, delay)
    }
  }))
}

const text = debouncedRef('', 300)
// input only triggers re-render 300ms after typing stops
</script>
18

Vue Router

Router-Setup

createRouter richtet das Routing ein. createWebHistory nutzt den HTML5-History-Modus (saubere URLs, verlangt einen Server-Fallback auf index.html). Routenkomponenten mit dynamischem import() lazy laden für Code-Splitting — jede Route wird ein eigenes Bündel. Dynamische Segmente (:id) über route.params zugreifen. Den Router als Plugin installieren mit app.use(router).

vue3
<!-- router/index.js -->
import { createRouter, createWebHistory } from 'vue-router'
import Home from '../views/Home.vue'

const routes = [
  { path: '/', name: 'home', component: Home },
  {
    path: '/about',
    name: 'about',
    // lazy-load for code-splitting
    component: () => import('../views/About.vue')
  },
  { path: '/user/:id', name: 'user', component: () => import('../views/User.vue') }
]

export const router = createRouter({
  history: createWebHistory(),
  routes
})

<!-- main.js -->
import { createApp } from 'vue'
import App from './App.vue'
import { router } from './router'

createApp(App).use(router).mount('#app')

RouterView & RouterLink

<RouterView> ist der Platzhalter, wo die Komponente der gematchten Route rendert. <RouterLink> rendert ein <a>-Tag, fängt aber Klicks für clientseitige Navigation ab (kein volles Seiten-Neuladen). Der to-Prop akzeptiert einen String-Pfad oder ein Objekt ({ name, params, query }). RouterLink ergänzt active/exact-active-Klassen, um den aktuellen Link zu stylen.

vue3
<!-- App.vue -->
<template>
  <nav>
    <!-- RouterLink renders <a>, handles navigation -->
    <RouterLink to="/">Home</RouterLink>
    <RouterLink to="/about">About</RouterLink>
    <RouterLink :to="{ name: 'user', params: { id: 42 } }">
      User 42
    </RouterLink>
  </nav>

  <!-- matched route's component renders here -->
  <RouterView />
</template>

Navigation & programmatisches Routing

useRouter() liefert die Router-Instanz für die Navigation; useRoute() die aktuelle Route (reaktiv). push ergänzt einen Historieneintrag (der Zurück-Button funktioniert); replace nicht. Routeneigenschaften (path, params, query, hash, name, matched) sind reaktiv — Watcher und computed laufen bei Navigation neu. Für In-App-Navigation immer router.push nutzen — nie window.location, um es SPA zu halten.

vue3
<script setup>
import { useRouter, useRoute } from 'vue-router'

const router = useRouter()
const route = useRoute()

// push to a new URL (adds to history)
function goHome() {
  router.push('/')
  router.push({ name: 'user', params: { id: 1 } })
  router.push({ path: '/search', query: { q: 'vue' } })
}

// replace current entry (no back button)
router.replace('/login')

// go back/forward
router.back()
router.forward()
router.go(-2)

// access current route info
console.log(route.path, route.params.id, route.query.q)
</script>

Routen-Guards

Guards steuern den Navigationsfluss. Globales beforeEach ist super für Auth-Checks. Per-Route beforeEnter bewacht bestimmte Routen. Komponenteninterne Guards (onBeforeRouteLeave, onBeforeRouteUpdate) sind nützlich für Warnungen bei ungespeicherten Änderungen. false oder eine Route zurückgeben, um abzubrechen/umzuleiten; true/undefined zum Bestätigen. Async-Guards können ein Promise zurückgeben. route.meta nutzen, um Flags wie requiresAuth anzuhängen.

vue3
<!-- router/index.js -->
const router = createRouter({ history, routes })

// global guard: runs on every navigation
router.beforeEach((to, from) => {
  if (to.meta.requiresAuth && !isAuthenticated()) {
    return '/login'  // redirect
  }
  // return true or undefined to confirm
})

// per-route guard
{ path: '/admin', component: Admin, beforeEnter: (to, from) => {
  if (!isAdmin()) return '/403'
}}

// in-component guard
<script setup>
import { onBeforeRouteLeave } from 'vue-router'
onBeforeRouteLeave((to, from) => {
  if (hasUnsavedChanges()) {
    return confirm('Discard changes?')
  }
})
</script>

Lazy Loading & verschachtelte Routen

Verschachtelte Routen rendern Kindkomponenten innerhalb des <RouterView> des Parents. Kinder mit Pfaden relativ zum Parent definieren. Leerer Pfad ('') matcht die Parent-URL exakt. Dynamisches import() splittet jede Route in ein eigenes Bündel. route.meta nutzen, um Daten anzuhängen (Auth-Anforderungen, Titel) — in Guards via to.meta zugänglich. Verwandte Routen mit einem Chunk-Namen-Kommentar bündeln.

vue3
const routes = [
  {
    path: '/dashboard',
    component: () => import('../views/Dashboard.vue'),
    children: [
      { path: '', component: () => import('../views/Overview.vue') },
      { path: 'stats', component: () => import('../views/Stats.vue') },
      { path: 'settings', component: () => import('../views/Settings.vue') }
    ]
  },
  // group routes into one chunk
  {
    path: '/admin',
    component: () => import(/* webpackChunkName: "admin" */ '../views/Admin.vue'),
    meta: { requiresAuth: true, role: 'admin' }
  }
]
19

State-Management (Pinia)

Einen Store definieren

Pinia ist Vues offizielles State-Management (Vuex-Nachfolger). defineStore mit einer Setup-Funktion gibt Composition-API-Syntax — ref/computed sind state/getters, zurückgegebene Funktionen sind actions. Das erste Argument ist eine eindeutige Store-ID. Setup-Stores sind flexibel (jedes Composable ist darin nutzbar). Alternativ die Options-Syntax nutzen (state/getters/actions-Objekt) für ein Vuex-artigeres Gefühl.

vue3
<!-- stores/counter.js -->
import { defineStore } from 'pinia'

// setup syntax (composition API style)
export const useCounterStore = defineStore('counter', () => {
  const count = ref(0)
  const double = computed(() => count.value * 2)

  function increment() {
    count.value++
  }

  function asyncIncrement() {
    setTimeout(() => count.value++, 1000)
  }

  return { count, double, increment, asyncIncrement }
})

Einen Store nutzen

useStore() innerhalb des Setups aufrufen, um auf einen Store zuzugreifen. Für reaktives Destructuring storeToRefs() nutzen (wie toRefs, überspringt aber actions). Actions lassen sich direkt destrukturieren — sie sind an den Store gebunden. Pinia erlaubt direkte Mutation (counter.count = 5) und $patch für Batch-Updates. Stores sind Singletons — dieselbe Instanz über alle Komponenten. Pinia installieren mit app.use(createPinia()).

vue3
<script setup>
import { useCounterStore } from '../stores/counter'
import { storeToRefs } from 'pinia'

const counter = useCounterStore()

// state and getters lose reactivity if destructured directly
// use storeToRefs to preserve it
const { count, double } = storeToRefs(counter)

// actions can be destructured directly (they're functions)
const { increment } = counter

// mutate state directly (Pinia allows it, unlike Vuex)
counter.count = 5
counter.$patch({ count: 10 })
counter.$patch(state => { state.count++ })
</script>

<template>
  <p>{{ count }} x 2 = {{ double }}</p>
  <button @click="increment">+</button>
</template>

Getters & Stores komponieren

Getters sind aus State abgeleitete computed-Werte. Um einen anderen Store darin zu nutzen, einfach dessen useStore() aufrufen — Pinia übernimmt die Dependency. Das macht das Komponieren von Stores trivial (anders als Vuex-Module). Getters können auch auf andere Getters referenzieren. Für async-Operationen einfach async-Funktionen im Store schreiben — kein besonderer 'actions'-Kontext wie bei Vuex.

vue3
<!-- stores/cart.js -->
import { defineStore } from 'pinia'
import { useUserStore } from './user'

export const useCartStore = defineStore('cart', () => {
  const items = ref([])

  // getter (computed)
  const total = computed(() =>
    items.value.reduce((sum, i) => sum + i.price * i.qty, 0)
  )

  const itemCount = computed(() =>
    items.value.reduce((n, i) => n + i.qty, 0)
  )

  // compose other stores
  const userStore = useUserStore()
  const canCheckout = computed(() =>
    userStore.isLoggedIn && items.value.length > 0
  )

  function addItem(item) {
    items.value.push(item)
  }

  return { items, total, itemCount, canCheckout, addItem }
})

Subscriptions & Persistenz

$subscribe feuert bei jeder State-Änderung (mit Mutations-Info und dem neuen State). Für Persistenz (localStorage, sessionStorage) oder Synchronisation mit externen Systemen nutzen. $onAction hakt in Aktionsaufrufe ein — nützlich für Logging, Analytics oder das Messen der Aktionsdauer. Die after/onError-Callbacks erlauben Reaktionen auf Aktionsabschluss oder -fehl. Aufräumen passiert automatisch beim Komponenten-Unmount.

vue3
<script setup>
import { useCartStore } from '../stores/cart'

const cart = useCartStore()

// subscribe to any state change
cart.$subscribe((mutation, state) => {
  console.log('cart changed', mutation.type, state)
  // persist to localStorage
  localStorage.setItem('cart', JSON.stringify(state.items))
})

// subscribe to actions
cart.$onAction(({ name, after, onError }) => {
  console.log('action started:', name)
  after(result => console.log('action done:', name, result))
  onError(err => console.error('action failed:', name, err))
})
</script>

Reset & Store-Module

Stores der Options-Syntax haben ein eingebautes $reset(); Setup-Stores nicht — reset() manuell implementieren, indem jede ref neu zugewiesen wird. Pinia ist modular by design — jeder Store ist unabhängig, keine verschachtelten Module wie bei Vuex. Stores komponieren, indem useOtherStore() innerhalb eines aufgerufen wird. Pinia global installieren mit createPinia(). Stores sind tree-shakable und haben exzellente TypeScript-Unterstützung und devtools-Integration.

vue3
<!-- stores/user.js -->
import { defineStore } from 'pinia'

export const useUserStore = defineStore('user', () => {
  const name = ref('')
  const isLoggedIn = ref(false)

  function login(n) { name.value = n; isLoggedIn.value = true }
  function logout() { name.value = ''; isLoggedIn.value = false }

  // Pinia setup stores don't have a built-in $reset
  // implement it manually
  function reset() {
    name.value = ''
    isLoggedIn.value = false
  }

  return { name, isLoggedIn, login, logout, reset }
})

<!-- main.js -->
import { createPinia } from 'pinia'
const pinia = createPinia()
app.use(pinia)
20

Übergänge & Animation

Transition-Komponente

Ein v-if/v-show-Element in <Transition> wickeln, um Eintritt/Austritt zu animieren. Vue ergänzt 6 Klassen zu den richtigen Zeitpunkten: *-enter-from (Startzustand), *-enter-active (während des Übergangs), *-enter-to (Endzustand) und *-leave-*. CSS-Übergänge/-Animationen auf diesen Klassen definieren. Der name-Prop ersetzt das 'v-'-Präfix. Nur ein Kindelement erlaubt; für Listen TransitionGroup.

vue3
<template>
  <Transition name="fade">
    <p v-if="show">Hello</p>
  </Transition>
</template>

<style>
/* 6 classes: {name}-enter-{from,active,to}, {name}-leave-{...} */
.fade-enter-active, .fade-leave-active {
  transition: opacity 0.3s ease;
}
.fade-enter-from, .fade-leave-to {
  opacity: 0;
}
</style>

Transition-Modi & Hooks

mode='out-in' animiert das austretende Element vollständig heraus, bevor das eintretende beginnt — perfekt, um Komponenten (Tabs) ohne Überlappung zu tauschen. mode='in-out' wird selten genutzt. JavaScript-Hooks (@before-enter, @enter, @leave) erlauben es, Animationen mit Bibliotheken wie GSAP zu treiben. :css='false' setzen, um Vue zu sagen, dass es die CSS-Erkennung überspringen und sich allein auf deine JS-Hooks verlassen soll (kleiner Performance-Gewinn).

vue3
<template>
  <!-- 'out-in': current leaves, then new enters -->
  <Transition mode="out-in" name="fade">
    <component :is="currentTab" />
  </Transition>

  <!-- JavaScript hooks for GSAP/anime.js -->
  <Transition
    @before-enter="beforeEnter"
    @enter="enter"
    @leave="leave"
    :css="false"
  >
    <div v-if="show">Animated</div>
  </Transition>
</template>

TransitionGroup für Listen

TransitionGroup animiert v-for-Listen mit drei Verhaltensweisen: Eintritt (neues Item), Austritt (entferntes Item) und Bewegung (bestehendes Item ändert Position). Die *-move-Klasse animiert die FLIP-Technik — Vue berechnet Positions-Deltas und wendet einen Transform-Übergang an. position: absolute auf leave-active setzen, damit das austretende Item aus dem Fluss genommen wird und Geschwister weich an ihren Platz gleiten.

vue3
<template>
  <TransitionGroup name="list" tag="ul">
    <li v-for="item in items" :key="item.id">{{ item.text }}</li>
  </TransitionGroup>
</template>

<style>
.list-enter-active, .list-leave-active { transition: all 0.5s; }
.list-enter-from, .list-leave-to { opacity: 0; transform: translateX(30px); }
/* the magic class for reordering */
.list-leave-active { position: absolute; }
.list-move { transition: transform 0.5s ease; }
</style>

Animierter Zustand mit <Transition>-Wrapper

Vues Standard-Klassennamen lassen sich mit eigenen überschreiben — enter-active-class und leave-active-class. So plugt man in bestehende Animationssysteme ein (Animate.css, Tailwinds Animations-Utilities, eigene Keyframes). Das Muster: deine Animation auf einer Klasse definieren und Vues Transition darauf zeigen. Das brückt Vues Lifecycle mit jedem CSS-Animations-Framework.

vue3
<template>
  <button @click="show = !show">Toggle</button>
  <Transition
    enter-active-class="animate__animated animate__fadeIn"
    leave-active-class="animate__animated animate__fadeOut"
  >
    <div v-if="show" class="box">Content</div>
  </Transition>
</template>

<!-- combine with third-party animation libraries -->
<!-- Animate.css, Tailwind animations, custom keyframes -->

Suspense für async

Suspense koordiniert async-Setup — nutzt eine Kindkomponente top-level await, suspendiert sie, und Suspense zeigt #fallback stattdessen. Sobald alle async-Kinder sich erfüllen, rendert der Standard-Slot. Elegant für datenholende Komponenten. Beachte: Suspense ist in Vue 3 weiterhin experimentell — Fehlerbehandlung braucht onErrorCaptured. Für Produktion nutzen die meisten Teams weiterhin Composables + Ladezustand.

vue3
<template>
  <Suspense>
    <template #default>
      <AsyncComponent />
    </template>
    <template #fallback>
      <div>Loading...</div>
    </template>
  </Suspense>
</template>

<!-- AsyncComponent uses top-level await -->
<script setup>
import { ref } from 'vue'
const data = ref(null)
// top-level await suspends the component
const res = await fetch('/api/data').then(r => r.json())
data.value = res
</script>
21

Teleport & Suspense

Teleport-Grundlagen

Teleport rendert Inhalte in ein DOM-Element anderswo im Dokument (oft auf body-Ebene), aber die Komponente behält den reaktiven Kontext ihres Parents, Props, Emits usw. Das löst z-index-/overflow-Probleme bei Modals, Tooltips und Dropdowns, die von parent-overflow:hidden oder Stacking-Kontexten beschnitten würden. Der 'to'-Selector zielt auf das Zielelement.

vue3
<!-- Modal.vue -->
<template>
  <!-- the rendered content is moved to #modals in the DOM,
       but keeps the component's reactive context -->
  <Teleport to="#modals">
    <div class="modal">
      <h2>{{ title }}</h2>
      <slot />
      <button @click="$emit('close')">Close</button>
    </div>
  </Teleport>
</template>

<!-- index.html must have -->
<!-- <div id="app"></div> -->
<!-- <div id="modals"></div> -->

Bedingter Teleport

Der disabled-Prop erlaubt bedingtes Teleportieren — bei true rendert der Inhalt an Ort und Stelle (nicht teleportiert). Nützlich, wenn dieselbe Komponente in verschiedenen Kontexten genutzt wird (z. B. ein Tooltip, der in einem normalen Layout teleportiert werden soll, aber inline innerhalb eines anderen Modals). Mehrere Teleports aufs selbe Ziel ergänzen sich in Renderreihenfolge. Teleport funktioniert mit v-if innerhalb.

vue3
<template>
  <!-- disabled: render in place (not teleported) -->
  <Teleport :to="target" :disabled="inline">
    <div class="popup" v-if="show">...</div>
  </Teleport>
</template>

<script setup>
const props = defineProps({
  inline: Boolean  // if true, render inline instead of teleporting
})
const target = '#popups'
</script>

<!-- Multiple Teleports to same target: appended in order -->

Teleport für Modals & Benachrichtigungen

Teleport zu body ist das Standardmuster für Modals — das Modal entkommt allen parent-overflow/transform/z-index-Beschränkungen. Mit Transition für Eintritts-/Austrittsanimation kombinieren. @click.self auf dem Backdrop schließt beim Klick außerhalb (aber nicht auf dem Inhalt). Slots erlauben dem Parent, Header, Body und Footer des Modals vollständig anzupassen, während die Modalkomponente Positionierung und Animation übernimmt.

vue3
<!-- components/Modal.vue -->
<template>
  <Teleport to="body">
    <Transition name="modal">
      <div v-if="show" class="modal-backdrop" @click.self="$emit('close')">
        <div class="modal-content">
          <header><slot name="header" /></header>
          <slot />
          <footer><slot name="footer" /></footer>
        </div>
      </div>
    </Transition>
  </Teleport>
</template>

Suspense mit async-Setup

Nutzt das Setup einer Kindkomponente top-level await, liefert es ein Promise. Suspense fängt es auf und zeigt #fallback bis zur Auflösung. Das Setup-Ergebnis der suspendierten Komponente wird dann zum Rendern genutzt. Mehrere async-Kinder werden koordiniert — Suspense wartet auf alle. onErrorCaptured fängt Setup-Fehler. Suspense ist weiterhin experimentell — für Produktion lieber manuellen Ladezustand in Composables.

vue3
<!-- Parent.vue -->
<template>
  <Suspense>
    <AsyncProfile :id="userId" />
    <template #fallback>
      <Spinner />
    </template>
  </Suspense>
</template>

<!-- AsyncProfile.vue -->
<script setup>
const props = defineProps(['id'])
// top-level await suspends this component
const profile = await fetch(`/api/users/${props.id}`).then(r => r.json())
// component only renders after this resolves
</script>

Verschachteltes Suspense & async-Komponenten

Suspense darf verschachteln — jede Ebene behandelt ihre eigene async-Grenze. Das äußere Suspense zeigt PageSkeleton, während Dashboard (und alles, was es braucht) lädt; das innere zeigt ChartSkeleton speziell für das Chart. Dieses granulare Laden verbessert die UX: Die Seitenschale erscheint zuerst, dann füllen sich einzelne Sektionen. Denken: Suspense ist experimentell — gründlich testen und Fehler via onErrorCaptured behandeln.

vue3
<template>
  <Suspense>
    <template #default>
      <Dashboard>
        <Suspense>
          <template #default>
            <AsyncChart :data="data" />
          </template>
          <template #fallback>
            <ChartSkeleton />
          </template>
        </Suspense>
      </Dashboard>
    </template>
    <template #fallback>
      <PageSkeleton />
    </template>
  </Suspense>
</template>
22

Provide / Inject

Einfaches Provide & Inject

provide() macht einen Wert allen Nachkommenkomponenten verfügbar; inject() holt ihn überall im Baum ab. Das vermeidet Props-Drilling bei tief verschachtelten Komponenten. Das zweite Argument von inject ist ein Defaultwert (genutzt, wenn nichts bereitgestellt wurde). Bereitgestellte refs sind reaktiv — Nachkommen können sie mutieren und der Parent sieht Änderungen. Symbol-Schlüssel nutzen, um Kollisionen in großen Apps zu vermeiden.

vue3
<!-- Parent.vue -->
<script setup>
import { provide, ref } from 'vue'

const theme = ref('dark')
const user = ref({ name: 'Alice' })

// provide to all descendants
provide('theme', theme)
provide('user', user)
</script>

<!-- DeepChild.vue (any level of nesting) -->
<script setup>
import { inject } from 'vue'

const theme = inject('theme', 'light')  // default 'light'
const user = inject('user')

// these are reactive refs, just like in the parent
</script>

Nur-lesender bereitgestellter State

readonly() nutzen, um State ohne direkte Mutation zu exponieren — Nachkommen müssen bereitgestellte Aktionsmethoden aufrufen, um ihn zu ändern. Dieses Muster (private mutierbare ref + readonly öffentliche Sicht + Aktionsmethoden) ist eine leichtgewichtige Alternative zu Pinia für komponentenbaumbegrenzten State. Es erzwingt Einweg-Datenfluss und verhindert Bugs durch zufällige Mutationen tief im Baum.

vue3
<!-- store.js (shared composable) -->
import { ref, readonly } from 'vue'

const _count = ref(0)  // private mutable state

export function useCountStore() {
  return {
    count: readonly(_count),  // consumers can't mutate
    increment: () => _count.value++  // only via action
  }
}

<!-- Provider.vue -->
<script setup>
import { provide } from 'vue'
import { useCountStore } from './store'

const store = useCountStore()
provide('countStore', store)
</script>

Typisierte Injection-Schlüssel

InjectionKey<Ref<Type>> nutzen, um einen typisierten Symbol-Schlüssel zu erzeugen. Das gibt volle TypeScript-Inferenz — inject kennt den Rückgabetyp. Symbol-Schlüssel vermeiden String-Kollisionen, wenn mehrere Bibliotheken Werte bereitstellen. Für App-weite Singletons Pinia statt provide/inject bevorzugen — Pinia hat devtools, Persistenz und bessere Testbarkeit. provide/inject für komponentenbaumbegrenzten Kontext nutzen (theme, form, locale).

vue3
<!-- keys.ts -->
import type { InjectionKey, Ref } from 'vue'
import { inject, provide } from 'vue'

export const ThemeKey: InjectionKey<Ref<string>> = Symbol('theme')

<!-- Provider.vue -->
<script setup>
import { ref } from 'vue'
import { ThemeKey } from './keys'

const theme = ref('dark')
provide(ThemeKey, theme)
</script>

<!-- Consumer.vue -->
<script setup>
import { inject } from 'vue'
import { ThemeKey } from './keys'

// TS knows theme is Ref<string> | undefined
const theme = inject(ThemeKey)
// with default
const theme2 = inject(ThemeKey, ref('light'))
</script>

Bereitgestellte Werte aktualisieren

Das empfohlene Muster: ein Objekt bereitstellen, das den reaktiven State UND die Methoden zu seiner Mutation enthält. Das hält die API explizit und verhindert zufällige Mutationen. Kinder destrukturieren State und Actions. Das ist im Kern ein Mini-Store — für alles über ein paar Werte hinaus ein Composable erwägen, das dieselbe Form liefert, oder Pinia. Der bereitgestellte Wert ist reaktiv, weil er eine ref enthält.

vue3
<!-- Provider.vue -->
<script setup>
import { ref, provide } from 'vue'

const count = ref(0)

// expose value + mutator together
provide('counter', {
  count,                       // reactive ref
  increment: () => count.value++,
  reset: () => count.value = 0
})
</script>

<!-- DeepChild.vue -->
<script setup>
import { inject } from 'vue'

const { count, increment, reset } = inject('counter')
// count is reactive, increment/reset are actions
</script>

<template>
  <p>{{ count }}</p>
  <button @click="increment">+</button>
  <button @click="reset">Reset</button>
</template>

App-Ebene Provide

app.provide() macht einen Wert jeder Komponente in der App verfügbar — nützlich für App-weite Konstanten (API-URLs, Feature-Flags, Umgebungskonfiguration). Anders als provide auf Komponentenebene ist das standardmäßig nicht reaktiv (außer du lieferst eine ref). Ein guter Weg, umgebungsspezifische Konfiguration zu injizieren, ohne env-Dateien überall zu importieren. Mit inject() in jeder Komponente kombinieren, um auf diese Globals zuzugreifen.

vue3
<!-- main.js -->
import { createApp } from 'vue'
import App from './App.vue'

const app = createApp(App)

// app-level provide — available to ALL components
app.provide('apiUrl', 'https://api.example.com')
app.provide('apiKey', import.meta.env.VITE_API_KEY)

// useful for app-wide constants
app.provide('features', {
  darkMode: true,
  beta: false
})

app.mount('#app')

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.