Skip to content

5. Capítulo 4 - Introducción a [Vue.js]

5.1. Fuentes

Este capítulo se basa en la documentación oficial de [Vue.js]: vuejs.org, y en particular en su guía (vuejs.org/guide/introduction.html).

5.2. De AngularJS 1.x a [Vue.js]

El documento original (2014) utilizaba AngularJS 1.x: un framework (todavía sin TypeScript) organizado en torno a $scope, controladores, directivas (ng-repeat, ng-if…) y un mecanismo de detección de cambios basado en el “ciclo de digestión” ($digest) y la vigilancia de variables ($watch).

[Vue.js] (creado por Evan You en 2014, tras una experiencia en Google trabajando con AngularJS) es, como [Angular], un framework completo: a diferencia de [React] (una simple biblioteca de interfaces), ofrece su propio sistema de componentes, una gestión reactiva del estado y, mediante sus paquetes oficiales independientes, que no se utilizan en este documento, un enrutador ([vue-router]) y un gestor de estado global ([Pinia]). [Vue.js] se describe a sí mismo como “progresivo”: un núcleo centrado en la capa de vista (conceptualmente similar al $scope/plantilla de AngularJS 1.x), complementado por su propio formato de componentes: los archivos [.vue] (véase más abajo). Este capítulo presenta estos conceptos uno por uno, con ejemplos breves independientes del caso de estudio; el capítulo siguiente explorará su aplicación en el cliente [RdvMedecins] completo, en [Vue.js] 3.

5.3. El concepto detrás de una aplicación [Vue.js]: la “aplicación de página única”

Una aplicación [Vue.js] es, como una aplicación [Angular] o [React], una aplicación de página única (SPA): el servidor entrega al navegador una sola página HTML, que contiene un único archivo JavaScript con toda la lógica de la aplicación. Una vez cargada esta página, nunca se vuelve a recargar la página completa: cada interacción del usuario (cambio de vistas, envío de un formulario, etc.) la gestiona el código JavaScript que ya está en el navegador, el cual actualiza la pantalla y se comunica con el servidor en segundo plano mediante solicitudes HTTP asíncronas (casi siempre con JSON). Este ya era el principio del documento original con AngularJS 1.x, así como de las variantes [Angular] y [React] de este curso: no ha cambiado; solo difiere de una variante a otra el framework que se encarga de la visualización.

5.4. Los componentes: archivos [.vue] y [Composition API]

Como en [Angular] y [React], un componente es la unidad básica de una aplicación [Vue.js]: genera lo que se debe mostrar en pantalla a partir de su estado actual y de las propiedades que recibe. La diferencia está en la forma: un componente [Angular] es una clase decorada, asociada a una plantilla HTML separada (o en línea); un componente [React] es una función que devuelve [JSX]; un componente [Vue.js] es un archivo [.vue] de “archivo único” (single-file), que reúne en un solo archivo tres bloques distintos: una [<template>] (el HTML, similar al de [Angular]), un [<script setup>] (la lógica, como en TypeScript) y, opcionalmente, un [<style>] (los estilos específicos de este componente).

A continuación se muestra un componente muy pequeño, independiente del caso de estudio, equivalente a [CounterComponent] ([Angular]) y a [Counter.tsx] ([React]), que ya se presentaron en este curso:

<!-- Counter.vue -->
<script setup lang="ts">
import { ref } from 'vue';

const value = ref(0);

function increment(): void {
  value.value++;
}
</script>

<template>
  <p>Value: {{ value }}</p>
  <button @click="increment">+1</button>
</template>

Analicemos este código:

  • Línea 3: [import { ref } from 'vue';] — [ref] es la función de [Vue.js], que crea un valor reactivo: un papel comparable al de un signal en el lado de [Angular], o al de [useState] en el lado de [React];
  • Línea 5: [const value = ref(0);] — [ref(0)] crea una “caja” reactiva inicializada en 0. A diferencia de [useState]() ([React]), que devuelve un PAR (el valor y un setter), [ref()] devuelve un ÚNICO objeto, cuyo valor se lee y se escribe mediante su propiedad [.value]: un mecanismo más parecido, conceptualmente, a un [signal()] [Angular] (que se lee con [mySignal()] y se escribe con [mySignal.set(...)]) que a un par [value, setValue];
  • línea 8: [value.value++;] — modificar [.value] actualiza el valor Y vuelve a dibujar automáticamente todo lo que depende de él en [<template>], exactamente como con [mySignal.update(v => v + 1)] en el lado de [Angular]; a diferencia de [React] (donde los valores de estado son inmutables), aquí nada impide que [.value] se incremente directamente (++), sin pasar por una función de actualización separada;
  • líneas 12–13: [Value: {{ value }}] — [<template>] ES la plantilla, igual que el HTML está separado en [Angular], a diferencia de [JSX] y [React], que derivan de JavaScript y se mezclan con el código de la función del componente. Las llaves dobles [{{ }}] insertan allí una expresión; cumplen la misma función que [{{ value() }}] en [Angular] ([Vue.js] NO requiere paréntesis de llamada ([value], no [value()]): en un [<template>], un [ref] se “desempaqueta” automáticamente; nunca es necesario escribir [.value]).

5.5. El estado local: [ref]/[reactive] y las props

En AngularJS 1.x, [Angular] detectaba que un dato había cambiado mediante un ciclo de verificación sistemático ($digest), que en la variante [Angular] de este curso se reemplazó por los signals (signal(), computed()). [React] adopta un enfoque distinto: un componente vuelve a ejecutar por completo su función con cada cambio de estado. [Vue.js] adopta un tercer enfoque, híbrido: como [Angular], rastrea con precisión los valores reactivos que utiliza un componente (gracias al [<template>] compilado y al sistema de “proxy” de [ref]/[reactive]) y actualiza únicamente las partes del DOM que realmente dependen de ellos, sin volver a ejecutar nunca la totalidad del [<script setup>] y sin el costo del DOM virtual que utiliza [React] para lograr un resultado comparable.

Función
Rol
ref(initialValue)
crea un estado local con un ÚNICO valor; se lee y escribe mediante [.value] en [<script>] (nunca en [<template>])
reactive(initialObject)
crea un estado local con VARIAS propiedades (un objeto); se lee y escribe directamente, SIN [.value], propiedad por propiedad
computed(() => ...)
deriva un valor a partir de otros [ref]/[reactive], que se recalcula automáticamente solo cuando cambian sus dependencias; el equivalente directo de [computed()] en el lado de [Angular] y de [useMemo]() en el lado de [React]
watch(source, callback)
vuelve a ejecutar [callback] cada vez que [source] cambia; el equivalente de [useEffect](..., [dep]) en el lado de [React], o de [effect()] en el lado de [Angular]

Dos mecanismos complementan [ref]/[reactive] para que un componente pueda comunicarse con su padre; se encuentran sistemáticamente en el cliente [RdvMedecins] (capítulo siguiente), justo donde estaban [input()]/[output()] en el lado de [Angular], y las props/props de devolución de llamada en el lado de [React]:

  • las props ([defineProps<...>()]): un componente [Vue.js] declara el formato de sus entradas mediante [defineProps], una función especial reconocida por el compilador (no requiere ningún [import]); el equivalente directo de [input.required<Doctor[]>()] en el lado de [Angular] y de un objeto de props desestructurado en el lado de [React];
  • los eventos ([defineEmits<...>()]): en lugar de una simple función pasada como prop (la opción de [React]), [Vue.js] distingue explícitamente los eventos que emite un componente; la función [emit(‘eventName’, value)] que devuelve es el equivalente directo de [search.emit(value)] en el lado de [Angular] ([output<...>()]).

5.6. Sin módulos: cada archivo ya es autónomo

Una aplicación AngularJS 1.x se organizaba en módulos (angular.module(...)). [Angular] adoptó primero esta idea en una forma más rígida (los archivos NgModule), antes de proponer los componentes standalone como modo por defecto. Al igual que [React], [Vue.js] nunca necesitó este concepto: un archivo [.vue] exporta implícitamente su componente (el [<script setup>] ES la exportación por defecto del archivo, sin siquiera tener que indicar la palabra clave [export]), y otro archivo lo utiliza con un simple [import]: los módulos ECMAScript estándar, sin capas adicionales propias del framework:

<!-- Parent.vue -->
<script setup lang="ts">
import Counter from './Counter.vue';
</script>

<template>
  <div>
    <Counter />
  </div>
</template>

Este es el estilo que se usa en todo el cliente [RdvMedecins] (capítulo siguiente): sin archivos *.module.ts, sin decoradores [imports: [...]] que mantener; una simplificación idéntica a la que ya vimos con [React], en comparación con AngularJS 1.x y [Angular] con NgModule.

5.7. Lógica compartida: composables y [provide]/[inject]

Como en [NestJS] (Capítulo 2), el cliente [RdvMedecins] requiere lógica compartida entre varios componentes: comunicarse con el servidor, identificar al usuario conectado y cambiar de idioma. [Angular] aborda esta necesidad con servicios inyectables ([@Injectable]({ providedIn: ‘root’ }) + inject(...)); [React] combina hooks personalizados con [Context]. [Vue.js] utiliza una combinación similar a la de [React], pero con su propio vocabulario y mecanismo:

  • un composable: una función cuyo nombre, por convención, empieza con [use] (como un hook de [React]), que a su vez puede llamar a otras funciones de [Vue.js] ([ref], [inject]…), encapsula lógica reutilizable, igual que un método de servicio del lado del servidor en [Angular];
  • el par [provide]/[inject] comparte un valor (estado + funciones) con TODO el subárbol de componentes, sin tener que pasarlo manualmente, propiedad por propiedad, por cada nivel intermedio; es el papel que desempeña [providedIn: ‘root’] en el lado de [Angular] y [Context] en el lado de [React]. A diferencia de [React], que exige que un componente [Provider] esté visualmente ANIDADO en el árbol alrededor del componente raíz, [Vue.js] devuelve un valor con una única llamada de función, [app.provide(key, value)], sobre la instancia de la aplicación (véase main.ts, capítulo siguiente), sin necesidad de anidar componentes.

A continuación se muestra un breve ejemplo, independiente del caso de estudio, conceptualmente equivalente a [MyService] ([Angular]) y a [my-context.tsx] ([React]), que ya se presentaron en este curso:

// my-composable.ts
import { inject, reactive, type InjectionKey } from 'vue';

interface MyStore {
  greet: () => string;
}

const MyStoreKey: InjectionKey<MyStore> = Symbol('MyStore');

export function createMyStore(): MyStore {
  return reactive<MyStore>({
    greet: () => 'Hello',
  });
}

export function useMyStore(): MyStore {
  const store = inject(MyStoreKey);
  if (!store) {
    throw new Error('useMyStore() must be called after app.provide(MyStoreKey, ...)');
  }
  return store;
}

Analicemos este código:

  • Línea 8: [const MyStoreKey: InjectionKey<MyStore> = Symbol('MyStore');] — la clave de inyección: un [Symbol] en lugar de una simple cadena, para evitar cualquier colisión accidental con otra clave del mismo nombre; [InjectionKey<T>] es simplemente un alias de [Symbol] en el lado de los tipos, lo que permite que [inject()] determine automáticamente el tipo del valor devuelto;
  • Línea 10: [export function createMyStore(): MyStore {] — la fábrica, llamada UNA SOLA VEZ (en [main.ts]; véase el capítulo siguiente), ANTES de que exista cualquier componente; por eso recibe sus dependencias como parámetros ordinarios de la función, en lugar de mediante [inject()];
  • línea 11: [return reactive<MyStore>({] — [reactive(...)] envuelve el objeto en un proxy de JavaScript: toda lectura de una de sus propiedades en un [<template>] registra automáticamente una dependencia; toda operación de escritura vuelve a dibujar todo lo que depende de ella; a diferencia de [ref()], la propiedad ([store.greet]) se lee y se escribe directamente, sin [.value];
  • Líneas 16–22: [export function useMyStore(): MyStore { …] — el composable al que llaman los componentes ([const my = useMyStore();]), tal como habrían llamado a [inject(MyService)] de [Angular], o a [useMyContext()] de [React]; el error que se genera si [inject(MyStoreKey)] devuelve [undefined] indica una omisión en el cableado (no se llamó al [app.provide(...)] correspondiente); exactamente la misma red de seguridad que en el lado de [React] (Context es null por defecto).

5.8. Comunicarse con el servidor: [fetch]

[HttpClient] ([Angular]) fue el sucesor directo del servicio $http de AngularJS 1.x, utilizado en el documento original. Como [React], [Vue.js] es solo un framework de interfaces y, en su núcleo, no ofrece ningún cliente HTTP: el cliente [RdvMedecins] utiliza directamente [fetch], la API estándar del navegador (disponible sin ninguna dependencia adicional):

1
2
3
const httpResponse = await fetch('http://localhost:8080/hello');
const response = (await httpResponse.json()) as { message: string };
console.log(response.message);

Una diferencia importante respecto a $http y [HttpClient]: [fetch] devuelve directamente una Promise (el mecanismo asíncrono estándar de JavaScript), no un Observable: sin la biblioteca RxJS, sin [.subscribe]({ next, error }), sin [.pipe(map(...))]. Se puede utilizar con [.then(...)] o, para mayor legibilidad, con async/await (como se muestra arriba). Un error de red o una respuesta de error se trata entonces con un simple bloque try/catch, en lugar de con la rama de error de una suscripción RxJS, exactamente como en el lado de [React].

El composable [useAppointmentService()] del cliente [RdvMedecins] (capítulo siguiente) encapsula sistemáticamente esta llamada a [fetch] seguida de [.json()], por una razón específica que se explicará en ese momento (el envoltorio [ServerResponse]<T> común a todas las respuestas del servidor).

5.9. Renderizado condicional y listas: [v-if]/[v-else] y [v-for]

AngularJS 1.x utilizaba directivas estructurales (ng-if, ng-repeat) para mostrar un elemento de forma condicional o repetir un bloque de plantilla por cada elemento de una lista. La variante [Angular] de este curso utiliza la sintaxis integrada [@if]/[@for]; el cliente [React] expresa lo mismo mediante el operador ternario y [.map(...)], en JavaScript puro. [Vue.js] está, en este punto concreto, más cerca de [Angular]: su [<template>] tiene su propio “lenguaje” de directivas, muy similar en espíritu al de AngularJS 1.x (ng-if se convierte en [v-if], ng-repeat se convierte en [v-for]):

1
2
3
4
5
6
<p v-if="loggedInUser">Welcome!</p>
<p v-else>Please log in.</p>

<ul>
  <li v-for="item in itemList" :key="item.id">{{ item.name }}</li>
</ul>

Analicemos este código:

  • líneas 1–2: [v-if="loggedInUser" … v-else …] — [v-if]/[v-else] reemplazan a [@if]/[@else] ([Angular]) y a ng-if (AngularJS 1.x): solo la rama cuya condición es verdadera se MONTA en el DOM; exactamente el mismo comportamiento que el operador ternario de [React] ({ condition ? ... : ... }), pero expresado como un atributo HTML en lugar de como una expresión JavaScript anidada dentro de [JSX];
  • Línea 5: [v-for="item in itemList" :key="item.id"] — [v-for] reemplaza a [@for] ([Angular]) y a ng-repeat (AngularJS 1.x), y cumple exactamente la misma función que [.map(...)] en el lado de [React]: repite el elemento por cada entrada del arreglo. [:key] (obligatorio, al igual que [key={item.id}] en [React] y track en [Angular]) le indica a [Vue.js] cómo reconocer un elemento que ya se mostró cuando vuelve a dibujar la lista.

5.10. Resumen: equivalencias [Angular] -> [React] -> [Vue.js]

[Angular]/[React] (versiones anteriores de este curso)
[Vue.js] (2026)
Standalone components ([@Component]) / functional components ([React])
Componentes de archivo único ([.vue])
Signals (signal(), input(), output(), computed()) / [useState](), props, [useMemo]() ([React])
[ref]()/[reactive](), [defineProps]/[defineEmits], [computed]()
effect() / [useEffect]() ([React])
[watch]()
Separate template (.html) + decorator (.ts) / embedded [JSX] (.tsx) ([React])
[<template>] + [<script setup>] combinados en un mismo archivo [.vue]
[@if], [@for] / ternary operator, .map() ([React])
[v-if]/[v-else], [v-for]
Injectable services ([@Injectable]) + inject() / custom hooks + [Context] ([React])
Composables + [provide]/[inject]
[HttpClient] (RxJS Observables) / [fetch] (Promises) ([React])
[fetch] (Promises nativas, como en [React])
[@angular/router] (empty routing table) / No router ([React])
Sin enrutador (misma conclusión, llevada un paso más allá)
Angular CLI / [@angular/build] / [Vite] ([React])
[Vite] (con [@vitejs/plugin-vue] en lugar de [@vitejs/plugin-react])

Estos conceptos bastan para abordar el cliente [RdvMedecins] en el capítulo siguiente: no obstante, cada nuevo uso se volverá a explicar allí, a medida que avance el código, en el punto exacto en que aparezca.