Vue-Instanzoptionen

Optionen in Vue sind die verschiedenen Optionen, die auf einer Vue-Instanz bei Verwendung der Options-API verfügbar sind.

Einige gängige Optionen von Vue-Instanzen:

  • el- Gibt das DOM-Element an, an das die Vue-Instanz gemountet wird. Wenn nicht angegeben, wird die Vue-Instanz nicht automatisch gemountet.

  • data- Definiert das Datenobjekt der Vue-Instanz. Das Template, berechnete Eigenschaften, Methoden, Watcher usw. der Vue-Instanz können auf diese Daten zugreifen.

  • computed- Enthält berechnete Eigenschaften, deren Werte auf Grundlage ihrer Abhängigkeiten zwischengespeichert werden. Berechnete Eigenschaften werden nur dann neu ausgewertet, wenn sich ihre Abhängigkeiten ändern.

  • methods- Definiert Methoden der Vue-Instanz, die im Template über Event-Listener aufgerufen werden können.

  • watch- Enthält einen oder mehrere Watcher, um Datenänderungen in der Vue-Instanz zu beobachten und darauf zu reagieren.

  • props- Definiert externe Daten, die die Komponente empfangen kann.

  • components- Ermöglicht das Registrieren benutzerdefinierter Komponenten in der Vue-Instanz.

  • directives- Ermöglicht das Registrieren globaler benutzerdefinierter Direktiven.

  • filters- Definiert Filter, die im Template zur Textformatierung verwendet werden können.

  • model- Gibt benutzerdefinierte v-model-Eigenschaften und -Ereignisse an, die von der Komponente verwendet werden.

  • provide/inject- Bietet Dependency-Injection-Fähigkeit, sodass Daten über Komponenten hinweg übergeben werden können.

  • lifecycle hooks- UmfasstonMounted, onUpdated, onUnmountedlifecycle hooks usw., die verwendet werden, um Code in verschiedenen Phasen der Vue-Instanz auszuführen.

  • template- Definiert die HTML-Vorlage der Vue-Instanz.

  • Render-Funktion- Ermöglicht die Verwendung von JavaScript-Funktionen zum Rendern von Komponenten und bietet erweiterte Anpassungsmöglichkeiten.

  • errorCaptured- Wird verwendet, um Fehler in der Vue-Instanz global abzufangen.

  • emits- Definiert Ereignisse, die die Komponente emittieren kann.

  • setup- Die Einstiegsfunktion in der Composition API von Vue 3, die verwendet wird, um die Komponentenlogik zu organisieren.

el

Mount-Punkt, der verwendet wird, um das DOM-Element anzugeben, an das die Vue-Instanz gemountet wird:

Beispiel

const app = Vue.createApp({
  // options
});
app.mount('#app');

data

  • Typ: Function oder Object

  • Zweck: dataist der Ort in der Vue-Instanz, der zum Speichern von Komponentendaten verwendet wird. Du kannstdataverschiedene Dateneigenschaften darin definieren und sie auf der Seite über die Template-Syntax verwenden.dataDie Daten darin werden reaktiv aktualisiert, was bedeutet, dass sich der zugehörige Seiteninhalt automatisch aktualisiert, wenn sich die Daten ändern.

Beispiel

const app = Vue.createApp({
  data() {
    return {
      message: 'Hello Vue!'
    };
  }
});

computed

  • Typ: Object

  • Zweck: computedDie Eigenschaft ermöglicht es Ihnen, berechnete Eigenschaften basierend auf reaktiven Abhängigkeiten zu deklarieren. Berechnete Eigenschaften werden nur neu ausgewertet, wenn sich ihre zugehörigen Abhängigkeiten ändern, und sie cachen die berechneten Ergebnisse, um unnötige wiederholte Berechnungen zu vermeiden.

Beispiel

const app = Vue.createApp({
  data() {
    return {
      firstName: 'John',
      lastName: 'Doe'
    };
  },
  berechnet: {
    fullName() {
      return `${this.firstName} ${this.lastName}`;
    }
  }
});

methods

  • Typ: Object

  • Zweck: methodsDie Eigenschaft wird verwendet, um Methoden in der Vue-Instanz zu speichern. Diese Methoden können im Template aufgerufen und auch in anderen Methoden der Instanz verwendet werden. Im Gegensatz zu berechneten Eigenschaften werden Methoden bei jedem Aufruf erneut ausgeführt, was sie für die Reaktion auf Ereignisse oder die Ausführung asynchroner Operationen geeignet macht.

Beispiel

const app = Vue.createApp({
  data() {
    return {
      count: 0
    };
  },
  methods: {
    increment() {
      this.count++;
    }
  }
});

watch

  • Typ: Object oder Function

  • Zweck: watchDie Eigenschaft wird verwendet, um Datenänderungen in der Vue-Instanz zu beobachten und darauf zu reagieren. Wenn sich die beobachteten Daten ändern, wird die angegebene Callback-Funktion ausgeführt. Sie eignet sich für die Handhabung asynchroner oder komplexer Datenänderungslogik.

Beispiel

const app = Vue.createApp({
  data() {
    return {
      message: 'Hello Vue!'
    };
  },
  watch: {
    message(newValue, oldValue) {
      console.log(`Nachricht geändert von ${oldValue} zu ${newValue}`);
    }
  }
});

props

  • Typ: Array oder Object

  • Zweck: propsDie Eigenschaft wird verwendet, um Daten zu empfangen, die von der übergeordneten Komponente an die untergeordnete Komponente übergeben werden. In der untergeordneten Komponente,propswerden die von der übergeordneten Komponente übergebenen Daten empfangen und können innerhalb der Komponente verwendet werden.

Im folgenden Beispiel empfängt MyComponent eine title-Prop und verwendet sie im Template:

Beispiel

const MyComponent = {
  props: ['title'],
  template: '<h1>{{ title }}</h1>'
};

const app = Vue.createApp({
  components: {
    'my-component': MyComponent
  },
  template: '<my-component title="Hallo Vue 3!"></my-component>'
});

app.mount('#app');

template

  • Typ: String

  • Zweck: templateDie Eigenschaft definiert die Template-Struktur der Vue-Komponente. Die Template-Syntax von Vue kann im Template verwendet werden, einschließlich Interpolation, Direktiven, berechneten Eigenschaften usw. Das Template wird schließlich in eine Render-Funktion kompiliert, um das virtuelle DOM der Komponente zu generieren.

Beispiel

const app = Vue.createApp({
  data() {
    return {
      message: 'Hello Vue!'
    };
  },
  template: '<div>{{ message }}</div>'
});

components

Die Option `components` wird verwendet, um lokale Komponenten zu registrieren.

Beispiel

const ChildComponent = {
  template: '<div>Eine untergeordnete Komponente</div>'
};

const app = Vue.createApp({
  components: {
    'child-component': ChildComponent
  },
  template: '<child-component></child-component>'
}).mount('#app');

provide / inject

Die Elternkomponente stellt Daten bereit, und die Kindkomponente injiziert und verwendet sie.

Beispiel

const ChildComponent = {
  inject: ['message'],
  template: '<div>{{ message }}</div>'
};

const app = Vue.createApp({
  bieten() {
    return {
      message: 'Provided Message'
    };
  },
  components: {
    'child-component': ChildComponent
  },
  template: '<child-component></child-component>'
}).mount('#app');

Lebenszyklus-Hooks

beforeCreate

Wird aufgerufen, bevor die Instanz initialisiert wird.

Beispiel

const app = Vue.createApp({
  beforeCreate() {
    console.log('beforeCreate');
  }
}).mount('#app');

created

Wird aufgerufen, nachdem die Instanz erstellt wurde.

Beispiel

const app = Vue.createApp({
  created() {
    console.log('created');
  }
}).mount('#app');

beforeMount

Wird vor dem Mounten aufgerufen.

Beispiel

const app = Vue.createApp({
  beforeMount() {
    console.log('beforeMount');
  }
}).mount('#app');

mounted

Wird aufgerufen, nachdem die Instanz gemountet wurde.

Beispiel

const app = Vue.createApp({
  mounted() {
    console.log('mounted');
  }
}).mount('#app');

beforeUpdate

Wird aufgerufen, bevor die Daten aktualisiert werden.

Beispiel

const app = Vue.createApp({
  data() {
    return {
      message: 'Hello'
    };
  },
  beforeUpdate() {
    console.log('beforeUpdate');
  }
}).mount('#app');

updated

Wird aufgerufen, nachdem die Daten aktualisiert wurden.

Beispiel

const app = Vue.createApp({
  data() {
    return {
      message: 'Hello'
    };
  },
  updated() {
    console.log('updated');
  }
}).mount('#app');

beforeUnmount

Wird aufgerufen, bevor die Instanz unmountet wird.

Beispiel

const app = Vue.createApp({
  beforeUnmount() {
    console.log('beforeUnmount');
  }
}).mount('#app');

unmounted

Wird aufgerufen, nachdem die Instanz ausgehängt wurde.

Beispiel

const app = Vue.createApp({
  unmounted() {
    console.log('unmounted');
  }
}).mount('#app');

Weitere Optionen

directives

Lokale Direktiven registrieren.

Beispiel

const app = Vue.createApp({
  directives: {
    focus: {
      mounted(el) {
        el.focus();
      }
    }
  },
  template: '<input v-focus>'
}).mount('#app');

mixins

Mixin-Objekte.

Beispiel

const myMixin = {
  created() {
    console.log('Mixin created');
  }
};

const app = Vue.createApp({
  mixins: [myMixin],
  created() {
    console.log('Component created');
  }
}).mount('#app');

extends

Erweitere eine weitere Komponente.

Beispiel

const BaseComponent = {
  created() {
    console.log('BaseComponent created');
  }
};

const app = Vue.createApp({
  extends: BaseComponent,
  created() {
    console.log('Extended component created');
  }
}).mount('#app');

inheritAttrs

Ob Attribute von der übergeordneten Komponente geerbt werden sollen.

Beispiel

const MyComponent = {
  inheritAttrs: false,
  props: ['title'],
  template: '<div><h1>{{ title }}</h1></div>'
};

const app = Vue.createApp({
  components: {
    'my-component': MyComponent
  },
  template: '<my-component title="Hello" id="app"></my-component>'
}).mount('#app');

setup

Wird für die Composition API verwendet.

Beispiel

const app = Vue.createApp({
  setup() {
    const message = Vue.ref('Hello Vue 3!');
    return { message };
  },
  template: '<h1>{{ message }}</h1>'
}).mount('#app');

expose

In der Composition API von Vue 3 können Sie, wenn Sie die setup-Funktion verwenden, um die Komponentenlogik zu definieren, die expose-Methode verwenden, um explizit die nach außen freizugebenden Eigenschaften und Methoden anzugeben.

Das Folgende ist ein einfaches Beispiel, das zeigt, wie man expose verwendet, um Eigenschaften und Methoden in einer Vue-3-Komponente freizugeben:

Elternkomponente (ParentComponent.vue)

<template>
  <div>
    <child-component ref="child"></child-component>
    <button @click="callChildMethod">Untergeordnete Methode aufrufen</button>
  </div>
</template>

<script>
import { ref } from 'vue';
import ChildComponent from './ChildComponent.vue';

export default {
  components: {
    ChildComponent
  },
  setup() {
    const child = ref(null);

    const callChildMethod = () => {
      if (child.value) {
        child.value.exposedMethod();
      }
    };

    return {
      child,
      callChildMethod
    };
  }
};
</script>

Untergeordnete Komponente (ChildComponent.vue)

<template>
  <div>
    <p>{{ exposedData }}</p>
  </div>
</template>

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

export default {
  setup(_, { expose }) {
    const exposedData = ref('Hallo von der untergeordneten Komponente');
   
    const exposedMethod = () => {
      console.log('Methode der untergeordneten Komponente aufgerufen');
    };

    expose({
      exposedData,
      exposedMethod
    });

    return {
      exposedData
    };
  }
};
</script>

Erklärung:

  1. Übergeordnete Komponente:

    • Verwenden Sie in der übergeordneten Komponenterefum eine Referenz auf die untergeordnete Komponente zu erstellen.child。
    • IncallChildMethodIn der Methode, durchchild.valuegreifen Sie auf die Instanz der untergeordneten Komponente zu und rufen Sie die von der untergeordneten Komponente bereitgestellten Methoden auf.exposedMethod。
  2. Untergeordnete Komponente:

    • In der untergeordneten KomponentesetupFunktion, durchrefreaktive Daten erstellenexposedData。
    • eine Methode definierenexposedMethod, verwendet, um zu zeigen, wie Methoden verfügbar gemacht werden.
    • Verwenden Sieexposedie Methode, um explizit verfügbar zu machenexposedDataundexposedMethodan die übergeordnete Komponente.
    • ReturnexposedData, damit es im Template verwendet werden kann.
Andere Erweiterungen