Comment utiliser l'attribut calculé dans Vue

Cette fois, je vais vous montrer comment utiliser l'attribut calculé dans Vue. Quelles sont les précautions lors de l'utilisation de l'attribut calculé dans Vue. Voici un cas pratique, jetons un coup d'œil.

Les propriétés calculées dans Vue sont appelées propriétés calculées . Dans cette section, nous apprenons comment utiliser les propriétés calculées dans Vue ? N'oubliez pas que lorsque vous avez découvert les connaissances liées aux modèles de Vue, vous saviez que vous pouvez utiliser des expressions dans les modèles, et les expressions dans les modèles sont très pratiques, mais ce type de parcours a certaines limites. pour quelques opérations simples. Autrement dit, mettre trop de logique dans un modèle peut le rendre trop lourd et difficile à maintenir. Regardons d'abord un exemple :

<p id="app">
  <h1>{{ message.split('').reverse().join('') }}</h1>
</p>

Dans cet exemple, le modèle n’est plus simple et clair. Il faut regarder un moment pour se rendre compte qu'ici on veut afficher lachaîne inversée du message variable. Cela devient plus difficile à gérer lorsque vous souhaitez référencer la chaîne inversée ici plusieurs fois dans le modèle.

C'est pourquoi, pour toute logique complexe, vous devez utiliser des propriétés calculées. Découvrons ensuite les propriétés calculées dans Vue.

Les propriétés calculées peuvent être utilisées pour calculer rapidement les propriétés affichées dans une vue. Ces calculs seront mis en cache et mis à jour uniquement en cas de besoin.

Il existe plusieurs façons de définir des valeurs pour les vues dans Vue :

• Utilisez des directives pour lier les valeurs de données directement aux vues

• Utilisez des expressions simples pour effectuer des transformations simples sur le contenu

• Utilisez filtresFacile conversion de contenu

En dehors de cela, nous pouvons également utiliser des propriétés calculées pour calculer la valeur d'affichage en fonction d'une valeur ou d'un ensemble de valeurs dans le modèle de données.

Propriété calculée

Les propriétés calculées nous permettent d'effectuer des calculs de valeurs complexes sur une vue spécifiée. Ces valeurs seront liées aux valeurs de dépendance et mises à jour uniquement en cas de besoin.

Par exemple, nous pourrions avoir un tableau de résultats dans le modèle de données :

data () {
  return {
    results: [
      {
        name: 'English',
        marks: 70
      },
      {
        name: 'Math',
        marks: 80
      },
      {
        name: 'History',
        marks: 90
      }
    ]
  }
}

Supposons que nous souhaitions voir le nombre total de tous les sujets. Nous ne pouvons pas utiliser de filtres ou d'expressions pour accomplir cette tâche.

• filtres : utilisés pour les formats de données simples, qui sont nécessaires à plusieurs endroits de l'application.

• expressions : ne permettent pas l'utilisation d'opérations de flux ou d'autres logiques complexes. Ils devraient garder les choses simples

À l’heure actuelle, les propriétés calculées peuvent s’avérer utiles. Nous pouvons ajouter une valeur calculée au modèle comme suit :

computed: {
  totalMarks: function () {
    let total = 0
    let me = this
    for (let i = 0; i < me.results.length; i++) {
      total += parseInt(me.results[i].marks)
    }
    return total
  }
}

L'attribut calculé totalMarks utilise les marques des résultats du tableau pour calculer la valeur totale. Il parcourt simplement les valeurs et renvoie le sous-total.

On peut alors afficher la valeur calculée dans la vue :

<p id="app">
  <p v-for="subject in results">
    <input v-model="subject.marks">
    <span>Marks for {{ subject.name }}: {{ subject.marks }}</span>
  </p>
  <p>
    Total marks are: {{ totalMarks }}
  </p>
</p>

Propriétés calculées vs méthodes

Nous pouvons utiliser la méthode de Vue pour calculer le score total du sujet, et le résultat total final sera le même.

Sur la base de l'exemple ci-dessus, nous déplaçons la fonction totalMarks dans le bloc calculé vers les méthodes. Remplacez également {{ totalMarks }} par {{ totalMarks() }} dans le modèle. Vous finissez par voir le même résultat, comme indiqué ci-dessous :

let app = new Vue({
 el: '#app',
 data () {
  return {
   results: [
    {
     name: '英语',
     marks: 70
    },
    {
     name: '数学',
     marks: 80
    },
    {
     name: '历史',
     marks: 90
    }
   ]
  }
 },
 methods: {
  totalMarks: function () {
   let total = 0
   let me = this
   for (let i = 0; i < me.results.length; i++) {
    total += parseInt(me.results[i].marks)
   }
   return total
  }
 }
})

Bien que les résultats de ces deux méthodes soient les mêmes, les performances subiront un coup dévastateur. Avec cette approche, la méthode totalMarks() est exécutée une fois à chaque fois que la page est rendue (par exemple, à chaque changement).

Si nous avons une propriété calculée, alors Vue se souviendra de la valeur dont dépend la propriété calculée (dans notre cas, c'est-à-dire les résultats ). En faisant cela, Vue ne peut calculer les valeurs que lorsque les dépendances changent. Sinon, la valeur précédemment mise en cache sera renvoyée. Cela signifie également que tant que les résultats n'ont pas changé, plusieurs visites La propriété calculée totalMarks renvoie immédiatement le résultat du calcul précédent sans avoir à réexécuter la fonction.

Les deux exemples ci-dessus illustrent également que dans Vue, les propriétés calculées sont mises en cache en fonction de leurs dépendances, mais les méthodes ne sont pas mises en cache en fonction de leurs dépendances. Ainsi, l’utilisation de propriétés calculées offre de meilleures performances que les méthodes.

Cela signifie également que la propriété calculée suivante ne sera plus mise à jour car Date.now() n'est pas une dépendance réactive :

computed: {
  now: function () {
    return Date.now()
  }
}

相比之下，每当触发重新渲染时，方法的调用方式将总是再次执行函数。因此，函数必须是一个纯函数。它不能有副作用。输出只能依赖于传递给函数的值。

那么我们为什么需要缓存？假设我们有一个性能开销比较大的的计算属性 A ，它需要遍历一个极大的数组和做大量的计算。然后我们可能有其他的计算属性依赖于 A 。如果没有缓存，我们将不可避免的多次执行 A 的 getter ！如果你不希望有缓存，请用方法来替代。

计算属性的 setter

计算属性默认只有 getter ，不过在需要时你也可以提供一个 setter ：

computed: {
  fullName: {
    // getter
    get: function () {
      return this.firstName + ' ' + this.lastName
    },
    // setter
    set: function (newValue) {
      var names = newValue.split(' ')
      this.firstName = names[0]
      this.lastName = names[names.length - 1]
    }
  }
}

你在输入框中输入一个 fullName ，然后点击 set 按钮，可以看到对应的效果。你现在再运行 app.fullName="Airen liao" 时，计算属性的 setter 会被调用， app.firstName 和 app.lastName 也相应地会被更新。

观察者

虽然计算属性在大多数情况下更合适，但有时候也需要一个自定义的 watcher 。这是为什么Vue通过 watch 选项提供一个更通用的方法，来响应数据的变化。当你想要在数据变化响应时，执行异步操作或开销较大的操作，这是很有用的。

Vue确实提供了一种更通用的方式来观察和响应Vue实例上的数据变动： watch 属性 。当你有一些数据需要随着其它数据变动而变动时，你很容易滥用 watch 。然而，通常更好的想法是使用计算属性而不是命令式的 watch 回调。比如下面的示例：

<p id="app">
  {{ fullName }}
</p>
let app = new Vue({
  el: '#app',
  data () {
    return {
      firstName: 'Foo',
      lastName: 'Bar',
      fullName: 'Foo Bar'
    }
  },
  watch: {
    firstName: function (val) {
      this.fullName = val + ' ' + this.lastName
    },
    lastName: function (val) {
      this.fullName = this.firstName + ' ' + val
    }
  }
})

上面代码是命令式的和重复的。将它与计算属性的版本进行比较：

let app = new Vue({
  el: '#app',
  data () {
    return {
      firstName: 'Foo',
      lastName: 'Bar'
    }
  },
  computed: {
    fullName: function () {
      return this.firstName + ' ' + this.lastName
    }
  }
})

在Vue中使用异步计算属性

Vue中的计算属性非常好。它们允许你执行复杂的操作或数据格式，同时最大限度地执行依赖项计算的性能，只在依赖更改时更新视图。但遗憾的是，它们完全是同步的。

值得庆幸的是，有一个插件。使用vue-async-computed 包可以通地将一个 promise 的值绑定到组件属性来创建和使用组件中的异步计算属性。

我们可以在项目的根目录下通过 yarn 或 npm 来安装 vue-async-computed 插件：

# Yarn
$ yarn add vue-async-computed
# NPM
$ npm i vue-async-computed --save

接下来在你的项目中开启这个插件：

// main.js
import Vue from 'vue';
import AsyncComputed from 'vue-async-computed'
import App from 'App.vue';
Vue.use(AsyncComputed);
new Vue({
  el: '#app',
  render: h => h(App)
});

如果你和我一样，对Vue的构建工具不是很熟悉的话，我建议你使用Vue官方提供的构建工具 Vue CLI 。默认情况，它提供了五种模板，你可以根据自己喜欢的方式选择自己需要的模板即可。

确认在项目中引用 vue-async-computed 之后，咱们就可以开始使用这个插件了。使用如何使用这个插件之前，先来简单的了解一些概念。

在Vue中标准计算属性和异步属性之间有一些区别：

• 异步属性不能有 setter

• 直到 promise 的 resolve 为止，除非 default 被设置，否则该值为 null

在大多数情况下，你可以将它们视为返回 promise 的计算属性。

<!-- MyComponent.vue -->
<template>
  <!-- 在一两秒后 myResolvedValue将变成"*Fancy* Resolved Value" -->
  <h2>Asynchronous Property {{ myResolvedValue }}</h2>
</template>
<script>
  export default {
    asyncComputed: {
      myResolvedValue () {
        return new Promise((resolve, reject) => {
          setTimeout(() => resolve('*Fancy* Resolved Value!'), 1000)
        })
      }
    }
  }
</script>

使用ES7 / ES2016的 async / await ，这将变得更简单：

<!-- MyComponent.vue -->
<template>
  <!-- 在一两秒后 myResolvedValue将变成"*Fancy* Resolved Value" -->
  <h2>Asynchronous Property {{ myResolvedValue }}</h2>
</template>
<script>
  function fancinessComesLater () {
    return new Promise((resolve, reject) => {
      setTimeout(() => resolve('*Fancy* Resolved Value!'), 1000)
    })
  }
  export default {
    asyncComputed: {
      async myResolvedValue() {
        return await fancinessComesLater()
      }
    }
  }
</script>

有关于vue-async-computed 更详细的使用和介绍，可以阅读其 官网 提供的相关介绍。

总结

今天主要学习了Vue中的计算属性。在Vue中的计算属性可以让我们很好的监听多个数据或者一个数据来维护返回一个状态值，只要其中一个或多个数据发生变化，则会重新计算整个函数体，重新皇家马德里回状态值，从而更新对应的视图（View）。其次，计算属性具有缓存，相比Vue中的方法而言，性能更佳。但Vue中的计算属性都是同步的，如果需要异步我们得依赖于vue-async-computed 。

Comme je suis débutant dans Vue, je n'ai qu'une compréhension superficielle des propriétés de calcul de Vue. Si je le regarde d'un niveau plus profond, il y aura encore certains problèmes. J'espère que vous pourrez me corriger ou me faire part de votre propre expérience.

Je pense que vous maîtrisez la méthode après avoir lu le cas dans cet article. Pour des informations plus intéressantes, veuillez prêter attention aux autres articles connexes sur le site Web chinois de php !

Lecture recommandée :

Explication détaillée de l'utilisation des méthodes natives ajax get et post

Node.js injecte de gros quantités de données dans MySQL

Ajouter une fonction de retour en haut à l'aide de requireJS

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!