Vue computed properties and listener case code analysis

This time I will bring you vue calculationpropertiesand listener case code analysis, what are the notes for implementing vue calculation properties and listeners, the following is a practical case, one Get up and take a look.

Basic example

<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: {
  // 计算属性的 getter
  reversedMessage: function () {
   // `this` 指向 vm 实例
   return this.message.split('').reverse().join('')
  }
 }
})

Result:

##Original message: "Hello"

Computed reversed message : "olleH"

Here we declare a calculated property reversedMessage. The function we provide will be used as the getter function of the property vm.reversedMessage:

console.log(vm.reversedMessage) // => 'olleH'
vm.message = 'Goodbye'
console.log(vm.reversedMessage) // => 'eybdooG'

You can open the browser console and modify the vm in the example yourself. The value of

vm.reversedMessage always depends on the value of vm.message.

You can bind computed properties in templates just like normal properties. Vue knows that

vm.reversedMessage depends on vm.message, so when vm.message changes, all bindings that depend on vm.reversedMessage are also updated. And the best part is that we've created this dependency in a declarative way: the computed property's getter function has no side effects, making it easier to test and understand

Computation Property caching vs methods

You may have noticed that we can achieve the same effect by calling a method in an

expression:

<p>Reversed message: "{{ reversedMessage() }}"</p>
// 在组件中
methods: {
 reversedMessage: function () {
  return this.message.split('').reverse().join('')
 }
}

We can convert the same A function is defined as a method rather than a computed property. The end result is indeed exactly the same both ways. However, the difference is that computed properties are cached based on their dependencies. A computed property is only re-evaluated when its associated dependencies change. This means that as long as the message has not changed, multiple accesses to the reversedMessage calculated property will immediately return the previous calculated result without having to execute the function again.

This also means that the following computed properties will no longer be updated, because Date.now() is not a reactive dependency:

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

In contrast, whenever a re-render is triggered, Calling a method will always execute the function again.

Why do we need caching? Suppose we have a computationally expensive property A, which requires traversing a huge array and doing a lot of calculations. Then we might have other computed properties that depend on A . Without caching, we would inevitably execute A's getter multiple times! If you don't want caching, use methods instead.

Computed properties vs listening properties

Vue provides a more general way to observe and respond to data changes on Vue instances: listening properties. When you have some data that needs to change when other data changes, it's easy to abuse watches - especially if you've used

AngularJS before. However, it is often better to use computed properties instead of imperative watch callbacks. Consider this example:

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

The above code is imperative and repetitive. Compare it to the computed property version:

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

Much better, isn't it?

Setters for computed properties

Computed properties only have getters by default, but you can also provide a setter when needed:

// ...
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]
  }
 }
}
// ...

Run now

When vm.fullName = 'John Doe' , the setter will be called, and vm.firstName and vm.lastName will be updated accordingly.

Listener

While computed properties are more appropriate in most cases, sometimes a custom listener is needed. This is why Vue provides a more general way to respond to changes in data through the watch option. This approach is most useful when you need to perform asynchronous or expensive operations when data changes.

For example:

<p id="watch-example">
 <p>
  Ask a yes/no question:
  <input v-model="question">
 </p>
 <p>{{ answer }}</p>
</p>
<!-- 因为 AJAX 库和通用工具的生态已经相当丰富，Vue 核心代码没有重复 -->
<!-- 提供这些功能以保持精简。这也可以让你自由选择自己更熟悉的工具。 -->
<script src="https://cdn.jsdelivr.net/npm/axios@0.12.0/dist/axios.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/lodash@4.13.1/lodash.min.js"></script>
<script>
var watchExampleVM = new Vue({
 el: '#watch-example',
 data: {
  question: '',
  answer: 'I cannot give you an answer until you ask a question!'
 },
 watch: {
  // 如果 `question` 发生改变，这个函数就会运行
  question: function (newQuestion, oldQuestion) {
   this.answer = 'Waiting for you to stop typing...'
   this.getAnswer()
  }
 },
 methods: {
  // `_.debounce` 是一个通过 Lodash 限制操作频率的函数。
  // 在这个例子中，我们希望限制访问 yesno.wtf/api 的频率
  // AJAX 请求直到用户输入完毕才会发出。想要了解更多关于
  // `_.debounce` 函数 (及其近亲 `_.throttle`) 的知识，
  // 请参考：https://lodash.com/docs#debounce
  getAnswer: _.debounce(
   function () {
    if (this.question.indexOf('?') === -1) {
     this.answer = 'Questions usually contain a question mark. ;-)'
     return
    }
    this.answer = 'Thinking...'
    var vm = this
    axios.get('https://yesno.wtf/api')
     .then(function (response) {
      vm.answer = _.capitalize(response.data.answer)
     })
     .catch(function (error) {
      vm.answer = 'Error! Could not reach the API. ' + error
     })
   },
   // 这是我们为判定用户停止输入等待的毫秒数
   500
  )
 }
})
</script>

Result:

Ask a yes/no question:

I cannot give you an answer until you ask a question !

In this example, using the watch option allows us to perform an asynchronous operation (access an API), limit how often we perform the operation, and set an intermediate

before we get the final result state. These are things that computed properties cannot do.

In addition to the watch option, you can also use the imperative vm.$watch API.

I believe you have mastered the method after reading the case in this article. For more exciting information, please pay attention to other related articles on the php Chinese website!

Recommended reading:

Detailed explanation of the steps to use vuex and components together

Vue uses vux-ui custom form verification attention What are the matters

The above is the detailed content of Vue computed properties and listener case code analysis. For more information, please follow other related articles on the PHP Chinese website!