Qual è la differenza principale tra un metodo e un valore calcolato in Vue.js?
Sembrano uguali e intercambiabili.
Qual è la differenza principale tra un metodo e un valore calcolato in Vue.js?
Sembrano uguali e intercambiabili.
Risposte:
I valori e i metodi calcolati sono molto diversi in Vue e nella maggior parte dei casi non sono assolutamente intercambiabili.
Proprietà calcolata
Un nome più appropriato per un valore calcolato è una proprietà calcolata . Infatti, quando viene creata un'istanza di Vue, le proprietà calcolate vengono convertite in una proprietà di Vue con un getter e talvolta un setter. Fondamentalmente puoi pensare a un valore calcolato come un valore derivato che verrà automaticamente aggiornato ogni volta che viene aggiornato uno dei valori sottostanti utilizzati per calcolarlo. Non si chiama un computer e non accetta alcun parametro. Fai riferimento a una proprietà calcolata proprio come faresti con una proprietà di dati. Ecco il classico esempio dalla documentazione :
computed: {
// a computed getter
reversedMessage: function () {
// `this` points to the vm instance
return this.message.split('').reverse().join('')
}
}
A cui si fa riferimento nel DOM in questo modo:
<p>Computed reversed message: "{{ reversedMessage }}"</p>
I valori calcolati sono molto utili per manipolare i dati esistenti su Vue. Ogni volta che desideri filtrare o trasformare i tuoi dati, in genere utilizzerai un valore calcolato a tale scopo.
data:{
names: ["Bob", "Billy", "Mary", "Jane"]
},
computed:{
startsWithB(){
return this.names.filter(n => n.startsWith("B"))
}
}
<p v-for="name in startsWithB">{{name}}</p>
I valori calcolati vengono anche memorizzati nella cache per evitare il calcolo ripetitivo di un valore che non deve essere ricalcolato quando non è cambiato (poiché potrebbe non essere presente in un ciclo, ad esempio).
Metodo
Un metodo è solo una funzione associata all'istanza Vue. Sarà valutato solo quando lo chiami esplicitamente. Come tutte le funzioni javascript accetta parametri e sarà rivalutato ogni volta che viene chiamato. I metodi sono utili nelle stesse situazioni qualsiasi funzione è utile.
data:{
names: ["Bob", "Billy", "Mary", "Jane"]
},
computed:{
startsWithB(){
return this.startsWithChar("B")
},
startsWithM(){
return this.startsWithChar("M")
}
},
methods:{
startsWithChar(whichChar){
return this.names.filter(n => n.startsWith(whichCharacter))
}
}
La documentazione di Vue è davvero buona e facilmente accessibile. Lo consiglio.
Quando @gleenk ha chiesto un esempio pratico per mettere in evidenza le differenze di cache e dipendenza tra metodi e proprietà calcolate, mostrerò un semplice scenario:
new Vue({
el: '#vue-app',
data: {
a: 0,
b: 0,
age: 20
},
methods: {
addToAmethod: function(){
console.log('addToAmethod');
return this.a + this.age;
},
addToBmethod: function(){
console.log('addToBmethod');
return this.b + this.age;
}
},
computed: {
addToAcomputed: function(){
console.log('addToAcomputed');
return this.a + this.age;
},
addToBcomputed: function(){
console.log('addToBcomputed');
return this.b + this.age;
}
}
});
Qui abbiamo 2 metodi e 2 proprietà calcolate che eseguono la stessa attività. I metodi addToAmethod
e addToBmethod
e le proprietà calcolate addToAcomputed
e addToBcomputed
tutto metti +20 (cioè il age
valore) a uno a
o b
. Per quanto riguarda i metodi, vengono entrambi chiamati ogni volta che è stata eseguita un'azione su una delle proprietà elencate, anche se le dipendenze per un metodo specifico non sono cambiate. Per le proprietà calcolate, il codice viene eseguito solo quando una dipendenza è cambiata; ad esempio, uno dei valori di proprietà specifici che fa riferimento ad A o B si attiverà addToAcomputed
o addToBcomputed
, rispettivamente.
Il metodo e le descrizioni calcolate sembrano abbastanza simili, ma dato che @Abdullah Khan lo ha già specificato , non sono la stessa cosa ! Ora proviamo ad aggiungere un po 'di html per eseguire tutto insieme e vedere dov'è la differenza.
new Vue({
el: '#vue-app',
data: {
a: 0,
b: 0,
age: 20
},
methods: {
addToAmethod: function(){
console.log('addToAmethod');
return this.a + this.age;
},
addToBmethod: function(){
console.log('addToBmethod');
return this.b + this.age;
}
}
});
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>VueJS Methods - stackoverflow</title>
<link href="style.css" rel="stylesheet" />
<script src="https://cdnjs.cloudflare.com/ajax/libs/vue/2.5.11/vue.min.js"></script>
</head>
<body>
<div id="vue-app">
<h1>Methods</h1>
<button v-on:click="a++">Add to A</button>
<button v-on:click="b++">Add to B</button>
<p>Age + A = {{ addToAmethod() }}</p>
<p>Age + B = {{ addToBmethod() }}</p>
</div>
</body>
<script src="app.js"></script>
</html>
Quando faccio clic sul pulsante "Aggiungi ad A" , vengono chiamati tutti i metodi (vedere il risultato della schermata del registro della console sopra), addToBmethod()
viene anche eseguito ma non ho premuto il pulsante "Aggiungi a B" ; il valore della proprietà che fa riferimento a B non è cambiato. Lo stesso comportamento si verifica se decidiamo di fare clic sul pulsante "Aggiungi a B" , perché entrambi i metodi verranno chiamati indipendentemente dalle modifiche della dipendenza. Secondo questo scenario, questa è una cattiva pratica perché stiamo eseguendo i metodi ogni volta, anche quando le dipendenze non sono cambiate. Questo richiede davvero risorse perché non esiste una cache per i valori delle proprietà che non sono stati modificati.
new Vue({
el: '#vue-app',
data: {
a: 0,
b: 0,
age: 20
},
computed: {
addToAcomputed: function(){
console.log('addToAcomputed');
return this.a + this.age;
},
addToBcomputed: function(){
console.log('addToBcomputed');
return this.b + this.age;
}
}
});
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>VueJS Computed properties - stackoverflow</title>
<link href="style.css" rel="stylesheet" />
<script src="https://cdnjs.cloudflare.com/ajax/libs/vue/2.5.11/vue.min.js"></script>
</head>
<body>
<div id="vue-app">
<h1>Computed Properties</h1>
<button v-on:click="a++">Add to A</button>
<button v-on:click="b++">Add to B</button>
<p>Age + A = {{ addToAcomputed }}</p>
<p>Age + B = {{ addToBcomputed }}</p>
</div>
</body>
<script src="app.js"></script>
</html>
Quando faccio clic sul pulsante "Aggiungi ad A" , addToAcomputed
viene chiamata solo la proprietà calcolata perché, come abbiamo già detto, le proprietà calcolate vengono eseguite solo quando una dipendenza è cambiata. E poiché non ho premuto il pulsante "Aggiungi a B" e il valore della proprietà age per B non è cambiato, non c'è motivo di chiamare ed eseguire la proprietà calcolata addToBcomputed
. Quindi, in un certo senso, la proprietà calcolata mantiene lo stesso valore "invariato" per la proprietà B come una specie di cache. E in questa circostanza questo è considerato una buona pratica .
Dal docs
Le proprietà ..computed sono memorizzate nella cache in base alle loro dipendenze. Una proprietà calcolata rivaluterà solo quando alcune delle sue dipendenze sono cambiate.
Se si desidera che i dati vengano memorizzati nella cache, utilizzare le proprietà calcolate se non si desidera che i dati vengano memorizzati nella cache, utilizzare le proprietà del metodo semplici.
Una delle differenze tra calcolato e metodo. Supponiamo di avere una funzione che restituirà il valore del contatore (il contatore è solo variabile). Vediamo come si comporta la funzione sia nel calcolo che nel metodo
Computerizzata
Alla prima esecuzione il codice all'interno della funzione verrà eseguito e vuejs memorizzerà il valore del contatore nella cache (per un accesso più veloce). Ma quando chiameremo di nuovo la funzione vuejs non eseguirà di nuovo il codice scritto all'interno di quella funzione. Prima controlla tutte le modifiche apportate al contatore o meno. Se vengono apportate modifiche, solo questa eseguirà nuovamente il codice che si trova all'interno di quella funzione. Se non sono state apportate modifiche al contatore, vuejs non eseguirà nuovamente la funzione. Restituirà semplicemente il risultato precedente dalla cache.
Metodo
Questo è proprio come un normale metodo nel javascript. Ogni volta che chiamiamo il metodo eseguirà sempre il codice all'interno della funzione indipendentemente dalle modifiche apportate al contatore.
Il metodo eseguirà sempre nuovamente il codice indipendentemente dalle modifiche nel codice. dove, come calcolato, eseguirà nuovamente il codice solo se uno dei suoi valori di dipendenza è cambiato. Altrimenti ci darà il risultato precedente dalla cache senza rieseguire
Ecco una ripartizione di questa domanda.
Quando usare i metodi
Quando utilizzare le proprietà calcolate
Proprietà calcolate
Le proprietà calcolate sono anche chiamate valore calcolato. Significa che si aggiornano e possono essere modificati in qualsiasi momento. Inoltre, memorizza nella cache i dati fino a quando non cambia. Quando viene creata un'istanza di Vue, le proprietà calcolate vengono convertite in una proprietà.
Un'altra cosa che voglio condividere, non è possibile passare alcun parametro nelle proprietà calcolate, motivo per cui durante la chiamata a qualsiasi proprietà del computer non è necessaria la parentesi.
metodi
I metodi sono gli stessi della funzione e funzionano allo stesso modo. Inoltre, un metodo non fa nulla se non lo chiami. Inoltre, come tutte le funzioni javascript, accetta i parametri e verrà rivalutato ogni volta che viene chiamato. Successivamente, non possono memorizzare nella cache valori
Nel metodo di chiamata è presente la parentesi ed è possibile inviare uno o più parametri.
Ci siamo imbattuti nella stessa domanda. Per me è più chiaro in questo modo:
v-on directive
seguito da un metodo, sa esattamente quale metodo chiamare e quando chiamarlo.<button v-on:click="clearMessage">Clear message</button> // @click
// method clearMessage is only called on a click on this button
<input v-model="message" @keyup.esc="clearMessage" @keyup.enter="alertMessage" />
/* The method clearMessage is only called on pressing the escape key
and the alertMessage method on pressing the enter key */
v-on directive
, verrà chiamato ogni volta che viene attivato un evento sulla pagina che aggiorna il DOM (o semplicemente deve eseguire nuovamente il rendering di una parte della pagina). Anche quando quel metodo non ha nulla a che fare con l'attivazione dell'evento.<p>Uppercase message: {{ messageUppercase() }}</p>
methods: {
messageUppercase() {
console.log("messageUpercase");
return this.message.toUpperCase();
}
}
/* The method `messageUppercase()` is called on every button click, mouse hover
or other event that is defined on the page with the `v-on directive`. So every
time the page re-renders.*/
this
parola nella sua definizione di funzione.<p>Uppercase message: {{ messageUppercase }}</p>
data() {
return {
message: "I love Vue.js"
}
},
computed: {
messageUppercase() {
console.log("messageUpercase");
return this.message.toUpperCase();
}
}
/* The computed property messageUppercase is only called when the propery message is
changed. Not on other events (clicks, mouse hovers,..) unless of course a specific
event changes the value of message. */
Il take away qui è che è meglio usare le computed
proprietà nel caso in cui un metodo non venga chiamato con il v-on directive
.