Vue 3: Diferenzas entre revisións

De Wiki do Ciclo ASIR do IES de Rodeira
Saltar á navegación Saltar á procura
Liña 235: Liña 235:


*'''npm install''' instalará todos os módulos JavaScript necesarios para Vue
*'''npm install''' instalará todos os módulos JavaScript necesarios para Vue
*'''npm run dev''' compilará e creará a páxina inicial do proxecto.
*'''npm run dev''' lanzará unha instancia do servidor web de Node para probar o noso proxecto. Inicialmente so aceptará conexións en localhost.

Para crear a aplicación que serviremos mediante un Apache, debemos construila con npm build e instalar o contido da carpeta build no root do sitio web. Debemos habilitar o módulo ''rewrite'' para que funcionen as rutas de Vue.


=== Controlando os Erros da Aplicación ===
=== Controlando os Erros da Aplicación ===

Revisión como estaba o 15 de outubro de 2024 ás 16:06

Introdución

Vue (pronunciado /vjuː/, como view) é un framework progresivo para construír interfaces de usuario. A diferenza doutros frameworks monolíticos, Vue está deseñado dende cero para ser utilizado de maneira incremental. A biblioteca central está enfocada só na capa de visualización, e é doada de utilizar e integrar con outras bibliotecas ou proxectos existentes.

Vue dispón dun "compilador" que se encarga de transformar as plantillas de Vue en código JavaScript optimizado que utilizará o navegador para renderizar o contido. Se encarga de convertir as directrices e etiquetas Vue (como v-if, v-for) en funcións JavaScript que manipulan o DOM.

As distribucións de desenvolvemento de Vue inclúen o compilador o que permite escribir as plantillas no HTML ou en ficheiros .vue sepearados sen compilalos previamente. Unha vez rematada a aplicación se "compilan" (build) xerando a aplicación de produción.

As distribucións de produción non precisan o compilador, unicamente o "runtime", xa que a aplicación xa estará "compilada" a JavaScript.

Un exemplo de plantilla Vue sería o seguinte:

import { createApp, ref } from 'vue'

createApp({
  setup() {
    return {
      count: ref(0)
    }
  }
}).mount('#app')
template
<div id="app">
  <button @click="count++">
    Count is: {{ count }}
  </button>
</div>
</script>

Vue pode utilizar dous tipos de API diferentes:

Options API

Coa Options API, definimos a lóxica dun compoñente usando un obxecto de opcións, como data, methods e mounted. As propiedades definidas polas opcións están dispoñibles en this dentro das funcións, que apunta á instancia do compoñente:

<script>
export default {
  // Properties returned from data() become reactive state
  // and will be exposed on `this`.
  data() {
    return {
      count: 0
    }
  },

  // Methods are functions that mutate state and trigger updates.
  // They can be bound as event handlers in templates.
  methods: {
    increment() {
      this.count++
    }
  },

  // Lifecycle hooks are called at different stages
  // of a component's lifecycle.
  // This function will be called when the component is mounted.
  mounted() {
    console.log(`The initial count is ${this.count}.`)
  }
}
</script>

<template>
  <button @click="increment">Count is: {{ count }}</button>
</template>

Composition API

Coa Composition API, definimos a lóxica dun compoñente usando funcións da API importadas. Nos SFCs (Single File Components), a Composition API utilízase normalmente con <script setup>. O atributo setup é unha indicación que permite a Vue realizar transformacións en tempo de compilación que nos permiten usar a Composition API con menos código repetitivo. Por exemplo, as importacións e as variables/funcións de nivel superior declaradas en <script setup> son directamente utilizables na plantilla.

Na maioría dos proxectos de Vue habilitados para ferramentas de construción, autoramos compoñentes de Vue utilizando un formato de ficheiro semellante ao HTML chamado Compoñente de Ficheiro Único (tamén coñecido como ficheiros *.vue, abreviado como SFC). Un SFC de Vue, como suxire o nome, encapsula a lóxica do compoñente (JavaScript), a plantilla (HTML) e os estilos (CSS) nun único ficheiro.

<script>
<script setup>
import { ref, onMounted } from 'vue'

// reactive state
const count = ref(0)

// functions that mutate state and trigger updates
function increment() {
  count.value++
}

// lifecycle hooks
onMounted(() => {
  console.log(`The initial count is ${count.value}.`)
})
</script>

<template>
  <button @click="increment">Count is: {{ count }}</button>
</template>

<style scoped>
button {
  font-weight: bold;
}


Ambos os estilos de API son plenamente capaces de cubrir casos de uso comúns. Son interfaces diferentes impulsadas polo mesmo sistema subxacente. De feito, a Options API está implementada sobre a Composition API. Os conceptos fundamentais e o coñecemento sobre Vue son compartidos entre os dous estilos.

Se es novo en Vue, aquí está a nosa recomendación xeral:

Para fins de aprendizaxe, escolla o estilo que lle pareza máis fácil de entender. De novo, a maioría dos conceptos básicos son compartidos entre os dous estilos. Sempre podes aprender o outro estilo máis adiante.

Para uso en produción:

  • Escolla a Options API se non está a usar ferramentas de construción, ou se planea usar Vue principalmente en escenarios de baixa complexidade, por exemplo, mellora progresiva.
  • Escolla a Composition API + Compoñentes de Ficheiro Único se planea construir aplicacións completas con Vue.

Neste documento utilizaremos principalmente Composition API.

Instalación

Existen varios modos de instalación:

Inclusión Direta con <script>

Simplemente se debe descargar e incluír a etiqueta script coa ruta correcta, ou utilizar un CDN. Por exemplo: <script src="https://unpkg.com/vue@3/dist/vue.global.prod.js"></script>. Vue tamén está dispoñible nos CDN unpkg e cdnjs.

As distribucións de Vue teñen a forma vue(.runtime).global(.prod).js, donde "runtime" conten únicamente o JavaScript necesario para executar as plantillas xa "compiladas" a JavaScript, mentres que as outras inclúen o compilador necesario para a "compilación" das plnatillas .vue.

Para o uso de módulos ES nativos e de xeito similar, a compilación de Vue a usar ten a forma vue(.runtime).esm-browser(.prod).js.

Si usamos empaquetadores como webpack, rollup ou parcel, temos as versións vue(.runtime).esm-bundler.js

As versións de produción inclúen prod;

Existen distintas compilacións de Vue:

  • Global Build: Na Global Build odas as APIs de nivel superior están expostas como propiedades no obxecto global Vue.
<script src="https://unpkg.com/vue@3/dist/vue.global.js"></script>

<div id="app">{{ message }}</div>

<script>
  const { createApp, ref } = Vue

  createApp({
    setup() {
      const message = ref('Hello vue!')
      return {
        message
      }
    }
  }).mount('#app')
</script>


  • ES Module Build: E o formato preferido para as aplicacións Vue, Utiliza módulos ECMAScript (ESM). Este enfoque permite importar Vue e outros módulos de forma máis flexible e organizada, facilitando a xestión de dependencias e a estrutura do código. Os ES Modules son compatibles co estándar moderno de JavaScript, e permiten realizar importacións e exportacións explícitas entre diferentes ficheiros. Usa a sintaxe de importación (import Vue from 'vue';), permitindo unha organización máis clara do código e un mellor control das dependencias.
<div id="app">{{ message }}</div>

<script type="module">
  import { createApp, ref } from 'https://unpkg.com/vue@3/dist/vue.esm-browser.js'

  createApp({
    setup() {
      const message = ref('Hello Vue!')
      return {
        message
      }
    }
  }).mount('#app')
</script>

Na demostración anterior, estamos importando desde a URL completa do CDN, pero no resto da documentación verás código como este:

import { createApp } from 'vue'

Podemos ensinar ao navegador onde localizar a importación de Vue utilizando *Import Maps*:

<script type="importmap">
  {
    "imports": {
      "vue": "https://unpkg.com/vue@3/dist/vue.esm-browser.js"
    }
  }
</script>

<div id="app">{{ message }}</div>

<script type="module">
  import { createApp, ref } from 'vue'

  createApp({
    setup() {
      const message = ref('Hello Vue!')
      return {
        message
      }
    }
  }).mount('#app')
</script>

Creación dunha aplicación Vue con Node

Vue proporciona un completo framework baseado en Node.js co que podemos desenvolver unha aplicación, "compilar" as plantillas e conseguir unha versión final de distribución. Para iso se empregan unha serie de utilidades (build tools) que nos axudarán nas distintas fases do proxecto. Unha desas ferramentas é Vite.

Vite é unha ferramenta de desenvolvemento de front-end moderna que se utiliza para a creación de aplicacións web rápidas e eficientes. Foi creada por Evan You, o mesmo creador de Vue.js, aínda que Vite non está limitado só a Vue, xa que tamén soporta outros frameworks como React.

A función de Vite dentro do ecosistema Vue é a "compilación" das plantillas (ES Modules) durante o desenvolvemento e a optimización final para producción.

En primeiro lugar, se debe crear a estrutura da aplicación mediante o uso de xestores de paquetes JavaScript como npm (Node Package Manager) ou yarn (Yet Another Resource Negotiator) entre outros:

npm create vue@latest

Durante a configuración inicial da aplicación o sistema nos preguntará detalles como:

  • 'o nome do proxecto
  • si imos usar TypeScript
  • si queremos JSX (unha extensión para escribir capas de presentacón dentro do JavaScript para crear interfaces demasiado complexas para as plantillas)
  • si queremos usar Vue-Router (que nos facilita a creación de SPA a través de rutas para a transición entre compoñentes para presentar o contido solicitado ao servidor)
  • si queremos usar Plinia (que nos permite compartir o estado --información-- entre distintos compoñentes da aplicación Vue)
  • si queremos usar Vitest (que é un framework para a realización de tests unitarios )
  • si queremos engadir un sistema de Testing (nos ofrece Cypress, Nightwatch ou Playwrigth)
  • si queremos usar ESLint (analiza problemas de estilo, erros de sintaxe, se xera a configuración para VSCode e podemos utilizalo dende a liña de comandos con npx eslint . ou npx eslint . --fix. Mediante npx podemos executar paquetes instalados con npm sen instalalos no sistema)
  • si queremos usar Prettier (formatea o código revisando tabuladores, espazos.. de xeito que quede lexible)
  • si queremos usar as extensións de depuración de Vue

Unha vez iniciado o proxecto o sistema nos indicará:

Done. Now run:

  cd "<proxecto>"
  npm install
  npm run dev
  • npm install instalará todos os módulos JavaScript necesarios para Vue
  • npm run dev lanzará unha instancia do servidor web de Node para probar o noso proxecto. Inicialmente so aceptará conexións en localhost.

Para crear a aplicación que serviremos mediante un Apache, debemos construila con npm build e instalar o contido da carpeta build no root do sitio web. Debemos habilitar o módulo rewrite para que funcionen as rutas de Vue.

Controlando os Erros da Aplicación

En app.config.* dispoñemos de varios elementos Vue que nos proporcionan control sobre o comportamento xeral da aplicación. Por exemplo, se poden "capturar" todos os erros sin xestionar que se produzan na aplicación mediante un código simple.

  • app.config.errorHandler: Recibe todos os errores non xestionados. O errorHandler recibe como argumentos o erro, a instancia do compoñente que lanzou o erro e un string explicativo sobre o erro
interface AppConfig {
  errorHandler?: (
    err: unknown,
    instance: ComponentPublicInstance | null,
    // `info` is a Vue-specific error info,
    // e.g. which lifecycle hook the error was thrown in
    info: string
  ) => void
}

Se utilizaría do seguinte xeito...

app.config.errorHandler = (err, instance, info) => {
  // handle error, e.g. report to a service
}
  • app.config.warnHandler: Xestiona avisos (warnings) de Vue
interface AppConfig {
  warnHandler?: (
    msg: string,
    instance: ComponentPublicInstance | null,
    trace: string
  ) => void
}

que se utilizaría do seguinte xeito:

app.config.warnHandler = (msg, instance, trace) => {
  // `trace` is the component hierarchy trace
}

Existen outros hooks que nos permiten modificar as opcions de compilación (app.config.compilerOptions.*) e rexistrar propiedades globais que se poden utilizar dende calquera punto da aplicación mediante app.config.globalProperties

interface AppConfig {
  globalProperties: Record<string, any>
}

que se utilizaría do seguinte xeito:

app.config.globalProperties.msg = 'hello'