vue從入門到進階：計算屬性computed與偵聽器watch（三）

風雨後見彩虹發表於2018-01-12
Vue

計算屬性computed

模板內的表示式非常便利，但是設計它們的初衷是用於簡單運算的。在模板中放入太多的邏輯會讓模板過重且難以維護。例如：

<div id="example">
  {{ message.split(``).reverse().join(``) }}
</div>

所以，對於任何複雜邏輯，你都應當使用計算屬性。

例子

<div id="example">
  <p>Original message: "{{ message }}"</p>
  <p>Computed reversed message: "{{ reversedMessage }}"</p>
</div>
var vm = new Vue({
  el: `#example`,
  data: {
    message: `Hello`
  },
  computed: {
    // 計算屬性的 getter
    reversedMessage: function () {
      // `this` 指向 vm 例項
      return this.message.split(``).reverse().join(``)
    }
  }
})

結果：

Original message: "Hello"
Computed reversed message: "olleH"

這裡我們宣告瞭一個計算屬性 reversedMessage。我們提供的函式將用作屬性 vm.reversedMessage 的 getter 函式：

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

你可以開啟瀏覽器的控制檯，自行修改例子中的 vm。vm.reversedMessage 的值始終取決於 vm.message 的值。

計算屬性快取 vs 方法

你可能已經注意到我們可以通過在表示式中呼叫方法來達到同樣的效果：

<p>Reversed message: "{{ reversedMessage() }}"</p>

// 在元件中
methods: {
  reversedMessage: function () {
    return this.message.split(``).reverse().join(``)
  }
}

我們可以將同一函式定義為一個方法而不是一個計算屬性。兩種方式的最終結果確實是完全相同的。然而，不同的是計算屬性是基於它們的依賴進行快取的。計算屬性只有在它的相關依賴發生改變時才會重新求值。這就意味著只要 message 還沒有發生改變，多次訪問 reversedMessage 計算屬性會立即返回之前的計算結果，而不必再次執行函式。

這也同樣意味著下面的計算屬性將不再更新，因為 Date.now() 不是響應式依賴：

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

計算屬性 vs 偵聽屬性

Vue 提供了一種更通用的方式來觀察和響應 Vue 例項上的資料變動：偵聽屬性。當你有一些資料需要隨著其它資料變動而變動時，你很容易濫用 watch——特別是如果你之前使用過 AngularJS。然而，通常更好的做法是使用計算屬性而不是命令式的 watch 回撥。如下例子：

<div id="demo">{{ fullName }}</div>
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
    }
  }
})

上面程式碼是命令式且重複的。將它與計算屬性的版本進行比較：

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

計算屬性的 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]
    }
  }
}
// ...

現在再執行 vm.fullName = `John Doe` 時，setter 會被呼叫，vm.firstName 和 vm.lastName 也會相應地被更新。

偵聽器watch

雖然計算屬性在大多數情況下更合適，但有時也需要一個自定義的偵聽器。這就是為什麼 Vue 通過 watch 選項提供了一個更通用的方法，來響應資料的變化。當需要在資料變化時執行非同步或開銷較大的操作時，這個方式是最有用的。

<div id="watch-example">
  <p>
    Ask a yes/no question:
    <input v-model="question">
  </p>
  <p>{{ answer }}</p>
</div>
<!-- 因為 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) {
      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>

在這個示例中，使用 watch 選項允許我們執行非同步操作 (訪問一個 API)，限制我們執行該操作的頻率，並在我們得到最終結果前，設定中間狀態。這些都是計算屬性無法做到的。

除了 watch 選項之外，您還可以使用命令式的 vm.$watch API。

vm.$watch( expOrFn, callback, [options] )

引數：

  • {string | Function} expOrFn
  • {Function | Object} callback

  • {Object} [options]

    • {boolean} deep
    • {boolean} immediate

返回值：{Function} unwatch
用法：
觀察 Vue 例項變化的一個表示式或計算屬性函式。回撥函式得到的引數為新值和舊值。表示式只接受監督的鍵路徑。對於更復雜的表示式，用一個函式取代。

注意：在變異 (不是替換) 物件或陣列時，舊值將與新值相同，因為它們的引用指向同一個物件/陣列。Vue 不會保留變異之前值的副本。

例項1：

// 鍵路徑
vm.$watch(`a.b.c`, function (newVal, oldVal) {
  // 做點什麼
})

再來一個函式的例項：
html程式碼：

<div id="app">
    <input type="text" v-model="a"  />
    <input type="text" v-model="b"  />
</div>

JS程式碼：

//函式
var vm = new Vue({
  el: `#app`,
  data: {
    a:`文字1`,
    b:`文字2`
  },
  
})
vm.$watch(
  function () {
    return this.a + this.b
  },
  function (newVal, oldVal) {
    console.log(newVal,oldVal);
  }
)

vm.$watch 返回一個取消觀察函式，用來停止觸發回撥：

var unwatch = vm.$watch(`a`, cb)
// 之後取消觀察
unwatch()
  • 選項：deep

為了發現物件內部值的變化，可以在選項引數中指定 deep: true 。注意監聽陣列的變動不需要這麼做。

vm.$watch(`someObject`, callback, {
  deep: true
})
vm.someObject.nestedValue = 123
// callback is fired
  • 選項：immediate

在選項引數中指定 immediate: true 將立即以表示式的當前值觸發回撥：

vm.$watch(`a`, callback, {
  immediate: true
})
// 立即以 `a` 的當前值觸發回撥

相關文章