Skip to content

2. Erste Schritte mit Vue.js

2.1. Beispiel 01: Die Struktur einer Vue.js-Anwendung

2.1.1. Die Datei package.json

Die Datei [package.json] im Ordner examples deklariert die verwendeten Bibliotheken und die Projektbefehle:

{
  "name": "examples-vuejs",
  "version": "1.0.0",
  "description": "The small examples of the course [Step-by-step introduction to the Vue.js framework] - a single installation for all of them",
  "private": true,
  "type": "module",
  "scripts": {
    "dev": "vite",
    "build": "vue-tsc --noEmit && vite build",
    "check": "vue-tsc --noEmit"
  },
  "dependencies": {
    "bootstrap": "^5.3.8",
    "pinia": "^3.0.4",
    "vue": "^3.5.22",
    "vue-i18n": "~11.3.2",
    "vue-router": "^4.6.3"
  },
  "devDependencies": {
    "@types/node": "^22.10.0",
    "@vitejs/plugin-vue": "^6.0.1",
    "@vue/tsconfig": "^0.8.1",
    "typescript": "~5.9.3",
    "vite": "^7.1.12",
    "vue-tsc": "^3.1.3"
  }
}

Gehen wir diese Datei durch:

  • Zeile 6: Die [JavaScript]-Dateien des Projekts sind ES-Module ([import] / [export]), das Standardformat von [JavaScript], das sowohl von Browsern als auch von [Node.js] unterstützt wird;
  • Zeilen 7–11: die Projektbefehle, die mit [npm run <name>] gestartet werden:
    • [npm run dev] startet den Entwicklungsserver von [Vite];
    • [npm run check] lässt die [TypeScript]-Typen aller Dateien, einschließlich der [.vue]-Dateien, vom Werkzeug [vue-tsc] prüfen;
    • [npm run build] prüft die Typen und erstellt anschließend die Produktionsversion der Beispiele;
  • Zeilen 12–18: die Bibliotheken, die die Anwendung im Browser benötigt: [Vue.js] selbst, sein Router ([vue-router]), [Pinia] für den gemeinsamen Zustand, [vue-i18n] für die Sprachen und [Bootstrap] für die Formatierung;
  • Zeilen 19–26: die Entwicklungs-Werkzeuge: [Vite] und seine Erweiterung für [.vue]-Dateien, der [TypeScript]-Compiler und [vue-tsc]. Sie sind nicht Teil der an die Benutzer ausgelieferten Anwendung.

Das Präfix [^] einer Version ([^3.5.22]) erlaubt es [npm] , eine neuere Version derselben Hauptversion (3.x.y) zu installieren; das Präfix [~] ([~11.3.2]) erlaubt nur Hotfixes (11.3.x). Die Version von [vue-i18n] ist absichtlich auf die Serie 11.3 festgelegt: Spätere Versionen erfordern [Node.js] 22.

2.1.2. Die Datei vite.config.ts

[Vite] ist das Werkzeug, das eine [Vue.js]-Anwendung während der Entwicklung ausführt und anschließend für die Produktion erstellt. Seine Konfiguration, die allen Beispielen gemeinsam ist:

// =========================================================================
// vite.config.ts - die Vite-Konfiguration, gemeinsam für ALLE Beispiele.
// -------------------------------------------------------------------------
// Vite ist beides:
//   - ein Entwicklungsserver (npm run dev): Er kompiliert die vom Browser angeforderten
//     .vue- und .ts-Dateien laufend und lädt die Seite
//     (oder nur die geänderte Komponente) bei jedem Speichern neu;
//   - ein Build-Werkzeug (npm run build): Es erzeugt in dist/
//     optimierte .js- und .css-Dateien für die Bereitstellung auf einem Webserver.
//
// Jedes Beispiel ist eine kleine eigenständige Anwendung mit eigener
// index.html: 01-first-application/index.html, 02-reactivity/index.html ...
// Ein einziger Vite-Server stellt alle bereit: http://localhost:5173/ zeigt das
// Inhaltsverzeichnis (index.html dieses Ordners), http://localhost:5173/01-first-application/
// das erste Beispiel usw.
// =========================================================================

import { existsSync, readdirSync } from 'node:fs';
import { fileURLToPath } from 'node:url';
import { resolve } from 'node:path';
import { defineConfig } from 'vite';
import vue from '@vitejs/plugin-vue';

const root = fileURLToPath(new URL('.', import.meta.url));

// die Beispielordner: diejenigen, deren Name mit zwei Ziffern beginnt
const examples = readdirSync(root).filter((d) => /^\d\d-/.test(d) && existsSync(resolve(root, d, 'index.html')));

export default defineConfig({
  // das Plugin, das Vite beibringt, .vue-Dateien zu kompilieren
  plugins: [vue()],

  server: {
    port: 5173,
    // der PROXY: Jede Anfrage des Browsers an /api/... wird von
    // Vite an den JSON-Server von RdvMedecins (Port 8080) weitergeleitet, die Antwort geht dann
    // zurück an den Browser. Für den Browser haben Seite und API somit denselben Ursprung
    // (http://localhost:5173): kein CORS zu konfigurieren, und das Cookie mit dem
    // JWT-Token wird ganz normal übertragen (siehe das Kapitel zur Blackbox).
    proxy: {
      '/api': 'http://localhost:8080',
    },
  },

  // npm run build: eine HTML-Einstiegsseite pro Beispiel, plus das Inhaltsverzeichnis
  build: {
    rollupOptions: {
      input: Object.fromEntries([
        ['contents', resolve(root, 'index.html')],
        ...examples.map((d) => [d, resolve(root, d, 'index.html')]),
      ]),
    },
  },
});
  • Zeile 31: die Erweiterung, die [Vite] anweist, die [.vue]-Dateien zu kompilieren. Ein Browser kann eine [.vue]-Datei nicht lesen: Wenn er eine anfordert, [Vite] wandelt es sie im laufenden Betrieb in eine Standard-[JavaScript]-Datei um;
  • Zeile 34: der Port des Entwicklungsservers;
  • Zeilen 40–41: der Proxy, der erst ab Beispiel 17 verwendet wird: Jede Anfrage des Browsers an eine Adresse, die mit [/api] beginnt, wird an den JSON-Server [RdvMedecins] auf Port 8080 weitergeleitet. Wir kommen darauf zurück;
  • Zeilen 27 und 46–53: [npm run build] muss alle Einstiegsseiten der Anwendung kennen. Ihm werden die Startseite und die Datei [index.html] jedes Ordners übergeben, dessen Name mit zwei Ziffern beginnt.

2.1.3. Die Dateien tsconfig.json und env.d.ts

1
2
3
4
5
6
7
8
9
{
  "extends": "@vue/tsconfig/tsconfig.dom.json",
  "compilerOptions": {
    "types": ["vite/client"],
    "noUnusedLocals": true,
    "noUnusedParameters": true
  },
  "include": ["*/src/**/*.ts", "*/src/**/*.vue", "common/**/*.ts", "common/**/*.vue", "env.d.ts"]
}
  • Zeile 2: Wir verwenden die für [Vue.js] empfohlene [TypeScript]-Konfiguration ([@vue/tsconfig]-Paket): moderner Code, strikter Modus, Typprüfung im Browser (DOM);
  • Zeile 4: für [Vite] spezifische Typen (etwa beim Import einer [.css]- oder [.svg]-Datei);
  • Zeilen 5–7: Eine unbenutzte Variable oder ein unbenutzter Parameter wird als Fehler gemeldet;
  • Zeile 8: die zu prüfenden Dateien: die in den Ordnern [src] der Beispiele und im Ordner [common].

Die Datei [env.d.ts] enthält nur eine Direktive, die dieselben Typen wie in [Vite] im Editor sichtbar macht:

// die Vite-spezifischen Typen (Import von .css-Dateien, import.meta.env ...)
/// <reference types="vite/client" />

2.1.4. Die Seite index.html

Jedes Beispiel hat seine eigene HTML-Seite. Die Seite für Beispiel 01:

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Example 01 - a first application</title>
</head>
<body>
  <!-- die Vue.js-Anwendung wird in diesem Element angezeigt (siehe src/main.ts) -->
  <div id="app"></div>
  <script type="module" src="./src/main.ts"></script>
</body>
</html>

Dies ist die einzige Seite, die der Browser lädt. Sie ist fast leer:

  • Zeile 10: das Element, in dem [Vue.js] die Anwendung anzeigt;
  • Zeile 11: das Anwendungsprogramm. [Vite] kompiliert es und sendet es als [JavaScript] an den Browser.

2.1.5. Der Einstiegspunkt: main.ts

// =========================================================================
// 01-first-application/src/main.ts - der Einstiegspunkt der Anwendung
// -------------------------------------------------------------------------
// index.html lädt diese Datei (<script type="module" src="./src/main.ts">).
// Sie erstellt die Vue.js-Anwendung aus ihrer ROOT-Komponente (App.vue)
// und zeigt sie im Element <div id="app"> der Seite an.
// =========================================================================

import { createApp } from 'vue';
// das Bootstrap-Stylesheet: Vite fügt es in die Seite ein
import 'bootstrap/dist/css/bootstrap.min.css';
import App from './App.vue';

// createApp(App): eine Anwendung, deren Wurzelkomponente App ist;
// mount('#app'): ihre HTML-Darstellung ersetzt den Inhalt von <div id="app">
createApp(App).mount('#app');
  • Zeile 9: die Funktion von [Vue.js] , die eine Anwendung erstellt;
  • Zeile 11: Ein Stylesheet, [CSS], wird wie ein Modul importiert. [Vite] fügt es in die Seite ein;
  • Zeile 12: die Wurzelkomponente der Anwendung, definiert in der Datei [App.vue];
  • Zeile 16: Die Anwendung wird aus dieser Komponente erstellt und dann in das Element [<div id="app">] „gemountet“: Das von [App.vue] erzeugte HTML ersetzt dessen Inhalt.

2.1.6. Die Wurzelkomponente: App.vue

<!--
  =========================================================================
  01-first-application/src/App.vue - a first component
  -------------------------------------------------------------------------
  A .vue file (Single File Component) groups the three facets of a
  component:
    - <script setup>: the data and the code of the component (TypeScript);
    - <template>    : the HTML to display, with {{ ... }};
    - <style>       : its CSS (here "scoped": it only applies to it).
  =========================================================================
-->
<script setup lang="ts">
import { ref } from 'vue';

// "gewöhnliche" Daten: das Template kann sie anzeigen
const title = 'Welcome to Vue.js';
const languages = ['TypeScript', 'HTML', 'CSS'];

// ref(...): ein REAKTIVES Datum. Ändert sich sein Wert (.value), aktualisiert Vue
// AUTOMATISCH die Stellen der Seite, die es anzeigen
const counter = ref(0);
const time = ref(new Date().toLocaleTimeString());

// eine Funktion, die vom Button des Templates aufgerufen wird
function increment(): void {
  counter.value++;
  time.value = new Date().toLocaleTimeString();
}
</script>

<template>
  <div class="container py-4">
    <!-- {{ expression }}: der Wert des Ausdrucks, in die Seite eingefügt -->
    <h1 class="h3">{{ title }}</h1>
    <p>This page is built in the browser, by Vue.js, from three files: index.html, main.ts and App.vue.</p>
    <p>It is written in {{ languages.join(', ') }} ({{ languages.length }} languages).</p>

    <!-- @click: die Funktion, die bei einem Klick aufgerufen wird (siehe Beispiel 04) -->
    <button class="btn btn-primary" @click="increment">Click me</button>
    <!-- im Template kein .value: Vue "entpackt" die Refs selbstständig -->
    <p class="mt-3 counter">You clicked {{ counter }} times (last click: {{ time }}).</p>
  </div>
</template>

<style scoped>
/* "scoped": diese Regel gilt nur für die Elemente DIESER Komponente */
.counter {
  font-weight: bold;
  color: #0d6efd;
}
</style>

Eine [.vue]-Datei (Single File Component, kurz SFC) vereint die drei Facetten einer Komponente:

  • Zeilen 12–29: der Code der Komponente in [TypeScript] ([lang="ts"]). Mit [setup] sind alle auf oberster Ebene des Skripts deklarierten Variablen und Funktionen direkt im Template verwendbar;
    • Zeilen 16–17: zwei gewöhnliche Daten;
    • Zeile 21: [ref(0)] erzeugt ein reaktives Datum mit dem Anfangswert 0. Sein Wert wird über seine Eigenschaft [value] gelesen und geändert. Wenn er sich ändert, aktualisiert [Vue.js] alle Stellen der Seite, an denen er angezeigt wird;
    • Zeilen 25–27: eine Funktion, die zwei reaktive Daten ändert. Sie verändert die Seite nicht: [Vue.js] aktualisiert sie;
  • Zeilen 31–43: das HTML der Komponente:
    • Zeile 34: Die Syntax [{{ expression }}] (die „Mustache-Klammern“) fügt den Wert eines [TypeScript]-Ausdrucks in die Seite ein. Er wird maskiert: Wenn [title] den Text [<b>] enthielte, würde [<b>] angezeigt, ohne dass das Tag interpretiert würde;
    • Zeile 36: Der Ausdruck kann beliebig sein: ein Methodenaufruf, eine Berechnung;
    • Zeile 39: Ein Klick auf die Schaltfläche ruft die Funktion [increment] auf (siehe Beispiel 04);
    • Zeile 41: Im Template schreibt man [counter], nicht [counter.value]: [Vue.js] „entpackt“ das [ref] automatisch;
  • Zeilen 45–51: das CSS der Komponente. Mit [scoped] gelten seine Regeln nur für die Elemente dieser Komponente: [Vite] fügt seinen Elementen ein eindeutiges Attribut hinzu ([data-v-xxxx]) und bezieht es in die Selektoren ein.

2.1.7. Ausführung

Öffnen Sie bei laufendem [Vite]-Server ([npm run dev]) die URL http://localhost:5173/01-first-application/ und klicken Sie dreimal auf die Schaltfläche:

Image

Zwei Experimente zum Ausprobieren:

  • Ändern Sie den Titeltext in [App.vue] und speichern Sie die Datei: Die Seite aktualisiert sich sofort ohne Neuladen, und der Zähler behält seinen Wert. Das ist der Austausch im laufenden Betrieb von Modulen (HMR, [Hot Module Replacement]) von [Vite];
  • Zeigen Sie den Quelltext der Seite an (Ctrl-U): Er enthält nur die Seite [index.html], die fast leer ist. Das angezeigte HTML wurde von [Vue.js] im Browser generiert. Um es zu sehen, verwenden Sie den Inspektor der Entwicklerwerkzeuge (F12, Registerkarte Elemente) oder die Erweiterung [Vue.js devtools], die auch die Komponenten und ihre Daten anzeigt.

2.2. Beispiel 02: Reaktivität

Die Reaktivität steht im Mittelpunkt von [Vue.js]. Dieses Beispiel berechnet den Preis eines Artikels einschließlich Mehrwertsteuer:

<!--
  =========================================================================
  02-reactivity/src/App.vue - ref, reactive, computed, watch
  -------------------------------------------------------------------------
  A small calculator of prices including VAT:
    - ref      : a simple reactive value (a number, a string...);
    - reactive : a reactive OBJECT (all its properties are reactive);
    - computed : a value COMPUTED from other ones, recomputed
                 automatically when they change;
    - watch    : code executed when a value changes (an "effect").
  =========================================================================
-->
<script setup lang="ts">
import { computed, reactive, ref, watch } from 'vue';

// ref: Sein Wert wird (im TypeScript-Code) über .value gelesen und geschrieben
const quantity = ref(1);

// reactive: ein Objekt, dessen Eigenschaften direkt gelesen und geschrieben werden
const item = reactive({
  label: 'Pen',
  priceExclVat: 2.5,
  vatRate: 20, // in %
});

// computed: wird nie direkt zugewiesen, sondern immer neu berechnet. Vue weiß, von welchen
// Daten es abhängt (quantity, item.priceExclVat, item.vatRate):
// Es berechnet den Wert neu, wenn sich eines davon ändert, und nur dann
const totalExclVat = computed(() => quantity.value * item.priceExclVat);
const vatAmount = computed(() => (totalExclVat.value * item.vatRate) / 100);
const totalInclVat = computed(() => totalExclVat.value + vatAmount.value);

// ein Formatierer für Eurobeträge im englischen Stil (€1,234.50)
const euros = new Intl.NumberFormat('en-US', { style: 'currency', currency: 'EUR' });

// watch: bei jeder Änderung des Gesamtbetrags inklusive Mehrwertsteuer halten wir eine Spur fest
const history = ref<string[]>([]);
watch(totalInclVat, (newValue, oldValue) => {
  history.value.unshift(`${euros.format(oldValue)} -> ${euros.format(newValue)}`);
  history.value = history.value.slice(0, 5); // die letzten 5
});

function reset(): void {
  quantity.value = 1;
  item.priceExclVat = 2.5;
  item.vatRate = 20;
}
</script>

<template>
  <div class="container py-4">
    <h1 class="h3 mb-3">Example 02 - reactivity</h1>
    <div class="row g-4">
      <div class="col-md-6">
        <div class="card p-3">
          <!-- v-model verbindet ein Feld in beide Richtungen mit einem Datum (siehe Beispiel 05) -->
          <label class="form-label">Item</label>
          <input v-model="item.label" class="form-control mb-2">
          <label class="form-label">Unit price excl. VAT</label>
          <input v-model.number="item.priceExclVat" type="number" step="0.1" min="0" class="form-control mb-2">
          <label class="form-label">Quantity</label>
          <input v-model.number="quantity" type="number" min="0" class="form-control mb-2">
          <label class="form-label">VAT rate</label>
          <select v-model.number="item.vatRate" class="form-select mb-3">
            <option :value="5.5">5.5 %</option>
            <option :value="10">10 %</option>
            <option :value="20">20 %</option>
          </select>
          <button class="btn btn-outline-secondary" @click="reset">Reset</button>
        </div>
      </div>
      <div class="col-md-6">
        <div class="card p-3">
          <h2 class="h5">{{ quantity }} x {{ item.label }}</h2>
          <table class="table mb-0">
            <tbody>
              <tr><td>Total excl. VAT</td><td class="text-end">{{ euros.format(totalExclVat) }}</td></tr>
              <tr><td>VAT ({{ item.vatRate }} %)</td><td class="text-end">{{ euros.format(vatAmount) }}</td></tr>
              <tr class="fw-bold"><td>Total incl. VAT</td><td class="text-end">{{ euros.format(totalInclVat) }}</td></tr>
            </tbody>
          </table>
        </div>
        <div class="card p-3 mt-3">
          <h2 class="h6">History of the total incl. VAT (watch)</h2>
          <ul class="mb-0">
            <li v-for="(line, i) in history" :key="i">{{ line }}</li>
          </ul>
        </div>
      </div>
    </div>
  </div>
</template>
  • Zeile 17: [ref] nimmt einen einfachen Wert an (Zahl, Zeichenkette, Boolean);
  • Zeilen 20–24: [reactive] macht ein ganzes Objekt reaktiv: Jede seiner Eigenschaften ist reaktiv. Sie werden direkt gelesen und geschrieben ([item.priceExclVat]), ohne [.value];
  • Zeilen 29–31: [computed] definiert einen aus anderen Werten berechneten Wert. [Vue.js] merkt sich die bei der Berechnung gelesenen Daten ([quantity], [item.priceExclVat]...) und berechnet nur neu, wenn sich eines davon ändert. Ihm wird nie ein Wert zugewiesen: Er wird gelesen ([totalExclVat.value]);
  • Zeile 34: [Intl.NumberFormat], das in [JavaScript] integrierte Werkzeug zur Zahlenformatierung: [2.5] wird zu „€2.50“;
  • Zeilen 38–41: [watch] führt Code aus, sobald sich Daten ändern, und erhält dabei den neuen und den alten Wert. Es dient für Aktionen wie das Speichern von Daten, das Senden einer Anfrage oder das Schreiben in den Speicher des Browsers... Um einen abgeleiteten Wert anzuzeigen, bevorzugen wir [computed];
  • Zeilen 43–46: Es genügt, die Daten zu ändern; alle Felder, Summen und der Verlauf aktualisieren sich entsprechend;
  • Zeilen 58–64: [v-model] verbindet jedes Feld in beide Richtungen mit einem Datum (siehe Beispiel 05);
  • Zeile 77: Im Template wird ein [computed] genauso wie ein [ref] verwendet, ohne [.value];
  • Zeile 86: eine wiederholte Liste für jedes Element des Arrays [history] (siehe Beispiel 03).

Image

2.3. Beispiel 03: Direktiven

Eine Direktive ist ein spezielles Template-Attribut mit dem Präfix [v-], das das Verhalten des Elements festlegt, auf das es angewendet wird.

<!--
  =========================================================================
  03-directives/src/App.vue - the basic directives
  -------------------------------------------------------------------------
  A DIRECTIVE is a special attribute of the template, prefixed by v-:
    - v-bind:attr="expr" (short form :attr="expr"): the value of an HTML
      attribute computed by an expression; :class and :style accept
      objects and arrays;
    - v-if / v-else-if / v-else: the element only exists in the page if
      the condition is true;
    - v-show: the element always exists, it is only hidden (display:none);
    - v-for="x in list": the element is repeated for each x, with a
      unique :key that allows Vue to follow each row.
  =========================================================================
-->
<script setup lang="ts">
import { computed, ref } from 'vue';
// Import eines Bildes: Vite liefert seine URL (und in der Produktion eine
// optimierte Kopie der Datei mit eindeutigem Namen)
import logoUrl from './assets/doctor.svg';

// ein TypeScript-Interface beschreibt die Form der Objekte der Liste
interface Doctor {
  id: number;
  title: string;
  firstName: string;
  lastName: string;
  specialty: string;
  available: boolean;
}

const doctors = ref<Doctor[]>([
  { id: 1, title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER', specialty: 'general practitioner', available: true },
  { id: 2, title: 'Mr', firstName: 'Paul', lastName: 'TATOU', specialty: 'pediatrician', available: false },
  { id: 3, title: 'Melle', firstName: 'Sophie', lastName: 'DUPONT', specialty: 'general practitioner', available: true },
]);

const filter = ref(''); // gesuchter Text
const onlyAvailable = ref(false);
const showHelp = ref(true);

// die angezeigte Liste: ein Computed, das bei Änderung des Filters neu berechnet wird
const displayedDoctors = computed(() =>
  doctors.value.filter(
    (m) =>
      (!onlyAvailable.value || m.available) &&
      `${m.firstName} ${m.lastName} ${m.specialty}`.toLowerCase().includes(filter.value.trim().toLowerCase()),
  ),
);
</script>

<template>
  <div class="container py-4">
    <h1 class="h3 mb-3">
      <!-- :src: Der Wert des Attributs src ist der der Variablen logoUrl -->
      <img :src="logoUrl" alt="logo" width="32" height="32">
      Example 03 - directives
    </h1>

    <div class="d-flex flex-wrap gap-3 align-items-center mb-3">
      <input v-model="filter" class="form-control w-auto" placeholder="search...">
      <label class="form-check-label">
        <input v-model="onlyAvailable" type="checkbox" class="form-check-input"> available only
      </label>
      <button class="btn btn-sm btn-outline-secondary" @click="showHelp = !showHelp">
        {{ showHelp ? "Hide help" : "Show help" }}
      </button>
    </div>

    <!-- v-show: Der Absatz bleibt in der Seite, ist aber nur ausgeblendet -->
    <p v-show="showHelp" class="alert alert-info">
      Type a name or a specialty. Unavailable doctors are greyed out.
    </p>

    <!-- v-if / v-else-if / v-else: Es existiert immer nur einer der drei Blöcke -->
    <p v-if="doctors.length === 0" class="text-muted">No doctors.</p>
    <p v-else-if="displayedDoctors.length === 0" class="text-warning">No doctor matches "{{ filter }}".</p>
    <table v-else class="table">
      <thead>
        <tr><th>#</th><th>Doctor</th><th>Specialty</th><th>Status</th></tr>
      </thead>
      <tbody>
        <!-- v-for: one row per doctor; (m, index) also gives the rank.
             :key="m.id": the identity of each row, so that Vue knows
             which row to add, move or remove when the list changes -->
        <tr v-for="(m, index) in displayedDoctors" :key="m.id" :class="{ 'text-muted': !m.available }">
          <td>{{ index + 1 }}</td>
          <td>{{ m.title }} {{ m.firstName }} {{ m.lastName }}</td>
          <td>{{ m.specialty }}</td>
          <td>
            <!-- :class mit einem Array: mehrere Klassen, eine davon berechnet -->
            <span :class="['badge', m.available ? 'text-bg-success' : 'text-bg-secondary']">
              {{ m.available ? 'available' : 'unavailable' }}
            </span>
          </td>
        </tr>
      </tbody>
    </table>

    <!-- :style mit einem Objekt: berechnete CSS-Eigenschaften -->
    <p :style="{ fontSize: 12 + displayedDoctors.length * 2 + 'px' }">
      {{ displayedDoctors.length }} doctor(s) displayed - the size of this text depends on it.
    </p>
  </div>
</template>
  • Zeile 23: Ein [TypeScript] -Interface beschreibt das Format der Objekte der Liste; [ref<Doctor[]>(...)] gibt den Datentyp an;
  • Zeile 20: Ein Bild wird als Modul importiert. [Vite] liefert seine Adresse; in der Produktion erzeugt es eine Kopie mit eindeutigem Namen (der sich mit ihrem Inhalt ändert: Browser behalten nie eine alte Version im Cache);
  • Zeile 43: die angezeigte Liste, gefiltert nach Eingabe und Kontrollkästchen;
  • Zeile 56: [v-bind:src="expression"], abgekürzt zu [:src="expression"], weist dem Attribut [src] den Wert eines Ausdrucks zu. Ohne den Doppelpunkt [src="logoUrl"] würde auf eine Datei namens „logoUrl“ verweisen;
  • Zeile 71: [v-show] blendet das Element aus ([display: none]), wenn die Bedingung falsch ist. Das Element bleibt auf der Seite;
  • Zeilen 76–78: [v-if], [v-else-if], und [v-else]: Nur eines dieser drei Elemente existiert jeweils auf der Seite. Wir wählen [v-show] für ein Element, das häufig ein- und ausgeblendet wird, und [v-if] in allen anderen Fällen;
  • Zeile 86: [v-for] wiederholt das Element für jeden Arzt; [index] ist sein Rang (beginnend bei 0). Das Attribut [:key="m.id"] gibt jeder Zeile eine Identität: Wenn sich die Liste ändert, [Vue.js] weiß es, welche Zeilen hinzuzufügen, zu löschen oder zu verschieben sind, statt alles von Grund auf neu aufzubauen. Ein Schlüssel muss eindeutig und stabil sein: Wir verwenden den Bezeichner des Objekts, niemals seinen Rang;
  • Zeile 86: [:class] mit einem Objekt: Die Klasse [text-muted] wird hinzugefügt, wenn die Bedingung wahr ist;
  • Zeile 92: [:class] mit einem Array: mehrere Klassen, darunter eine berechnete;
  • Zeile 101: [:style] mit einem Objekt berechneter [CSS] -Eigenschaften (in [camelCase]).

Image

Bei einem Filter ohne Ergebnis wird der Absatz mit [v-else-if] angezeigt:

Image

2.4. Beispiel 04: Ereignisse

<!--
  =========================================================================
  04-events/src/App.vue - reacting to the user's actions
  -------------------------------------------------------------------------
  v-on:event="handler" (short form @event="handler"):
    - @click="f"          calls f(nativeEvent);
    - @click="f(3, $event)" calls f with arguments; $event is
                          the native event of the browser;
    - modifiers: @submit.prevent (prevents the classic submission of the
      form), @keyup.enter (only the Enter key), @click.stop...
  =========================================================================
-->
<script setup lang="ts">
import { ref } from 'vue';

interface Task {
  id: number;
  label: string;
  done: boolean;
}

const tasks = ref<Task[]>([
  { id: 1, label: 'Install Node.js', done: true },
  { id: 2, label: 'Read the chapter on events', done: false },
]);
const newTask = ref('');
const log = ref<string[]>([]);
let nextId = 3;

function trace(message: string): void {
  log.value.unshift(`${new Date().toLocaleTimeString()} ${message}`);
}

// aufgerufen durch @submit.prevent: Der Browser sendet das Formular NICHT an den
// Server (kein Neuladen der Seite), unser Code übernimmt
function add(): void {
  const label = newTask.value.trim();
  if (label === '') {
    return;
  }
  tasks.value.push({ id: nextId++, label, done: false });
  trace(`added "${label}"`);
  newTask.value = '';
}

function remove(task: Task): void {
  tasks.value = tasks.value.filter((t) => t.id !== task.id);
  trace(`removed "${task.label}"`);
}

// $event: das native Ereignis (hier ein MouseEvent) mit seinen Koordinaten
function position(event: MouseEvent): void {
  trace(`click at (${event.offsetX}, ${event.offsetY})`);
}
</script>

<template>
  <div class="container py-4">
    <h1 class="h3 mb-3">Example 04 - events</h1>

    <!-- @submit.prevent: Eingabetaste im Feld ODER Klick auf den Button -->
    <form class="d-flex gap-2 mb-3" @submit.prevent="add">
      <input v-model="newTask" class="form-control" placeholder="new task" @keyup.esc="newTask = ''">
      <button type="submit" class="btn btn-primary">Add</button>
    </form>

    <ul class="list-group mb-3">
      <li v-for="t in tasks" :key="t.id" class="list-group-item d-flex align-items-center gap-2">
        <input v-model="t.done" type="checkbox" class="form-check-input" @change="trace(`“${t.label}”: ${t.done ? 'done' : 'to do'}`)">
        <span :class="{ 'text-decoration-line-through text-muted': t.done }" class="flex-grow-1">{{ t.label }}</span>
        <!-- ein Handler mit Argument: die Aufgabe DIESER Zeile -->
        <button class="btn btn-sm btn-outline-danger" @click="remove(t)">Delete</button>
      </li>
    </ul>

    <div class="area p-3 mb-3 rounded" @click="position($event)">Click in this area</div>

    <h2 class="h6">Log</h2>
    <ul class="small">
      <li v-for="(line, i) in log" :key="i">{{ line }}</li>
    </ul>
  </div>
</template>

<style scoped>
.area {
  background: #e9f2ff;
  height: 80px;
  cursor: crosshair;
}
</style>
  • Zeile 62: [v-on:submit], abgekürzt als [@submit], lauscht auf das Ereignis [submit] des Formulars (Drücken der Eingabetaste in einem Feld oder Klick auf eine Schaltfläche). Der Modifikator [.prevent] ruft [event.preventDefault()] auf: Der Browser sendet das Formular NICHT an den Server und lädt die Seite nicht neu; ausgeführt wird die Funktion [add];
  • Zeile 63: ein Tastenmodifikator: Nur das Drücken von Esc löst den Handler aus. Es ist eine einfache Anweisung, die im Template geschrieben wird;
  • Zeile 69: Ein Handler kann ein Funktionsaufruf mit Argumenten sein;
  • Zeile 72: Jede Schaltfläche übergibt IHRE Aufgabe an [remove];
  • Zeile 76: [$event] bezeichnet das native Ereignis des Browsers – hier ein [MouseEvent] – samt den Klickkoordinaten;
  • Zeilen 36–43: Eine Aufgabe hinzuzufügen bedeutet, dem reaktiven Array ein Objekt hinzuzufügen; das Feld zu leeren bedeutet, das Datum zu leeren, mit dem es verbunden ist;
  • Zeilen 46–47: Das Array wird durch eine gefilterte Kopie ersetzt. [Vue.js] verfolgt sowohl Änderungen „an Ort und Stelle“ ([push], [splice]) als auch den vollständigen Austausch.

Image

2.5. Beispiel 05: Formularfelder

Dasselbe Formular wie Beispiel 18 aus dem Kurs [NestJS], nur dass hier alles im Browser abläuft:

<!--
  =========================================================================
  05-forms/src/App.vue - all the field types, linked by v-model
  -------------------------------------------------------------------------
  v-model="data" links a form field to a reactive piece of data, in
  BOTH directions: typing in the field modifies the data, and modifying the
  data (by code) modifies the field. The data received depends on the field:
    - text input, textarea              -> string
    - input + .number                   -> number
    - single checkbox                   -> boolean
    - checkboxes on the same array      -> string[] (the checked values)
    - radio buttons                     -> the value of the chosen button
    - select / select multiple          -> the value / an array of values
    - input type="date"                 -> string "yyyy-MM-dd"
  Modifiers: .trim (spaces removed), .number, .lazy (update when
  leaving the field rather than on each key).
  Same form as example 18 of the NestJS course; but here, no
  server: everything happens in the browser.
  =========================================================================
-->
<script setup lang="ts">
import { reactive, ref } from 'vue';

const titles = ['Mr', 'Mme', 'Melle'];
const possibleHobbies = ['sport', 'music', 'reading', 'cinema'];
const countries = [
  { code: 'fr', name: 'France' },
  { code: 'be', name: 'Belgium' },
  { code: 'ch', name: 'Switzerland' },
];

// alle Werte des Formulars in EINEM reaktiven Objekt
const form = reactive({
  title: 'Mme',
  name: '',
  age: 30,
  presentation: '',
  newsletter: false,
  hobbies: ['reading'] as string[],
  country: 'fr',
  languages: [] as string[],
  birthDate: '',
});

const sent = ref<string | null>(null);

function send(): void {
  // JSON.stringify: das, was wir an einen Server senden würden (siehe Beispiel 18)
  sent.value = JSON.stringify(form, null, 2);
}
</script>

<template>
  <div class="container py-4">
    <h1 class="h3 mb-3">Example 05 - the fields of a form</h1>
    <div class="row g-4">
      <form class="col-md-7" @submit.prevent="send">
        <div class="mb-3">
          <span class="form-label d-block">Title</span>
          <!-- Radiobuttons: dasselbe v-model, ein Wert pro Button -->
          <div v-for="t in titles" :key="t" class="form-check form-check-inline">
            <input :id="'title-' + t" v-model="form.title" type="radio" :value="t" class="form-check-input">
            <label :for="'title-' + t" class="form-check-label">{{ t }}</label>
          </div>
        </div>
        <div class="row g-3 mb-3">
          <div class="col-8">
            <label class="form-label" for="name">Name</label>
            <!-- .trim: " martin " wird zu "martin" -->
            <input id="name" v-model.trim="form.name" class="form-control">
          </div>
          <div class="col-4">
            <label class="form-label" for="age">Age</label>
            <!-- .number: Das Datum erhält eine Zahl, nicht den String "30" -->
            <input id="age" v-model.number="form.age" type="number" class="form-control">
          </div>
        </div>
        <div class="mb-3">
          <label class="form-label" for="presentation">About you</label>
          <textarea id="presentation" v-model="form.presentation" rows="2" class="form-control"></textarea>
        </div>
        <div class="mb-3 form-check">
          <!-- eine einzelne Checkbox: true / false -->
          <input id="newsletter" v-model="form.newsletter" type="checkbox" class="form-check-input">
          <label for="newsletter" class="form-check-label">Receive the newsletter</label>
        </div>
        <div class="mb-3">
          <span class="form-label d-block">Hobbies</span>
          <!-- mehrere Checkboxen auf demselben Array: die angehakten Werte -->
          <div v-for="h in possibleHobbies" :key="h" class="form-check form-check-inline">
            <input :id="'hobby-' + h" v-model="form.hobbies" type="checkbox" :value="h" class="form-check-input">
            <label :for="'hobby-' + h" class="form-check-label">{{ h }}</label>
          </div>
        </div>
        <div class="row g-3 mb-3">
          <div class="col-6">
            <label class="form-label" for="country">Country</label>
            <select id="country" v-model="form.country" class="form-select">
              <!-- :value: der übermittelte Wert (der Code), der angezeigte Text ist der Name -->
              <option v-for="c in countries" :key="c.code" :value="c.code">{{ c.name }}</option>
            </select>
          </div>
          <div class="col-6">
            <label class="form-label" for="languages">Spoken languages</label>
            <select id="languages" v-model="form.languages" multiple class="form-select" size="3">
              <option value="fr">French</option>
              <option value="en">English</option>
              <option value="es">Spanish</option>
            </select>
          </div>
        </div>
        <div class="mb-3">
          <label class="form-label" for="birthDate">Date of birth</label>
          <input id="birthDate" v-model="form.birthDate" type="date" class="form-control w-auto">
        </div>
        <button type="submit" class="btn btn-primary">Send</button>
      </form>

      <div class="col-md-5">
        <h2 class="h6">The model, live</h2>
        <!-- {{ object }} zeigt das Objekt im JSON-Format an -->
        <pre class="bg-light p-2 rounded small">{{ form }}</pre>
        <template v-if="sent">
          <h2 class="h6">Last submission</h2>
          <pre class="bg-success-subtle p-2 rounded small">{{ sent }}</pre>
        </template>
      </div>
    </div>
  </div>
</template>
  • Zeilen 33–43: alle Werte des Formulars in einem reaktiven Objekt. Die Annotationen [as string[]] teilen [TypeScript] den Typ der Arrays mit, der sich aus [[]] nicht ableiten lässt;
  • Zeile 62: Radiobuttons teilen sich dasselbe [v-model]; das Datum erhält den Wert ([:value]) des ausgewählten Buttons;
  • Zeile 70: Der Modifikator [.trim] entfernt führende und nachgestellte Leerzeichen;
  • Zeile 75: [.number] wandelt die Eingabe in eine Zahl um. Ohne ihn würde das Datum auf die Zeichenkette ["30"] gesetzt: Ein HTML-Feld enthält nur Text;
  • Zeile 84: Ein einzelnes Kontrollkästchen liefert einen booleschen Wert;
  • Zeile 91: Mehrere Kontrollkästchen, die mit demselben Array verbunden sind: Es enthält die Werte der angekreuzten Kontrollkästchen;
  • Zeile 100: Bei einer Dropdown-Liste ist [:value] der übermittelte Wert (der Ländercode); der Text der Option ist lediglich ihre Beschriftung;
  • Zeile 105: Eine Liste mit Mehrfachauswahl ergibt ein Array;
  • Zeile 114: Ein Datumsfeld liefert eine Zeichenkette ["yyyy-MM-dd"], unabhängig davon, wie der Browser es anzeigt;
  • Zeile 122: [{{ object }}] zeigt ein Objekt im JSON-Format an: Sie sehen, wie sich das Template bei jedem Tastendruck ändert;
  • Zeile 49: [JSON.stringify(form, null, 2)] erzeugt den JSON-Text eines Objekts, mit 2 Leerzeichen eingerückt. Dies würde an einen Server gesendet (siehe Beispiel 18).

Image

2.6. Beispiel 06: Formularvalidierung

Wir verwenden die Regeln des Formulars „Patientenkonto erstellen“ des Servers [RdvMedecins] und prüfen sie im Browser, während der Benutzer tippt:

<!--
  =========================================================================
  06-validation/src/App.vue - validating a form in the browser
  -------------------------------------------------------------------------
  The errors are COMPUTED values: they are recomputed on each keystroke.
  They are not displayed right away (an empty form covered in red is
  unpleasant): only for a field already left ("touched"), or for
  all the fields after a submission attempt.

  Same rules as the RdvMedecins server ("Create a patient account" form):
  title in the list, first name and last name required (20 characters at most),
  login in lower case, password of at least 6 characters, confirmation.

  WARNING: this validation is only a COMFORT for the user (an
  immediate answer, without a round trip to the server). It protects
  nothing: anyone can send the server a request built by
  hand (curl...). The server therefore ALWAYS revalidates everything (see example 20).
  =========================================================================
-->
<script setup lang="ts">
import { computed, reactive, ref } from 'vue';

const TITLES = ['Mr', 'Mme', 'Melle'];
const LOGIN_FORMAT = /^[a-z0-9._-]{1,30}$/;
const PASSWORD_MIN = 6;

type Field = 'title' | 'firstName' | 'lastName' | 'login' | 'password' | 'confirmation';

const input = reactive<Record<Field, string>>({
  title: 'Mr',
  firstName: '',
  lastName: '',
  login: '',
  password: '',
  confirmation: '',
});

// die Felder, die der Benutzer bereits verlassen hat (blur-Ereignis)
const touched = reactive(new Set<Field>());
const submitAttempted = ref(false);
const success = ref(false);

// der Fehler jedes Feldes ('' = kein Fehler), bei jedem Tastendruck neu berechnet
const errors = computed<Record<Field, string>>(() => ({
  title: TITLES.includes(input.title) ? '' : 'Choose a title from the list.',
  firstName: required(input.firstName, 'The first name') || maximum(input.firstName, 'The first name', 20),
  lastName: required(input.lastName, 'The last name') || maximum(input.lastName, 'The last name', 20),
  login:
    required(input.login, 'The login') ||
    (LOGIN_FORMAT.test(input.login.trim())
      ? ''
      : 'Unaccented lower-case letters, digits, dot, hyphen, underscore.'),
  password:
    required(input.password, 'The password') ||
    (input.password.length < PASSWORD_MIN ? `At least ${PASSWORD_MIN} characters.` : ''),
  confirmation: input.confirmation === input.password ? '' : 'The confirmation does not match the password.',
}));

const formValid = computed(() => Object.values(errors.value).every((e) => e === ''));

function required(value: string, name: string): string {
  return value.trim() === '' ? `${name} is required.` : '';
}
function maximum(value: string, name: string, max: number): string {
  return value.trim().length > max ? `${name} must not exceed ${max} characters.` : '';
}

// der ANZUZEIGENDE Fehler eines Feldes: nur wenn es berührt wurde oder nach
// einem Absendeversuch
function visibleError(field: Field): string {
  return touched.has(field) || submitAttempted.value ? errors.value[field] : '';
}

function send(): void {
  submitAttempted.value = true;
  success.value = formValid.value;
}
</script>

<template>
  <div class="container py-4" style="max-width: 640px">
    <h1 class="h3 mb-3">Example 06 - form validation</h1>
    <!-- novalidate: the browser's own validation is disabled, to
         display OUR messages, in OUR style -->
    <form class="card p-4" novalidate @submit.prevent="send">
      <div class="mb-3">
        <label class="form-label" for="title">Title</label>
        <select id="title" v-model="input.title" class="form-select" :class="{ 'is-invalid': visibleError('title') }">
          <option v-for="t in TITLES" :key="t">{{ t }}</option>
        </select>
      </div>
      <div class="row g-3 mb-3">
        <div class="col-sm-6">
          <label class="form-label" for="firstName">First name</label>
          <!-- @blur: the user leaves the field, which becomes "touched";
               the Bootstrap class is-invalid frames it in red and makes
               the following .invalid-feedback appear -->
          <input id="firstName" v-model="input.firstName" class="form-control"
                 :class="{ 'is-invalid': visibleError('firstName') }" @blur="touched.add('firstName')">
          <div class="invalid-feedback">{{ visibleError('firstName') }}</div>
        </div>
        <div class="col-sm-6">
          <label class="form-label" for="lastName">Last name</label>
          <input id="lastName" v-model="input.lastName" class="form-control"
                 :class="{ 'is-invalid': visibleError('lastName') }" @blur="touched.add('lastName')">
          <div class="invalid-feedback">{{ visibleError('lastName') }}</div>
        </div>
      </div>
      <div class="mb-3">
        <label class="form-label" for="login">Login</label>
        <input id="login" v-model="input.login" class="form-control" autocomplete="username"
               :class="{ 'is-invalid': visibleError('login'), 'is-valid': touched.has('login') && !errors.login }"
               @blur="touched.add('login')">
        <div class="invalid-feedback">{{ visibleError('login') }}</div>
      </div>
      <div class="row g-3 mb-4">
        <div class="col-sm-6">
          <label class="form-label" for="password">Password</label>
          <input id="password" v-model="input.password" type="password" class="form-control" autocomplete="new-password"
                 :class="{ 'is-invalid': visibleError('password') }" @blur="touched.add('password')">
          <div class="invalid-feedback">{{ visibleError('password') }}</div>
        </div>
        <div class="col-sm-6">
          <label class="form-label" for="confirmation">Confirmation</label>
          <input id="confirmation" v-model="input.confirmation" type="password" class="form-control" autocomplete="new-password"
                 :class="{ 'is-invalid': visibleError('confirmation') }" @blur="touched.add('confirmation')">
          <div class="invalid-feedback">{{ visibleError('confirmation') }}</div>
        </div>
      </div>
      <button type="submit" class="btn btn-primary">Create the account</button>
      <div v-if="submitAttempted && !formValid" class="alert alert-danger mt-3 mb-0">The form contains errors.</div>
      <div v-if="success" class="alert alert-success mt-3 mb-0">Valid form: it could be sent to the server.</div>
    </form>
  </div>
</template>
  • Zeile 27: der Typ der Feldnamen. [Record<Field, string>] ist ein Objekt mit genau diesen Eigenschaften: Ein Tippfehler in einem Feldnamen würde zur Kompilierzeit erkannt;
  • Zeile 39: die Felder, die der Benutzer bereits verlassen hat. Ein reaktives [Set]: [touched.add(...)] aktualisiert die Seite;
  • Zeilen 44–57: die Fehler in den Feldern, bei jedem Tastendruck neu berechnet. Eine leere Zeichenkette bedeutet „kein Fehler“; [a || b] liefert [b] , wenn [a] leer ist: So können wir die Prüfungen eines Feldes verketten, wobei die erste fehlgeschlagene die Meldung auslöst;
  • Zeile 59: wahr, wenn es keine Fehler gibt;
  • Zeilen 70–72: Der Fehler eines Feldes wird nur angezeigt, wenn es „berührt“ wurde oder nach einem Sendeversuch. Ein leeres Formular, das rot markiert ist, bevor man überhaupt angefangen hat, wäre unangenehm;
  • Zeile 85: [novalidate] deaktiviert die Prüfungen des Browsers (Attribut [required]...), sodass nur unsere Meldungen in unserem Stil angezeigt werden;
  • Zeile 99: das Ereignis [blur]: Der Benutzer verlässt das Feld;
  • Zeile 99: Die [Bootstrap]-Klasse [is-invalid] umrandet das Feld rot und zeigt das darauf folgende [<div class="invalid-feedback">] an;
  • Zeile 112: [is-valid] umrandet es umgekehrt grün.

Nach einem Klick auf „Konto erstellen“ ist das Formular leer:

Image

dann, nachdem das Formular korrekt ausgefüllt wurde:

Image

Ein wichtiger Hinweis: Diese Validierung ist lediglich eine Annehmlichkeit. Sie reagiert sofort, ohne Hin- und Rückweg zum Server, bietet aber keinerlei Schutz: Jeder kann eine von Hand gebaute Anfrage an den Server senden (zum Beispiel mit [curl]), ohne unsere Seiten zu durchlaufen. Der Server muss daher alles, was er empfängt, erneut validieren. In Beispiel 20 und später in der Fallstudie betrachten wir einen anderen Ansatz: Die Validierung und die Anzeige der Meldungen übernimmt der Server.