Vue3 Composition API

Die Vue3 Composition API wird hauptsächlich verwendet, um die Wiederverwendbarkeit der Codelogik in großen Komponenten zu verbessern.

Mit steigender geschäftlicher Komplexität wachsen traditionelle Komponenten im Codeumfang weiter an, und die gesamte Codelogik wird schwer zu lesen und zu verstehen.

Der Ort, an dem Vue3 die Composition API verwendet, ist die setup()-Funktion.setup。

In setup können wir Teile des Codes nach logischen Gesichtspunkten gruppieren, dann Logikausschnitte extrahieren und sie mit anderen Komponenten teilen. Daher ermöglicht uns die Composition API, besser organisierten Code zu schreiben.

Vergleiche die folgenden beiden Codeausschnitte:

1. Traditionelle Komponenten

2. Composition API


setup-Komponente

Die setup()-Funktion wird ausgeführt, bevor die Komponente erstellt wird (created()).

Die setup()-Funktion akzeptiert zwei Parameter: props und context.

Der erste Parameter, props, ist reaktiv und wird aktualisiert, wenn neue props übergeben werden.

Der zweite Parameter, context, ist ein einfaches JavaScript-Objekt. Es ist ein Kontextobjekt, das andere Werte bereitstellt, die in setup nützlich sein können.

Hinweis:In setup solltest du die Verwendung von this vermeiden, da es die Komponenteninstanz nicht findet. Der setup-Aufruf erfolgt, bevor Daten-Eigenschaften, berechnete Eigenschaften oder Methoden aufgelöst werden, daher kann in setup nicht auf sie zugegriffen werden.

Das folgende Beispiel verwendet die Composition API, um einen Zähler zu definieren:

Beispiel (src/APP.vue)

<template>
    <div>
        <p>Zähler-Beispiel: {{ count }}</p>
        <input @click="myFn" type="button" value="Klicke mich, um 1 hinzuzufügen">
    </div>
</template>

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

export default {
    setup(){
// Definiere eine Variable mit einem Anfangswert von 0. Verwende die ref-Methode, um sie zuzuweisen; bei direkter Zuweisung werden Änderungen an der Variable die UI nicht aktualisieren.
        let count = ref(0);

// Definiere das Klickereignis myFn
        function myFn(){
            console.log(count);
            count.value += 1;
        }
       
// Wenn die Komponente gemountet wird, verwenden wir den onMounted-Hook, um einige Nachrichten aufzuzeichnen
        onMounted(() => console.log('component mounted!'));

// Variablen oder Methoden, die mit der Composition API definiert wurden, sind im Template verfügbar.
return {count, myFn} // Die zurückgegebenen Funktionen verhalten sich genauso wie Methoden
    }
}
</script>

In Vue 3.0 können wir eine neue ref-Funktion verwenden, damit jede reaktive Variable überall funktioniert, wie unten gezeigt:

import { ref } from 'vue'

let count = ref(0);

ref()Die Funktion erstellt ein reaktives Datenobjekt basierend auf dem angegebenen Wert. Der Rückgabewert ist ein Objekt mit nur einer.value.value-Eigenschaft.

In der setup()-Funktion geben die von ref() erzeugten reaktiven Daten ein Objekt zurück, daher müssen Sie.value.value verwenden, um darauf zuzugreifen.

Beispiel

import { ref } from 'vue'

const counter = ref(0)

console.log(counter) // { value: 0 }
console.log(counter.value) // 0

counter.value++
console.log(counter.value) // 1

Vue Composition API Lifecycle-Hooks

In Vue2 implementieren wir Lifecycle-Hook-Funktionen auf folgende Weise:

Beispiel

export default {
  beforeMount() {
    console.log('V2 beforeMount!')
  },
  mounted() {
    console.log('V2 mounted!')
  }
};

In der Vue3 Composition API können Lifecycle-Hook-Funktionen insetup()der setup()-Funktion mithilfe vononFunktionen mit on-Präfix implementiert werden:

Beispiel

import { onBeforeMount, onMounted } from 'vue';
export default {
  setup() {
    onBeforeMount(() => {
      console.log('V3 beforeMount!');
    })
    onMounted(() => {
      console.log('V3 mounted!');
    })
  }
};

Die folgende Tabelle zeigt die Zuordnung zwischen der Options API und der Composition API, einschließlich der Vorgehensweise zum Aufrufen von Lifecycle-Hooks innerhalb von setup():

Vue2 Options-basierte APIVue Composition API
beforeCreatesetup()
createdsetup()
beforeMountonBeforeMount
mountedonMounted
beforeUpdateonBeforeUpdate
updatedonUpdated
beforeDestroyonBeforeUnmount
destroyedonUnmounted
errorCapturedonErrorCaptured

Da setup um die Lifecycle-Hooks beforeCreate und created herum ausgeführt wird, ist es nicht nötig, sie explizit zu definieren. Mit anderen Worten: Jeglicher Code, der in diesen Hooks geschrieben wird, sollte direkt in der setup-Funktion geschrieben werden.

Diese Funktionen akzeptieren eine Callback-Funktion, die ausgeführt wird, wenn der Hook von der Komponente aufgerufen wird:

Beispiel

setup() {
...
    // Wenn die Komponente gemountet wird, verwenden wir den onMounted-Hook, um einige Nachrichten aufzuzeichnen
    onMounted(() => console.log('Komponente montiert!'));
...
}

Template-Refs

Bei der Verwendung der Composition API sind reaktive Refs und Template-Refs vereinheitlichte Konzepte.

Um eine Referenz auf ein Element oder eine Komponenteninstanz im Template zu erhalten, können wir wie gewohnt ein Ref deklarieren und es aus setup() zurückgeben:

Beispiel

<template>
  <div ref="root">Dies ist ein Root-Element</div>
</template>

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

  export default {
    setup() {
      const root = ref(null)

      onMounted(() => {
        // Das DOM-Element wird dem Ref nach dem ersten Rendern zugewiesen
        console.log(root.value) // <div>Dies ist ein Root-Element</div>
      })

      return {
        root
      }
    }
  }
</script>

Im obigen Beispiel legen wir root im Render-Kontext offen und binden es über ref="root" als ref an das div.

Als Templates verwendete Refs verhalten sich wie jede andere ref: Sie sind reaktiv und können an zusammengesetzte Funktionen übergeben (oder von ihnen zurückgegeben) werden.

Verwendung in v-for

Bei Verwendung innerhalb von v-for werden Template-Refs in der Composition API nicht speziell behandelt. Verwenden Sie stattdessen eine Funktions-ref für die benutzerdefinierte Handhabung:

Beispiel

<template>
  <div v-for="(item, i) in list" :ref="el => { if (el) divs[i] = el }">
    {{ item }}
  </div>
</template>

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

  export default {
    setup() {
      const list = reactive([1, 2, 3])
      const divs = ref([])

      // Stellen Sie sicher, dass die ref vor jeder Aktualisierung zurückgesetzt wird
      onBeforeUpdate(() => {
        divs.value = []
      })

      return {
        Liste,
        divs
      }
    }
  }
</script>

Überwachen von Template-Refs

Das Beobachten von Template-Refs auf Änderungen kann die in den vorherigen Beispielen gezeigten Lifecycle-Hooks ersetzen.

Ein wesentlicher Unterschied zu Lifecycle-Hooks ist jedoch, dass watch() und watchEffect() ausgeführt werden, bevor das DOM gemountet oder aktualisiert wird, was Nebenwirkungen hat: Wenn der Watcher ausgeführt wird, wurden Template-Refs noch nicht aktualisiert.

Beispiel

<template>
  <div ref="root">Dies ist ein Root-Element</div>
</template>

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

  export default {
    setup() {
      const root = ref(null)

      watchEffect(() => {
        // Dieser Nebeneffekt wird vor der DOM-Aktualisierung ausgeführt, daher hält die Template-Ref noch keine Referenz auf das Element.
        console.log(root.value) // => null
      })

      return {
        root
      }
    }
  }
</script>

Daher sollten Watcher, die Template-Refs verwenden, mit der Option flush: 'post' definiert werden, wodurch Nebeneffekte nach der DOM-Aktualisierung ausgeführt werden, sodass Template-Refs mit dem DOM synchron bleiben und auf das richtige Element verweisen.

Beispiel

<template>
  <div ref="root">Dies ist ein Root-Element</div>
</template>

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

  export default {
    setup() {
      const root = ref(null)

      watchEffect(() => {
        console.log(root.value) // => <div>Dies ist ein Root-Element</div>
      },
      {
        flush: 'post'
      })

      return {
        root
      }
    }
  }
</script>

API-Referenz

Laufende NummerAPI und BeschreibungBeispiel
1setup()
Die Einstiegsfunktion in der Composition API der Komponente, die beim Instanziieren der Komponente aufgerufen wird und zum Definieren reaktiver Daten und Methoden dient.
export default { setup() { const count = ref(0); return { count }; } }
2ref()
Erzeugt eine reaktive Referenz zum Umhüllen primitiver Typen oder Objekte.
const count = ref(0)
3computed()
Erzeugt einen berechneten Wert auf Basis anderer reaktiver Daten.
const doubledCount = computed(() => count.value * 2)
4reactive()
Erzeugt ein reaktives Objekt, geeignet für Objekte oder Arrays.
const state = reactive({ count: 0 })
5readonly()
Erzeugt schreibgeschützte reaktive Daten, die nicht geändert werden dürfen.
const state = readonly({ count: 0 })
6watchEffect()
Erzeugt einen reaktiven Seiteneffekt, der seine zugehörigen reaktiven Abhängigkeiten automatisch verfolgt.
watchEffect(() => { console.log(count.value) })
7watchPostEffect()
Ein Seiteneffekt, der ausgelöst wird, nachdem das DOM aktualisiert wurde.
watchPostEffect(() => { console.log('Post effect') })
8watchSyncEffect()
Führt Seiteneffekte synchron aus, wenn sich reaktive Abhängigkeiten ändern.
watchSyncEffect(() => { console.log('Synchronized effect') })
9watch()
Wird verwendet, um Änderungen an reaktiven Daten zu beobachten; Sie können bestimmte reaktive Daten oder berechnete Eigenschaften angeben.
watch(count, (newCount) => { console.log(newCount) })
10onWatcherCleanup()
Bereinigt den Watcher; wird aufgerufen, wenn die beobachteten Daten nicht mehr benötigt werden.
watch(count, () => {}, onWatcherCleanup(() => { console.log('cleaned up') }))
11isRef()
Prüft, ob ein Wert vomrefref-Typ ist.
isRef(count)
12unref()
Entpackt einenrefref-Wert.
unref(count)
13toRef()
Erzeugt eine reaktive ref, die aus einem Objekt extrahiert wurde.
const countRef = toRef(state, 'count')
14toValue()
Entpackenrefoderreactiveeinen Wert vom Typ ref.
toValue(count)
15toRefs()
Konvertiere jede Eigenschaft eines reaktiven Objekts in ein eigenständiges ref.ref。
const { count } = toRefs(state)
16isProxy()
Prüfe, ob ein Objekt ein Vue-Proxy-Objekt ist.
isProxy(state)
17isReactive()
Prüfe, ob ein Objekt ein reaktives Objekt ist.
isReactive(state)
18isReadonly()
Prüfe, ob ein Objekt ein schreibgeschütztes reaktives Objekt ist.
isReadonly(state)
19shallowRef()
Erstelle ein flaches reaktives Objekt,refwodurch nur die Eigenschaften der ersten Ebene des Objekts reaktiv gemacht werden.
const state = shallowRef({ count: 0 })
20triggerRef()
Auslösen erzwingenrefAktualisierung von ref.
triggerRef(count)
21customRef()
Erstelle ein benutzerdefiniertes reaktives ref, mit dem Entwickler Getter und Setter anpassen können.
const count = customRef((track, trigger) => { let value = 0; return { get: () => value, set: (val) => { value = val; trigger() } } })
22shallowReactive()
Erstelle ein flaches reaktives Objekt, bei dem nur die Eigenschaften der ersten Ebene reaktiv sind.
const state = shallowReactive({ count: 0 })
23shallowReadonly()
Erstelle ein flaches, schreibgeschütztes reaktives Objekt, bei dem nur die Eigenschaften der ersten Ebene des Objekts schreibgeschützt sind.
const state = shallowReadonly({ count: 0 })
24toRaw()
Rufe das Rohobjekt eines Proxy-Objekts ab.
const rawState = toRaw(state)
25markRaw()
Markiere ein Objekt als nicht proxyfähig, und Vue überspringt die reaktive Verarbeitung für dieses Objekt.
const obj = markRaw({ count: 0 })
26effectScope()
Erstelle einen neuen Effektbereich, um Nebeneffekte zu verwalten.
const scope = effectScope()
27getCurrentScope()
Rufe den aktuellen Effektbereich ab.
const scope = getCurrentScope()
28onScopeDispose()
Führe eine Aufräumfunktion aus, wenn der Effektbereich zerstört wird.
onScopeDispose(() => { console.log('Scope disposed') })
29onMounted()
Lebenszyklus-Hook, der aufgerufen wird, wenn die Komponente gemountet wird.
onMounted(() => { console.log('Component mounted') })
30onUpdated()
Lebenszyklus-Hook, der aufgerufen wird, wenn die Komponente aktualisiert wird.
onUpdated(() => { console.log('Component updated') })
31onUnmounted()
Lebenszyklus-Hook, der aufgerufen wird, wenn die Komponente entfernt wird.
onUnmounted(() => { console.log('Component unmounted') })
32onBeforeMount()
Lebenszyklus-Hook, der aufgerufen wird, bevor die Komponente gemountet wird.
onBeforeMount(() => { console.log('Before mount') })
33onBeforeUpdate()
Lebenszyklus-Hook, der aufgerufen wird, bevor die Komponente aktualisiert wird.
onBeforeUpdate(() => { console.log('Before update') })
34onBeforeUnmount()
Lebenszyklus-Hook, der aufgerufen wird, bevor die Komponente entfernt wird.
onBeforeUnmount(() => { console.log('Before unmount') })
35onErrorCaptured()
Unbehandelte Fehler im Komponentenbaum abfangen.
onErrorCaptured((err, instance, info) => { console.error(err) })
36onRenderTracked()
Hook, der ausgelöst wird, wenn reaktive Daten während des Komponenten-Renderings verfolgt werden.
onRenderTracked((event) => { console.log(event) })
37onRenderTriggered()
Hook, der ausgelöst wird, wenn sich reaktive Daten während des Komponenten-Renderings ändern.
onRenderTriggered((event) => { console.log(event) })
38onActivated()
Lifecycle-Hook, der aufgerufen wird, wenn die Komponente aktiviert wird (verwendet fürkeep-aliveKomponente).
onActivated(() => { console.log('Component activated') })
39onDeactivated()
Lifecycle-Hook, der aufgerufen wird, wenn die Komponente deaktiviert wird (verwendet fürkeep-aliveKomponente).
onDeactivated(() => { console.log('Component deactivated') })
40onServerPrefetch()
Hook zum Vorabrufen von Daten, wenn die Komponente serverseitig gerendert wird.
onServerPrefetch(async () => { await fetchData() })
41provide()
Abhängigkeiten für untergeordnete Komponenten bereitstellen.
provide('key', value)
42inject()
Abhängigkeiten von übergeordneten oder Vorfahren-Komponenten injizieren.
const value = inject('key')
43hasInjectionContext()
Prüfen, ob derzeit ein Injection-Kontext vorhanden ist.
hasInjectionContext()
44useAttrs()
Alle Attribute der Komponente abrufen, einschließlich HTML-Attribute, die an die Komponente übergeben werden
const attrs = useAttrs()
45useSlots()
Den Slot-Inhalt der Komponente abrufen
const slots = useSlots()
46useModel()
Ruft den aktuellen Komponenten-v-modelgebundenen Wert ab.
const modelValue = useModel()
47useTemplateRef()
Ruft eine Referenz auf das Element im Template ab.
const templateRef = useTemplateRef('elementId')
48useId()
Ruft eine eindeutige Kennung ab.
const uniqueId = useId()
Weitere Erweiterungen