Skip to content

2. Primeros pasos con Vue.js

2.1. Ejemplo 01: la estructura de una aplicación Vue.js

2.1.1. El archivo package.json

El archivo [package.json] de la carpeta examples declara las bibliotecas utilizadas y los comandos del proyecto:

{
  "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"
  }
}

Repasemos este archivo:

  • Línea 6: Los archivos [JavaScript] del proyecto son módulos ES ([import] / [export]), el formato estándar de [JavaScript], que es compatible tanto con los navegadores como con [Node.js];
  • Líneas 7–11: los comandos del proyecto, que se ejecutan con [npm run <name>]:
    • [npm run dev] inicia el servidor de desarrollo de [Vite];
    • [npm run check] hace que la herramienta [vue-tsc] verifique los tipos de [TypeScript] de todos los archivos, incluidos los [.vue];
    • [npm run build] verifica los tipos y luego construye la versión de producción de los ejemplos;
  • Líneas 12–18: las bibliotecas que la aplicación necesita en el navegador: [Vue.js] mismo, su enrutador ([vue-router]), [Pinia] para el estado compartido, [vue-i18n] para los idiomas y [Bootstrap] para el formato;
  • líneas 19–26: las herramientas de desarrollo: [Vite] y su extensión para los archivos [.vue], el compilador [TypeScript] y [vue-tsc]. No forman parte de la aplicación entregada a los usuarios.

El prefijo [^] de una versión ([^3.5.22]) permite que [npm] instale una versión más reciente de la misma versión mayor (3.x.y); el prefijo [~] ([~11.3.2]) solo permite correcciones (11.3.x). La versión de [vue-i18n] está fijada intencionalmente a la serie 11.3: las versiones posteriores requieren [Node.js] 22.

2.1.2. El archivo vite.config.ts

[Vite] es la herramienta que ejecuta una aplicación [Vue.js] durante el desarrollo y luego la construye para producción. Su configuración, común a todos los ejemplos:

// =========================================================================
// vite.config.ts - la configuración de Vite, compartida por TODOS los ejemplos.
// -------------------------------------------------------------------------
// Vite es ambas cosas:
//   - un servidor de desarrollo (npm run dev): compila al vuelo los
//     archivos .vue y .ts solicitados por el navegador, y recarga la página
//     (o solo el componente modificado) en cada guardado;
//   - una herramienta de compilación (npm run build): produce, en dist/,
//     archivos .js y .css optimizados para colocar en un servidor web.
//
// Cada ejemplo es una pequeña aplicación independiente, con su propio
// index.html: 01-first-application/index.html, 02-reactivity/index.html...
// Un único servidor Vite los sirve todos: http://localhost:5173/ muestra la
// tabla de contenido (index.html de esta carpeta), http://localhost:5173/01-first-application/
// el primer ejemplo, etc.
// =========================================================================

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));

// las carpetas de ejemplos: aquellas cuyo nombre comienza con dos dígitos
const examples = readdirSync(root).filter((d) => /^\d\d-/.test(d) && existsSync(resolve(root, d, 'index.html')));

export default defineConfig({
  // el plugin que enseña a Vite a compilar los archivos .vue
  plugins: [vue()],

  server: {
    port: 5173,
    // el PROXY: toda solicitud del navegador a /api/... es reenviada por
    // Vite al servidor JSON de RdvMedecins (puerto 8080), y luego la respuesta vuelve
    // al navegador. Para el navegador, la página y la API tienen así el MISMO origen
    // (http://localhost:5173): no hay que configurar CORS, y la cookie del
    // token JWT viaja con normalidad (vea el capítulo sobre la caja negra).
    proxy: {
      '/api': 'http://localhost:8080',
    },
  },

  // npm run build: una página HTML de entrada por ejemplo, más la tabla de contenido
  build: {
    rollupOptions: {
      input: Object.fromEntries([
        ['contents', resolve(root, 'index.html')],
        ...examples.map((d) => [d, resolve(root, d, 'index.html')]),
      ]),
    },
  },
});
  • línea 31: la extensión que indica a [Vite] que compile los archivos [.vue]. Un navegador no puede leer un archivo [.vue]: cuando lo solicita, [Vite] lo convierte sobre la marcha en un archivo [JavaScript] estándar;
  • línea 34: el puerto del servidor de desarrollo;
  • líneas 40–41: el proxy, que solo se usará a partir del Ejemplo 17: toda solicitud del navegador a una dirección que comience con [/api] se reenvía al servidor JSON [RdvMedecins], en el puerto 8080. Volveremos sobre esto;
  • Líneas 27 y 46–53: [npm run build] debe conocer todas las páginas de entrada de la aplicación. Se le proporciona el índice y el archivo [index.html] de cada carpeta cuyo nombre comienza con dos dígitos.

2.1.3. Los archivos tsconfig.json y 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"]
}
  • Línea 2: Usamos la configuración de [TypeScript] recomendada para [Vue.js] (paquete [@vue/tsconfig]): código moderno, modo estricto, verificación de tipos en el navegador (DOM);
  • Línea 4: Tipos específicos de [Vite] (por ejemplo, al importar un archivo [.css] o [.svg] );
  • Líneas 5–7: Una variable o un parámetro sin usar se reporta como un error;
  • línea 8: los archivos que se deben verificar: los de las carpetas [src] de los ejemplos y la carpeta [common].

El archivo [env.d.ts] contiene una sola directiva, que hace visibles en el editor los mismos tipos que en [Vite] :

// los tipos específicos de Vite (importación de archivos .css, import.meta.env...)
/// <reference types="vite/client" />

2.1.4. La página index.html

Cada ejemplo tiene su propia página HTML. La página del Ejemplo 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>
  <!-- la aplicación Vue.js se muestra en este elemento (vea src/main.ts) -->
  <div id="app"></div>
  <script type="module" src="./src/main.ts"></script>
</body>
</html>

Esta es la única página que cargará el navegador. Está casi vacía:

  • línea 10: el elemento en el que [Vue.js] mostrará la aplicación;
  • línea 11: el programa de la aplicación. [Vite] lo compila y lo envía al navegador como [JavaScript].

2.1.5. El punto de entrada: main.ts

// =========================================================================
// 01-first-application/src/main.ts - el punto de entrada de la aplicación
// -------------------------------------------------------------------------
// index.html carga este archivo (<script type="module" src="./src/main.ts">).
// Construye la aplicación Vue.js a partir de su componente RAÍZ (App.vue)
// y la muestra en el elemento <div id="app"> de la página.
// =========================================================================

import { createApp } from 'vue';
// la hoja de estilos de Bootstrap: Vite la inserta en la página
import 'bootstrap/dist/css/bootstrap.min.css';
import App from './App.vue';

// createApp(App): una aplicación cuyo componente raíz es App;
// mount('#app'): su renderizado HTML reemplaza el contenido de <div id="app">
createApp(App).mount('#app');
  • Línea 9: la función de [Vue.js] que crea una aplicación;
  • línea 11: una hoja de estilos, [CSS], se importa tal como se importaría un módulo. [Vite] la inserta en la página;
  • línea 12: el componente raíz de la aplicación, definido en el archivo [App.vue];
  • línea 16: la aplicación se crea a partir de este componente y luego se “monta” en el elemento [<div id="app">]: el HTML producido por [App.vue] reemplaza su contenido.

2.1.6. El componente raíz: App.vue

<!--
  =========================================================================
  01-first-application/src/App.vue - un primer componente
  -------------------------------------------------------------------------
  Un archivo .vue (Single File Component) agrupa las tres facetas de un
  componente:
    - <script setup>: los datos y el código del componente (TypeScript);
    - <template>    : el HTML a mostrar, con {{ ... }};
    - <style>       : su CSS (aquí "scoped": solo se aplica a él).
  =========================================================================
-->
<script setup lang="ts">
import { ref } from 'vue';

// datos "ordinarios": la plantilla puede mostrarlos
const title = 'Welcome to Vue.js';
const languages = ['TypeScript', 'HTML', 'CSS'];

// ref(...): un dato REACTIVO. Cuando su valor (.value) cambia, Vue
// actualiza AUTOMÁTICAMENTE los lugares de la página que lo muestran
const counter = ref(0);
const time = ref(new Date().toLocaleTimeString());

// una función llamada por el botón de la plantilla
function increment(): void {
  counter.value++;
  time.value = new Date().toLocaleTimeString();
}
</script>

<template>
  <div class="container py-4">
    <!-- {{ expression }}: el valor de la expresión, insertado en la página -->
    <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: la función a llamar al hacer clic (vea el ejemplo 04) -->
    <button class="btn btn-primary" @click="increment">Click me</button>
    <!-- en la plantilla, sin .value: Vue "desenvuelve" los refs por sí mismo -->
    <p class="mt-3 counter">You clicked {{ counter }} times (last click: {{ time }}).</p>
  </div>
</template>

<style scoped>
/* "scoped": esta regla solo se aplica a los elementos de ESTE componente */
.counter {
  font-weight: bold;
  color: #0d6efd;
}
</style>

Un archivo [.vue] (Single File Component, o SFC) combina las tres facetas de un componente:

  • líneas 12–29: el código del componente, en [TypeScript] ([lang="ts"]). Con [setup], todas las variables y funciones declaradas en el nivel superior del script se pueden usar directamente en la plantilla;
    • líneas 16–17: dos datos ordinarios;
    • línea 21: [ref(0)] crea un dato reactivo con un valor inicial de 0. Su valor se lee y se modifica mediante su propiedad [value]. Cuando cambia, [Vue.js] actualiza todos los lugares de la página donde se muestra;
    • líneas 25–27: una función que modifica dos datos reactivos. No altera la página: [Vue.js] la actualizará;
  • líneas 31–43: el HTML del componente:
    • línea 34: la sintaxis [{{ expression }}] (las “llaves dobles”) inserta en la página el valor de una expresión [TypeScript]. Se escapa: si [title] contuviera [<b>], [<b>] se mostraría sin que la etiqueta se interprete;
    • línea 36: la expresión puede ser cualquier cosa: una llamada a un método, un cálculo;
    • línea 39: al hacer clic en el botón se llama a la función [increment] (véase el ejemplo 04);
    • línea 41: en la plantilla, se escribe [counter], no [counter.value]: [Vue.js] “desempaqueta” automáticamente el [ref];
  • líneas 45–51: el CSS del componente. Con [scoped], sus reglas se aplican solo a los elementos de este componente: [Vite] agrega un atributo único a sus elementos ([data-v-xxxx]) y lo incluye en los selectores.

2.1.7. Ejecución

Con el servidor de [Vite] en ejecución ([npm run dev]), abra la URL http://localhost:5173/01-first-application/ y haga clic en el botón tres veces:

Image

Dos experimentos para probar:

  • Edite el texto del título en [App.vue] y guarde el archivo: la página se actualiza de inmediato, sin recargarse, y el contador conserva su valor. Este es el reemplazo en caliente de módulos (HMR, [Hot Module Replacement]) de [Vite];
  • Vea el código fuente de la página (Ctrl-U): solo contiene la página [index.html], que está casi vacía. El HTML mostrado fue generado por [Vue.js] dentro del navegador. Para verlo, utilice el inspector de las herramientas de desarrollo (F12, pestaña Elements) o la extensión [Vue.js devtools], que también muestra los componentes y sus datos.

2.2. Ejemplo 02: reactividad

La reactividad está en el corazón de [Vue.js]. Este ejemplo calcula el precio con IVA de un artículo:

<!--
  =========================================================================
  02-reactivity/src/App.vue - ref, reactive, computed, watch
  -------------------------------------------------------------------------
  Una pequeña calculadora de precios con IVA incluido:
    - ref      : un valor reactivo simple (un número, una cadena...);
    - reactive : un OBJETO reactivo (todas sus propiedades son reactivas);
    - computed : un valor CALCULADO a partir de otros, recalculado
                 automáticamente cuando estos cambian;
    - watch    : código ejecutado cuando un valor cambia (un "efecto").
  =========================================================================
-->
<script setup lang="ts">
import { computed, reactive, ref, watch } from 'vue';

// ref: su valor se lee y se escribe mediante .value (en el código TypeScript)
const quantity = ref(1);

// reactive: un objeto cuyas propiedades se leen y se escriben directamente
const item = reactive({
  label: 'Pen',
  priceExclVat: 2.5,
  vatRate: 20, // en %
});

// computed: nunca se asigna directamente, siempre se recalcula. Vue sabe de
// qué datos depende (quantity, item.priceExclVat, item.vatRate):
// lo recalcula cuando uno de ellos cambia, y solo en ese caso
const totalExclVat = computed(() => quantity.value * item.priceExclVat);
const vatAmount = computed(() => (totalExclVat.value * item.vatRate) / 100);
const totalInclVat = computed(() => totalExclVat.value + vatAmount.value);

// un formateador de importes en euros, estilo inglés (€1,234.50)
const euros = new Intl.NumberFormat('en-US', { style: 'currency', currency: 'EUR' });

// watch: en cada cambio del total con IVA, guardamos un registro
const history = ref<string[]>([]);
watch(totalInclVat, (newValue, oldValue) => {
  history.value.unshift(`${euros.format(oldValue)} -> ${euros.format(newValue)}`);
  history.value = history.value.slice(0, 5); // los últimos 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 enlaza un campo con un dato, en ambos sentidos (vea el ejemplo 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>
  • línea 17: [ref] acepta un valor simple (número, cadena, booleano);
  • líneas 20–24: [reactive] hace reactivo un objeto completo: cada una de sus propiedades es reactiva. Se leen y se escriben directamente ([item.priceExclVat]), sin [.value];
  • líneas 29–31: [computed] define un valor calculado a partir de otros valores. [Vue.js] registra los datos leídos durante el cálculo ([quantity], [item.priceExclVat]...) y solo vuelve a calcular cuando uno de ellos cambia. Nunca se le asigna un valor: se lee ([totalExclVat.value]);
  • línea 34: [Intl.NumberFormat], la herramienta de formato de números integrada en [JavaScript]: [2.5] se convierte en “€2.50”;
  • líneas 38–41: [watch] ejecuta código cada vez que cambian los datos, y recibe tanto el valor nuevo como el anterior. Se usa para acciones como guardar datos, enviar una solicitud o escribir en el almacenamiento del navegador... Para mostrar un valor derivado, preferimos [computed];
  • líneas 43–46: basta con modificar los datos; todos los campos, los totales y el historial se actualizarán en consecuencia;
  • líneas 58–64: [v-model] vincula cada campo a un dato, en ambas direcciones (véase el ejemplo 05);
  • línea 77: en la plantilla, un [computed] se usa de la misma manera que un [ref], sin [.value];
  • línea 86: una lista repetida para cada elemento del arreglo [history] (véase el ejemplo 03).

Image

2.3. Ejemplo 03: directivas

Una directiva es un atributo especial de la plantilla, con el prefijo [v-], que define el comportamiento del elemento al que se aplica.

<!--
  =========================================================================
  03-directives/src/App.vue - las directivas básicas
  -------------------------------------------------------------------------
  Una DIRECTIVA es un atributo especial de la plantilla, con el prefijo v-:
    - v-bind:attr="expr" (forma corta :attr="expr"): el valor de un atributo
      HTML calculado por una expresión; :class y :style aceptan
      objetos y arreglos;
    - v-if / v-else-if / v-else: el elemento solo existe en la página si
      la condición es verdadera;
    - v-show: el elemento siempre existe, solo se oculta (display:none);
    - v-for="x in list": el elemento se repite para cada x, con una
      :key única que permite a Vue seguir cada fila.
  =========================================================================
-->
<script setup lang="ts">
import { computed, ref } from 'vue';
// importar una imagen: Vite proporciona su URL (y, en producción, una
// copia optimizada del archivo, con un nombre único)
import logoUrl from './assets/doctor.svg';

// una interfaz TypeScript describe la forma de los objetos de la lista
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(''); // texto buscado
const onlyAvailable = ref(false);
const showHelp = ref(true);

// la lista mostrada: un computed, recalculado cuando cambia el filtro
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: el valor del atributo src es el de la variable 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: el párrafo permanece en la página, simplemente oculto -->
    <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: solo uno de los tres bloques existe a la vez -->
    <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: una fila por médico; (m, index) también da la posición.
             :key="m.id": la identidad de cada fila, para que Vue sepa
             qué fila agregar, mover o quitar cuando cambia la lista -->
        <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 con un arreglo: varias clases, una de ellas calculada -->
            <span :class="['badge', m.available ? 'text-bg-success' : 'text-bg-secondary']">
              {{ m.available ? 'available' : 'unavailable' }}
            </span>
          </td>
        </tr>
      </tbody>
    </table>

    <!-- :style con un objeto: propiedades CSS calculadas -->
    <p :style="{ fontSize: 12 + displayedDoctors.length * 2 + 'px' }">
      {{ displayedDoctors.length }} doctor(s) displayed - the size of this text depends on it.
    </p>
  </div>
</template>
  • Línea 23: Una interfaz de [TypeScript] describe el formato de los objetos de la lista; [ref<Doctor[]>(...)] especifica el tipo de dato;
  • línea 20: una imagen se importa como un módulo. [Vite] proporciona su dirección; en producción, creará una copia con un nombre único (que cambia con su contenido: los navegadores nunca conservarán una versión antigua en la caché);
  • línea 43: la lista mostrada, filtrada por el campo de entrada y la casilla de verificación;
  • línea 56: [v-bind:src="expression"], abreviado como [:src="expression"], asigna el valor de una expresión al atributo [src]. Sin los dos puntos, [src="logoUrl"] se referiría a un archivo llamado “logoUrl”;
  • línea 71: [v-show] oculta el elemento ([display: none]) cuando la condición es falsa. El elemento permanece en la página;
  • Líneas 76–78: [v-if], [v-else-if], y [v-else]: solo uno de estos tres elementos existe en la página en un momento dado. Elegimos [v-show] para un elemento que se muestra y se oculta con frecuencia, y [v-if] en los demás casos;
  • Línea 86: [v-for] repite el elemento para cada médico; [index] es su posición (comenzando en 0). El atributo [:key="m.id"] da a cada fila una identidad: cuando la lista cambia, [Vue.js] sabe qué filas agregar, eliminar o mover, en lugar de reconstruirlo todo desde cero. Una clave debe ser única y estable: usamos el identificador del objeto, nunca su posición;
  • línea 86: [:class] con un objeto: la clase [text-muted] se agrega si la condición es verdadera;
  • línea 92: [:class] con un arreglo: varias clases, entre ellas una calculada;
  • línea 101: [:style] con un objeto de propiedades [CSS] calculadas (en [camelCase]).

Image

Con un filtro que no devuelve resultados, se muestra el párrafo [v-else-if]:

Image

2.4. Ejemplo 04: eventos

<!--
  =========================================================================
  04-events/src/App.vue - reaccionar a las acciones del usuario
  -------------------------------------------------------------------------
  v-on:event="handler" (forma corta @event="handler"):
    - @click="f"          llama a f(nativeEvent);
    - @click="f(3, $event)" llama a f con argumentos; $event es
                          el evento nativo del navegador;
    - modificadores: @submit.prevent (impide el envío clásico del
      formulario), @keyup.enter (solo la tecla Enter), @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}`);
}

// llamada por @submit.prevent: el navegador NO envía el formulario al
// servidor (sin recarga de página), es nuestro código el que actúa
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: el evento nativo (aquí un MouseEvent), con sus coordenadas
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: Enter en el campo O clic en el botón -->
    <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>
        <!-- un manejador con un argumento: la tarea de ESTA fila -->
        <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>
  • Línea 62: [v-on:submit], abreviado como [@submit], escucha el evento [submit] del formulario (al presionar Enter en un campo o hacer clic en un botón). El modificador [.prevent] llama a [event.preventDefault()]: el navegador NO envía el formulario al servidor ni recarga la página; la función [add] es la que se ejecuta;
  • línea 63: un modificador de tecla: solo al presionar Esc se activa el manejador. Es una instrucción simple escrita en la plantilla;
  • línea 69: un manejador puede ser una llamada a una función con argumentos;
  • línea 72: Cada botón pasa SU tarea a [remove];
  • línea 76: [$event] hace referencia al evento nativo del navegador —en este caso, un [MouseEvent]— junto con las coordenadas del clic;
  • líneas 36–43: agregar una tarea consiste en agregar un objeto al arreglo reactivo; vaciar el campo consiste en vaciar el dato al que está vinculado;
  • líneas 46–47: el arreglo se reemplaza por una copia filtrada. [Vue.js] detecta tanto las modificaciones “en el lugar” ([push], [splice]) como el reemplazo completo.

Image

2.5. Ejemplo 05: campos de formulario

Es el mismo formulario que el Ejemplo 18 del curso [NestJS], pero aquí todo ocurre en el navegador:

<!--
  =========================================================================
  05-forms/src/App.vue - todos los tipos de campo, enlazados con v-model
  -------------------------------------------------------------------------
  v-model="data" enlaza un campo de formulario con un dato reactivo, en
  AMBAS direcciones: escribir en el campo modifica el dato, y modificar el
  dato (por código) modifica el campo. El dato recibido depende del campo:
    - text input, textarea              -> string
    - input + .number                   -> number
    - checkbox único                   -> boolean
    - checkboxes sobre el mismo arreglo      -> string[] (los valores marcados)
    - radio buttons                     -> el valor del botón elegido
    - select / select multiple          -> el valor / un arreglo de valores
    - input type="date"                 -> string "yyyy-MM-dd"
  Modificadores: .trim (se quitan los espacios), .number, .lazy (se actualiza al
  salir del campo en lugar de con cada tecla).
  Mismo formulario que el ejemplo 18 del curso de NestJS; pero aquí, sin
  servidor: todo ocurre en el navegador.
  =========================================================================
-->
<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' },
];

// todos los valores del formulario, en UN solo objeto reactivo
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: lo que enviaríamos a un servidor (vea el ejemplo 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>
          <!-- botones de radio: el mismo v-model, un valor por botón -->
          <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 " se convierte en "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: el dato recibe un número, no la cadena "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">
          <!-- una sola casilla de verificación: 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>
          <!-- varias casillas de verificación sobre el mismo arreglo: los valores marcados -->
          <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: el valor transmitido (el código), siendo el texto mostrado el nombre -->
              <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 }} muestra el objeto en formato JSON -->
        <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>
  • Líneas 33–43: todos los valores del formulario, en un objeto reactivo. Las anotaciones [as string[]] indican a [TypeScript] el tipo de los arreglos, que no se puede inferir a partir de [[]];
  • línea 62: los botones de opción comparten el mismo [v-model]; el dato recibe el valor ([:value]) del botón seleccionado;
  • línea 70: el modificador [.trim] elimina los espacios al inicio y al final;
  • línea 75: [.number] convierte la entrada en un número. Sin él, el dato tomaría la cadena ["30"]: un campo HTML contiene solo texto;
  • línea 84: una casilla de verificación por sí sola devuelve un valor booleano;
  • Línea 91: varias casillas de verificación vinculadas al mismo arreglo: este contiene los valores de las casillas marcadas;
  • línea 100: en una lista desplegable, [:value] es el valor transmitido (el código del país); el texto de la opción es simplemente su etiqueta;
  • línea 105: una lista de selección múltiple produce un arreglo;
  • línea 114: un campo de fecha devuelve una cadena ["yyyy-MM-dd"], sin importar cómo la muestre el navegador;
  • línea 122: [{{ object }}] muestra un objeto en formato JSON: se puede ver cómo cambia la plantilla con cada pulsación de tecla;
  • línea 49: [JSON.stringify(form, null, 2)] genera el texto JSON de un objeto, con sangría de 2 espacios. Esto es lo que se enviaría a un servidor (véase el Ejemplo 18).

Image

2.6. Ejemplo 06: validación de formularios

Usaremos las reglas del formulario “Crear una cuenta de paciente” del servidor [RdvMedecins] y las verificaremos en el navegador mientras el usuario escribe:

<!--
  =========================================================================
  06-validation/src/App.vue - validación de un formulario en el navegador
  -------------------------------------------------------------------------
  Los errores son valores COMPUTADOS: se recalculan con cada pulsación de tecla.
  No se muestran de inmediato (un formulario vacío cubierto de rojo es
  desagradable): solo para un campo que ya se abandonó ("touched"), o para
  todos los campos después de un intento de envío.

  Same rules as the RdvMedecins server ("Create a patient account" form):
  título de la lista, nombre y apellido obligatorios (máximo 20 caracteres),
  login en minúsculas, contraseña de al menos 6 caracteres, confirmación.

  ADVERTENCIA: esta validación es solo una COMODIDAD para el usuario (una
  respuesta inmediata, sin un viaje de ida y vuelta al servidor). No protege
  nada: cualquiera puede enviar al servidor una solicitud construida
  a mano (curl...). Por lo tanto, el servidor SIEMPRE vuelve a validar todo (vea el ejemplo 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: '',
});

// los campos que el usuario ya abandonó (evento blur)
const touched = reactive(new Set<Field>());
const submitAttempted = ref(false);
const success = ref(false);

// el error de cada campo ('' = sin error), recalculado en cada pulsación de tecla
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.` : '';
}

// el error a MOSTRAR para un campo: solo si ha sido tocado, o después de
// un intento de envío
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: la validación propia del navegador se desactiva, para
         mostrar NUESTROS mensajes, con NUESTRO estilo -->
    <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: el usuario abandona el campo, que pasa a ser "touched";
               la clase de Bootstrap is-invalid lo enmarca en rojo y hace
               aparecer el .invalid-feedback siguiente -->
          <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>
  • Línea 27: el tipo de los nombres de los campos. [Record<Field, string>] es un objeto con exactamente estas propiedades: un error tipográfico en el nombre de un campo se detectaría en tiempo de compilación;
  • línea 39: los campos que el usuario ya ha abandonado. Un [Set] reactivo: [touched.add(...)] actualiza la página;
  • líneas 44–57: los errores de los campos, recalculados con cada pulsación de tecla. Una cadena vacía significa “sin error”; [a || b] devuelve [b] cuando [a] está vacío: esto permite encadenar las verificaciones de un campo, de modo que la primera que falle active el mensaje;
  • línea 59: verdadero si no hay errores;
  • líneas 70–72: el error de un campo se muestra solo si ha sido “tocado”, o después de un intento de envío. Un formulario en blanco resaltado en rojo antes de haber empezado sería desagradable;
  • línea 85: [novalidate] desactiva los controles del navegador (atributo [required]...), de modo que solo se muestren nuestros mensajes, con nuestro estilo;
  • línea 99: el evento [blur]: el usuario abandona el campo;
  • línea 99: la clase [Bootstrap] [is-invalid] enmarca el campo en rojo y muestra el [<div class="invalid-feedback">] que le sigue;
  • línea 112: [is-valid], por el contrario, lo enmarca en verde.

Después de hacer clic en “Crear la cuenta”, el formulario queda vacío:

Image

luego, una vez que el formulario se ha llenado correctamente:

Image

Una nota importante: esta validación es solo una comodidad. Responde de inmediato, sin un viaje de ida y vuelta al servidor, pero no ofrece ninguna protección: cualquiera puede enviar al servidor una solicitud construida manualmente (con [curl], por ejemplo), sin pasar por nuestras páginas. Por lo tanto, el servidor debe volver a validar lo que recibe. En el Ejemplo 20, y más adelante en el caso de estudio, veremos otro enfoque: dejar que el servidor se encargue de la validación y de mostrar los mensajes.