Maison > Article > interface Web > Explication détaillée des propriétés calculées de vue
Explication détaillée des propriétés calculées de vue
- php中世界最好的语言original
- 2018-04-11 13:50:231845parcourir
Cette fois, je vais vous apporter une explication détaillée des propriétés calculées de vue. Quelles sont les précautions lors de l'utilisation des propriétés calculées de vue. Voici des cas pratiques, jetons un coup d'œil.
1. Qu'est-ce qu'un attribut calculé
Les Expressions dans les modèles sont très pratiques, mais elles sont conçues pour des opérations simples. Mettre trop de logique dans un modèle peut le rendre trop lourd et difficile à maintenir. Par exemple :
<p id="example">
{{ message.split('').reverse().join('') }}
</p>
L'expression ici contient 3 opérations, ce qui n'est pas très clair, donc lorsque vous rencontrez une logique complexe, vous devez utiliser l'attribut calculé spécial de Vue calculé pour la gérer.
2. Utilisation des attributs calculés
Diverses logiques complexes peuvent être complétées dans un attribut calculé, y compris des opérations, des appels de fonction, etc., à condition qu'un résultat soit finalement renvoyé.
Réécrivons l'exemple ci-dessus en utilisant les propriétés calculées
<p id="example">
<p>Original message: "{{ message }}"</p>
<p>Computed reversed message: "{{ reversedMessage }}"</p> //我们把复杂处理放在了计算属性里面了
</p>
var vm = new Vue({
el: '#example',
data: {
message: 'Hello'
},
computed: {
reversedMessage: function () {
// `this` 指向 vm 实例
return this.message.split('').reverse().join('')
}
}
});
Résultat :
Message d'origine : "Bonjour"
Message inversé calculé : "olleH"
En plus de l'utilisation simple dans l'exemple ci-dessus, les propriétés calculées peuvent également s'appuyer sur les données de plusieurs instances de Vue. Tant que l'une des données change, les propriétés calculées seront réexécutées et la vue sera mise à jour.
<body>
<p id="app">
<button @click="add()">补充货物1</button>
<p>总价为：{{price}}</p>
</p>
</body>
var app = new Vue({
el: '#app',
data: {
package1: {
count: 5,
price: 5
},
package2: {
count: 10,
price: 10
}
},
computed: {
price: function(){
return this.package1.count*this.package1.price+this.package2.count*this.package2.price //总价随着货物或价格的改变会重新计算
}
},
methods: { //对象的方法
add: function(){
this.package1.count++
}
}
});
Il existe deux conseils très pratiques pour les propriétés calculées qui sont facilement négligés : premièrement, les propriétés calculées peuvent dépendre d'autres propriétés calculées. Deuxièmement, les propriétés calculées peuvent non seulement s'appuyer sur les données de l'instance Vue actuelle, mais également sur les données d'autres propriétés calculées. instances, par exemple :
<p id="app1"></p>
<p id="app2">{{ reverseText}}</p>
var app1 = new Vue({
el: '#app1',
data: {
text: 'computed'
}
});
var app2 = new Vue({
el: '#app2',
computed: {
reverseText: function(){
return app1.text.split('').reverse().join(''); //使用app1的数据进行计算
}
}
});
Chaque propriété calculée contient un getter et un setter. Nos deux exemples ci-dessus sont l'utilisation par défaut des propriétés calculées, utilisant uniquement des getters pour la lecture.
Lorsque vous en avez besoin, vous pouvez également fournir une fonction de définition. Lorsque vous modifiez manuellement la valeur d'une propriété calculée comme si vous modifiiez une donnée ordinaire, la fonction de définition sera déclenchée pour effectuer certaines opérations personnalisées, telles que :
var vm = new Vue({
el: '#demo',
data: {
firstName: 'Foo',
lastName: 'Bar'
},
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];
}
}
}
});
//现在再运行 vm.fullName = 'John Doe' 时，setter 会被调用，vm.firstName 和 vm.lastName 也会相应地被更新。
Dans la plupart des cas, nous n'utiliserons que la méthode getter par défaut pour lire une propriété calculée. Les setters sont rarement utilisés en entreprise, donc lors de la déclaration d'une propriété calculée, vous pouvez utiliser directement la méthode d'écriture par défaut sans avoir à combiner getter et setter. .
3. Cache d'attributs calculés
Dans l'exemple ci-dessus, en plus d'utiliser des propriétés calculées, nous pouvons également obtenir le même effet en appelant des méthodes dans des expressions, telles que :
<p>{{reverseTitle()}}</p>
// 在组件中
methods: {
reverseTitle: function () {
return this.title.split('').reverse().join('')
}
}
Nous pourrions définir la même fonction comme une méthode au lieu d’une propriété calculée, et le résultat final serait en effet exactement le même dans les deux cas. Un seul utilise reverseTitle() pour obtenir la valeur, et l'autre utilise reverseTitle pour obtenir la valeur.
Toutefois, la différence réside dans le fait que les propriétés calculées sont mises en cache en fonction de leurs dépendances. Une propriété calculée n'est réévaluée que lorsque ses dépendances associées changent.
Cela signifie que tant que le titre n'a pas changé, accéder plusieurs fois à la propriété calculée reverseTitle renverra immédiatement le résultat du calcul précédent sans avoir à réexécuter la fonction.
Un petit exemple :
<p>{{reverseTitle}}</p>
<p>{{reverseTitle1()}}</p>
<button @click="add()">补充货物1</button>
<p>总价为：{{price}}</p>
computed: {
reverseTitle: function(){
return this.title.split('').reverse().join('') //而使用计算属性，只要title没变，页面渲染是不会重新进这里来计算的，而是使用了缓存。
},
price: function(){
return this.package1.count*this.package1.price+this.package2.count*this.package2.price
}
},
methods: { //对象的方法
add: function(){
this.package1.count++
},
reverseTitle1: function(){
return this.title.split('').reverse().join('') //点击补充货物，也会进这个方法，再次计算。不是刷新，而是只要页面渲染，就会进方法里重新计算。
}
},
En revanche, la méthode appelante exécutera toujours à nouveau la fonction chaque fois qu’un nouveau rendu est déclenché.
Pourquoi avons-nous besoin de mise en cache ? Supposons que nous ayons une propriété A coûteuse en termes de calcul, qui nécessite de parcourir un vaste tableau et d'effectuer de nombreux calculs. Nous pourrions alors avoir d’autres propriétés calculées qui dépendent de A .
Sans mise en cache, nous exécuterions inévitablement le getter de A plusieurs fois ! Si vous ne souhaitez pas de mise en cache, utilisez plutôt des méthodes.
Jetons un coup d'œil à l'utilisation des propriétés calculées de Vue
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>计算属性</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="black">
<script src="../js/Vue.js"></script>
<script src="../js/vue-resource.js"></script>
<script>
window.onload = function(){
var vm = new Vue({
el:'#box',
data: {
a: 1,
},
computed:{
b:function(){
return this.a+1;
}
}
});
console.log(vm.a);
}
</script>
</head>
<body>
<p id="box">
a => {{a}}
<br>
b => {{b}}
</p>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>计算属性</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="black">
<script src="../js/Vue.js"></script>
<script src="../js/vue-resource.js"></script>
<script>
window.onload = function(){
var vm = new Vue({
el:'#box',
data: {
a: 1,
},
computed:{
b:function(){
return this.a+1;
}
}
});
document.onclick = function(){
vm.a = 101;
}
}
</script>
</head>
<body>
<p id="box">
a => {{a}}
<br>
b => {{b}}
</p>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>计算属性</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="black">
<script src="../js/Vue.js"></script>
<script src="../js/vue-resource.js"></script>
<script>
window.onload = function(){
var vm = new Vue({
el:'#box',
data: {
a: 1,
},
computed:{
b:{
get:function(){
return this.a+2;
},
set:function(val){
this.a=val;
}
}
}
});
document.onclick = function(){
vm.b = 10;
}
}
</script>
</head>
<body>
<p id="box">
a => {{a}}
<br>
b => {{b}}
</p>
</body>
</html>
Je pense que vous maîtrisez la méthode après avoir lu le cas dans cet article. Pour plus d'informations, veuillez prêter attention aux autres sujets connexes dans l'article du site Web PHP chinois !
Lecture recommandée :
Explication détaillée de la méthode rem de construction automatisée côté mobile de Webpack
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!
Articles Liés
Voir plus- Une analyse approfondie du composant de groupe de liste Bootstrap
- Explication détaillée du currying de la fonction JavaScript
- Exemple complet de génération de mot de passe JS et de détection de force (avec téléchargement du code source de démonstration)
- Angularjs intègre l'interface utilisateur WeChat (weui)
- Comment basculer rapidement entre le chinois traditionnel et le chinois simplifié avec JavaScript et l'astuce permettant aux sites Web de prendre en charge le basculement entre les compétences en chinois simplifié et traditionnel_javascript