Maison > Article > interface Web > Explication détaillée des propriétés calculées et de l'utilisation de vue
Explication détaillée des propriétés calculées et de l'utilisation de vue
- php中世界最好的语言original
- 2018-04-08 14:56:571585parcourir
Cette fois, je vais vous apporter une explication détaillée des propriétés calculées de vue et de leur utilisation. 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
Les expressions dans les modèles sont très pratiques, mais l'intention initiale de leur conception est utilisée 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 d'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 renvoyé à la fin.
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('')
}
}
});
Le résultat :
Message original : "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 le seront. sera réexécuté. La vue sera également 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 ne peuvent pas uniquement s'appuyer sur les données de l'instance Vue actuelle ; , mais aussi les données d'autres 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 lire.
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, tout 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 utiliserons uniquement 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 directement utiliser la valeur par défaut dans le fichier. manière d’écrire, il n’est pas nécessaire de déclarer à la fois le getter et le setter.
3. Mise en cache des attributs calculés
Dans l'exemple ci-dessus, en plus d'utiliser des attributs calculés, nous pouvons également appeler des méthodes dans les expressions To. obtenir le même effet, tel que :
<p>{{reverseTitle()}}</p>
// 在组件中
methods: {
reverseTitle: function () {
return this.title.split('').reverse().join('')
}
}
Nous pouvons définir la même fonction comme une méthode au lieu d'une propriété calculée, et le résultat final des deux méthodes est en effet exactement le même. Un seul utilise reverseTitle() pour obtenir la valeur, et l'autre utilise reverseTitle pour obtenir la valeur.
Cependant, la différence est 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, chaque fois qu'un nouveau rendu est déclenché, la méthode appelante exécutera toujours à nouveau la fonction.
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écuterons 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 l'avez lu. Vous maîtrisez la méthode dans le cas de 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 :
Comment gérer le délai d'expiration de la demande de vue axios
Comment implémenter l'optimisation de l'échafaudage dans webpack
Étapes détaillées pour le webpack v4 du développement au prd
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