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

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

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]).

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

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.

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

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:

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

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.