Vue 元件生命週期：探索鉤子

Amd794發表於2024-05-27

Vue元件

title: Vue 元件生命週期：探索鉤子
date: 2024/5/27 18:42:38
updated: 2024/5/27 18:42:38
categories:

前端開發

tags:

生命週期
非同步載入
通訊原理
父子通訊
兄弟通訊
跨層通訊
效能最佳化

第 1 章：介紹與背景

1.1 什麼是 Vue 元件生命週期？

Vue 元件生命週期是指 Vue 元件從建立、執行到銷燬的整個過程，共分為 8 個階段：

建立前（beforeCreate）
建立後（created）
載入前（beforeMount）
載入後（mounted）
更新前（beforeUpdate）
更新後（updated）
銷燬前（beforeDestroy）
銷燬後（destroyed）

在每個階段，Vue 框架都提供了特定的鉤子函式，開發人員可以在這些函式中編寫自定義的程式碼，從而實現對元件生命週期的控制和管理。

1.2 為什麼需要了解生命週期？

瞭解 Vue 元件生命週期有以下幾個優點：

瞭解元件的執行機制，提高開發效率。
在合適的時機進行資料處理和事件繫結，提高專案效能。
在元件建立和銷燬時進行資源清理和記憶體釋放，避免記憶體洩漏。
在生命週期鉤子函式中進行非同步資料載入和元件通訊，使程式碼更加清晰和可維護。

1.3 如何利用生命週期提高開發效率？

在建立階段，可以進行資料初始化和事件繫結，避免在模板中頻繁的編寫相同的程式碼。
在執行階段，可以對資料進行監聽和最佳化，提高專案效能。
在銷燬階段，可以進行資源清理和記憶體釋放，避免記憶體洩漏。AD：漫畫首頁
在生命週期鉤子函式中進行非同步資料載入和元件通訊，使程式碼更加清晰和可維護。
透過使用第三方庫或外掛，可以更加方便地使用生命週期鉤子函式，提高開發效率。

第 2 章：元件生命週期概述

2.1 元件生命週期的基本概念

元件生命週期是指 Vue 元件從建立、執行到銷燬的整個過程。在這個過程中，Vue 框架會自動呼叫一系列的生命週期鉤子函式，開發人員可以在這些函式中編寫自定義的程式碼，從而實現對元件生命週期的控制和管理。

2.2 生命週期鉤子函式的分類

Vue 元件的生命週期鉤子函式可以分為以下幾類：

建立階段鉤子函式：在元件建立時呼叫，包括 beforeCreate 和 created 兩個鉤子函式。
載入階段鉤子函式：在元件載入時呼叫，包括 beforeMount 和 mounted 兩個鉤子函式。
更新階段鉤子函式：在元件更新時呼叫，包括 beforeUpdate 和 updated 兩個鉤子函式。
銷燬階段鉤子函式：在元件銷燬時呼叫，包括 beforeDestroy 和 destroyed 兩個鉤子函式。

2.3 常見的生命週期鉤子函式

beforeCreate：在元件例項被建立之前呼叫，此時元件例項的資料和方法還未初始化。
created：在元件例項被建立之後呼叫，此時元件例項的資料和方法已經初始化，但元件還未被掛載到 DOM 上。
beforeMount：在元件被掛載到 DOM 之前呼叫，此時元件的模板已經編譯完成，但還未渲染到 DOM 上。
mounted：在元件被掛載到 DOM 之後呼叫，此時元件已經渲染到 DOM 上，可以進行 DOM 操作和非同步資料載入。
beforeUpdate：在元件更新之前呼叫，此時元件的資料已經發生變化，但還未重新渲染到 DOM 上。
updated：在元件更新之後呼叫，此時元件的資料已經重新渲染到 DOM 上，可以進行 DOM 操作和非同步資料載入。
beforeDestroy：在元件銷燬之前呼叫，此時元件例項仍然可用，可以進行資源清理和記憶體釋放。AD：首頁 | 一個覆蓋廣泛主題工具的高效線上平臺
destroyed：在元件銷燬之後呼叫，此時元件例項已經被銷燬，無法再進行任何操作。

第 3 章：建立階段

在 Vue.js 中，元件的建立階段包括以下幾個鉤子函式：

beforeCreate：在元件例項被建立之前呼叫，此時資料和方法還未初始化。
created：在元件例項被建立之後呼叫，此時資料和方法已經初始化，可以進行資料操作和事件繫結。
beforeMount：在元件被掛載到 DOM 之前呼叫，此時模板已經編譯完成，但還未渲染到 DOM 上。
mounted：在元件被掛載到 DOM 之後呼叫，此時元件已經渲染到 DOM 上，可以進行 DOM 操作和非同步資料載入。

在建立階段，可以在鉤子函式中進行資料處理和事件繫結，以簡化元件的程式碼和提高元件的效能。

例如，在 created 鉤子函式中可以進行資料的請求和初始化，從而避免在元件掛載到 DOM 之後再進行資料請求，提高元件的渲染速度。

同時，可以在 created 鉤子函式中進行事件的繫結，從而在元件建立時就完成事件的繫結，而無需在 mounted 鉤子函式中進行事件繫結。

總之，在建立階段進行資料處理和事件繫結，可以簡化元件的程式碼和提高元件的效能，是實現高質量 Vue 元件開發的重要手段。

以下是一些程式碼示例：

// 在 created 鉤子函式中進行資料的請求和初始化
export default {
  data() {
    return {
      user: null
    }
  },
  created() {
    this.fetchUser()
  },
  methods: {
    fetchUser() {
      // 進行資料請求和初始化
      this.user = {
        name: 'John Doe',
        age: 30
      }
    }
  }
}

// 在 created 鉤子函式中進行事件的繫結
export default {
  data() {
    return {
      message: 'Hello World!'
    }
  },
  created() {
    this.handleClick = () => {
      console.log(this.message)
    }
  },
  mounted() {
    document.getElementById('btn').addEventListener('click', this.handleClick)
  }
}

在上述示例中，我們可以看到在 created 鉤子函式中進行資料的請求和初始化，以及事件的繫結，從而在元件建立時就完成資料的請求和初始化，並且在元件掛載到 DOM 之後就完成事件的繫結。

第 4 章：執行階段

在 Vue.js 中，元件的執行階段包括以下幾個鉤子函式：

beforeUpdate：在元件更新之前呼叫，此時資料已經更新，但 DOM 還未重新渲染。
updated：在元件更新之後呼叫，此時 DOM 已經重新渲染。

在執行階段，可以在鉤子函式中進行資料監聽和效能最佳化，以提高元件的響應速度和效能。

例如，在 beforeUpdate 鉤子函式中可以進行資料的監聽，從而在資料更新時及時更新元件的狀態，避免出現資料不一致的情況。

同時，可以在 updated 鉤子函式中進行效能最佳化，例如使用虛擬滾動技術來最佳化大量資料的渲染，或者使用防抖和節流技術來最佳化頻繁觸發的事件。
AD：專業搜尋引擎

總之，在執行階段進行資料監聽和效能最佳化，可以提高元件的響應速度和效能，是實現高質量 Vue 元件開發的重要手段。

以下是一些程式碼示例：

// 在 beforeUpdate 鉤子函式中進行資料的監聽
export default {
  data() {
    return {
      count: 0
    }
  },
  beforeUpdate() {
    console.log(`count before update: ${this.count}`)
  },
  methods: {
    increment() {
      this.count++
    }
  }
}

// 在 updated 鉤子函式中進行效能最佳化
export default {
  data() {
    return {
      items: []
    }
  },
  updated() {
    // 使用虛擬滾動技術來最佳化大量資料的渲染
    const container = document.getElementById('container')
    container.style.height = `${container.scrollHeight}px`
  },
  methods: {
    addItem() {
      this.items.push(`Item ${this.items.length}`)
    }
  }

第 5 章：銷燬階段

在 Vue.js 中，元件的銷燬階段包括以下兩個生命週期鉤子函式：

beforeDestroy：在元件銷燬之前呼叫。在這個階段，元件例項仍然完全可用，這意味著所有的資料繫結、事件監聽器、計算屬性等都還在工作。
destroyed：在元件銷燬之後呼叫。在這個階段，元件例項已經被銷燬，所有的繫結和事件監聽器都已經被移除，元件不再可用。

在銷燬階段，通常會進行資源清理和記憶體釋放，以確保應用程式的效能和穩定性。以下是一些常見的清理操作：

取消訂閱：如果元件中使用了事件訂閱（如使用 EventBus 或第三方庫如 RxJS），應該在 beforeDestroy 鉤子中取消這些訂閱，以避免記憶體洩漏。
清除定時器：如果在元件中使用了定時器（如 setInterval 或 setTimeout），應該在 beforeDestroy 鉤子中清除這些定時器。
解綁事件監聽器：如果元件繫結了 DOM 事件監聽器，應該在 beforeDestroy 鉤子中解綁這些事件監聽器。
斷開 WebSocket 連線：如果元件使用了 WebSocket 連線，應該在 beforeDestroy 鉤子中斷開這些連線。

以下是一個簡單的示例，展示瞭如何在 beforeDestroy 鉤子中進行資源清理：

export default {
  data() {
    return {
      timer: null
    };
  },
  created() {
    // 建立定時器
    this.timer = setInterval(() => {
      console.log('定時器執行中...');
    }, 1000);
  },
  beforeDestroy() {
    // 清除定時器
    clearInterval(this.timer);
  },
  destroyed() {
    console.log('元件已被銷燬');
  }
};

在這個示例中，元件在建立時啟動了一個定時器，並在銷燬前清除這個定時器，以避免記憶體洩漏。destroyed 鉤子簡單地記錄了元件已被銷燬的資訊。透過這種方式，可以確保元件在不再需要時能夠正確地釋放資源，從而最佳化應用程式的效能和記憶體使用。

第 6 章：非同步資料載入

在 Vue.js 中，非同步資料載入是常見的需求，通常透過在生命週期鉤子函式中發起資料請求來實現。以下是如何使用生命週期函式進行資料請求以及在合適的時機取消請求的詳細說明：

6.1 使用生命週期函式進行資料請求

通常，資料請求會在元件的生命週期鉤子函式中發起，特別是 created 或 mounted 鉤子。這兩個鉤子分別在元件例項被建立後和元件掛載到 DOM 後立即呼叫。

示例：在 `created` 鉤子中發起資料請求

export default {
  data() {
    return {
      posts: []
    };
  },
  created() {
    this.fetchPosts();
  },
  methods: {
    async fetchPosts() {
      try {
        const response = await fetch('https://jsonplaceholder.typicode.com/posts');
        const data = await response.json();
        this.posts = data;
      } catch (error) {
        console.error('Error fetching posts:', error);
      }
    }
  }
};

在這個示例中，元件在建立後立即呼叫 fetchPosts 方法來獲取資料。使用 async/await 來處理非同步操作，使得程式碼更加清晰和易於理解。

6.2 在合適的時機取消請求

在某些情況下，可能需要在元件銷燬前取消未完成的請求，以避免潛在的記憶體洩漏或不必要的網路請求。這通常在 beforeDestroy 鉤子中完成。

示例：在 `beforeDestroy` 鉤子中取消請求

假設使用 axios 進行資料請求，並且每個請求都有一個唯一的識別符號，可以使用這個識別符號來取消請求。

import axios from 'axios';
import { ref } from 'vue';

export default {
  data() {
    return {
      cancelTokenSource: ref(null),
      posts: []
    };
  },
  created() {
    this.fetchPosts();
  },
  beforeDestroy() {
    if (this.cancelTokenSource.value) {
      this.cancelTokenSource.value.cancel('元件銷燬前取消請求');
    }
  },
  methods: {
    fetchPosts() {
      this.cancelTokenSource.value = axios.CancelToken.source();
      axios.get('https://jsonplaceholder.typicode.com/posts', {
        cancelToken: this.cancelTokenSource.value.token
      }).then(response => {
        this.posts = response.data;
      }).catch(thrown => {
        if (axios.isCancel(thrown)) {
          console.log(thrown.message); // 輸出：元件銷燬前取消請求
        } else {
          console.error('Error fetching posts:', thrown);
        }
      });
    }
  }
};

在這個示例中，使用 axios 的 CancelToken 來建立一個取消令牌，並在 beforeDestroy 鉤子中使用這個令牌來取消請求。如果請求被取消，axios 會丟擲一個特定的錯誤，可以透過 axios.isCancel 來檢查這個錯誤。

透過這種方式，可以確保在元件不再需要資料時，不會繼續進行不必要的資料請求，從而最佳化效能並減少資源消耗。

第 7 章：元件通訊

在 Vue.js 中，元件通訊是非常重要的話題，可以分為父子元件通訊、兄弟元件通訊和跨層級元件通訊。以下是詳細的說明：

7.1 父子元件通訊

父子元件通訊是最常見的元件通訊方式，在父元件和子元件之間傳遞資料和事件非常簡單。

父元件向子元件傳遞資料

可以使用 props 將資料從父元件傳遞到子元件。

示例：父元件向子元件傳遞資料

<!-- ParentComponent.vue -->
<template>
  <div>
    <child-component :title="parentTitle"></child-component>
  </div>
</template>

<script>
import ChildComponent from './ChildComponent.vue';

export default {
  components: {
    ChildComponent
  },
  data() {
    return {
      parentTitle: 'Hello from parent!'
    };
  }
};
</script>

<!-- ChildComponent.vue -->
<template>
  <div>
    <h1>{{ title }}</h1>
  </div>
</template>

<script>
export default {
  props: {
    title: String
  }
};
</script>

子元件向父元件傳送事件

可以使用 $emit 將事件從子元件傳送到父元件。

示例：子元件向父元件傳送事件

<!-- ParentComponent.vue -->
<template>
  <div>
    <child-component @child-event="handleChildEvent"></child-component>
  </div>
</template>

<script>
import ChildComponent from './ChildComponent.vue';

export default {
  components: {
    ChildComponent
  },
  methods: {
    handleChildEvent(message) {
      console.log('Received message from child:', message);
    }
  }
};
</script>

<!-- ChildComponent.vue -->
<template>
  <div>
    <button @click="sendMessage">Send message to parent</button>
  </div>
</template>

<script>
export default {
  methods: {
    sendMessage() {
      this.$emit('child-event', 'Hello from child!');
    }
  }
};
</script>

7.2 兄弟元件通訊

對於兄弟元件之間的通訊，可以使用一箇中間元件或者透過事件匯流排（event bus）。

使用中間元件

可以使用一箇中間元件來傳遞資料和事件。

示例：使用中間元件

<!-- ParentComponent.vue -->
<template>
  <div>
    <first-child @first-child-event="handleFirstChildEvent"></first-child>
    <second-child :message="firstChildMessage"></second-child>
  </div>
</template>

<script>
import FirstChildComponent from './FirstChildComponent.vue';
import SecondChildComponent from './SecondChildComponent.vue';

export default {
  components: {
    FirstChildComponent,
    SecondChildComponent
  },
  data() {
    return {
      firstChildMessage: null
    };
  },
  methods: {
    handleFirstChildEvent(message) {
      this.firstChildMessage = message;
    }
  }
};
</script>

<!-- FirstChildComponent.vue -->
<template>
  <div>
    <button @click="sendMessage">Send message to second child</button>
  </div>
</template>

<script>
export default {
  methods: {
    sendMessage() {
      this.$emit('first-child-event', 'Hello from first child!');
    }
  }
};
</script>

<!-- SecondChildComponent.vue -->
<template>
  <div>
    <h1>{{ message }}</h1>
  </div>
</template>

<script>
export default {
  props: {
    message: String
  }
};
</script>

使用事件匯流排

可以使用一個全域性事件匯流排來實現兄弟元件之間的通訊。

示例：使用事件匯流排

// main.js
import Vue from 'vue';
export const EventBus = new Vue();

// FirstChildComponent.vue
<template>
  <div>
    <button @click="sendMessage">Send message to second child</button>
  </div>
</template>

<script>
import { EventBus } from './main';

export default {
  methods: {
    sendMessage() {
      EventBus.$emit('first-child-event', 'Hello from first child!');
    }
  }
};
</script>

// SecondChildComponent.vue
<template>
  <div>
    <h1>{{ message }}</h1>
  </div>
</template>

<script>
import { EventBus } from './main';

export default {
  data() {
    return {
      message: null
    };
  },
  created() {
    EventBus.$on('first-child-event', message => {
      this.message = message;
    });
  }
};
</script>

7.3 跨層級元件通訊

對於跨層級元件之間的通訊，可以使用 provide 和 inject 或者使用 Vuex 狀態管理。

使用 `provide` 和 `inject`

可以使用 provide 和 inject 在父元件和子元件之間進行跨層級通訊。

示例：使用 `provide` 和 `inject`

<!-- ParentComponent.vue -->
<template>
  <div>
    <first-child></first-child>
  </div>
</template>

<script>
import FirstChildComponent from './FirstChildComponent.vue';
import SecondChildComponent from './SecondChildComponent.vue';

export default {
  components: {
    FirstChildComponent
  },
  provide() {
    return {
      parentMessage: 'Hello from parent!'
    };
  }
};
</script>

<!-- FirstChildComponent.vue -->
<template>
  <div>
    <second-child></second-child>
  </div>
</template>

<script>
import SecondChildComponent from './SecondChildComponent.vue';

export default {
  components: {
    SecondChildComponent
  },
  inject: ['parentMessage']
};
</script>

<!-- SecondChildComponent.vue -->
<template>
  <div>
    <h1>{{ parentMessage }}</h1>
  </div>
</template>

<script>
export default {
  inject: ['parentMessage']
};
</script>

使用 Vuex

可以使用 Vuex 狀態管理來實現跨層級元件通訊。

示例：使用 Vuex

// store.js
import Vuex from 'vuex';
import Vue from 'vue';

Vue.use(Vuex);

const store = new Vuex.Store({
  state: {
    message: 'Hello from Vuex!'
  },
  mutations: {
    setMessage(state, message) {
      state.message = message;
    }
  }
});

export default store;

// ParentComponent.vue
<template>
  <div>
    <first-child></first-child>
  </div>
</template>

<script>
import { mapMutations } from 'vuex';
import FirstChildComponent from './FirstChildComponent.vue';

export default {
  components: {
    FirstChildComponent
  },
  methods: {
    ...mapMutations(['setMessage'])
  },
  mounted() {
    this.setMessage('Hello from parent!');
  }
};

第 8 章：元件最佳化

在構建大型 Vue.js 應用時，效能和記憶體最佳化是非常重要的。以下是有關元件最佳化的詳細說明。

8.1 效能最佳化

8.1.1 使用 `v-if` 和 `v-for` 時注意順序

在使用 v-if 和 v-for 時，應該優先使用 v-if，因為 v-for 會每次都重新渲染整個列表。如果同時使用 v-if 和 v-for，v-for 應該優先放在 v-if 前面。

8.1.2 使用 `key` 來最佳化 `v-for`

在使用 v-for 時，應該為每個專案提供一個唯一的 key，這可以幫助 Vue.js 跟蹤每個節點的身份，從而提高渲染效能。

8.1.3 使用 `v-once` 渲染靜態內容

如果某個元件的內容在整個生命週期中都不會改變，可以使用 v-once 來渲染靜態內容，以提高渲染效能。

8.1.4 使用 `v-memo` 快取元件

在使用 v-for 時，可以使用 v-memo 來快取元件，以避免重新渲染。

8.1.5 使用 `v-pre` 跳過編譯

如果某個元件的內容不需要被 Vue.js 編譯，可以使用 v-pre 來跳過編譯，以提高渲染效能。

8.1.6 使用 `v-cloak` 隱藏未編譯的Mustache標籤

在使用 Mustache 標籤時，可以使用 v-cloak 來隱藏未編譯的 Mustache 標籤，以避免閃爍。

8.2 記憶體最佳化

8.2.1 使用 `v-if` 和 `v-for` 時注意效能

在使用 v-if 和 v-for 時，應該注意它們的效能影響，避免不必要的渲染。

8.2.2 使用 `v-show` 渲染靜態內容

在使用 v-show 時，可以渲染靜態內容，而不是使用 v-if 建立和銷燬節點。

8.2.3 使用 `Object.freeze` 凍結資料

在使用 Object.freeze 時，可以凍結資料，避免不必要的重新渲染。

8.2.4 使用 `v-once` 渲染靜態內容

在使用 v-once 時，可以渲染靜態內容，而不是每次都重新渲染節點。

8.2.5 使用 `$once` 監聽事件

在使用 $once 時，可以監聽事件，而不是使用 $on 建立永久的監聽器。

8.2.6 使用 `$off` 取消事件監聽

在使用 $off 時，可以取消事件監聽，避免記憶體洩漏。

8.3 避免常見的陷阱

8.3.1 避免使用 `Array.prototype.splice` 修改陣列

在使用 Array.prototype.splice 時，可能會導致 Vue.js 無法檢測到變化，從而導致不必要的重新渲染。

8.3.2 避免使用 `Object.assign` 修改物件

在使用 Object.assign 時，可能會導致 Vue.js 無法檢測到變化，從而導致不必要的重新渲染。

8.3.3 避免使用箭頭函式

在使用箭頭函式時，可能會導致 this 指向不正確，從而導致不必要的重新渲染。

8.3.4 避免使用 `v-html` 和 `v-text` 混合使用

在使用 v-html 和 v-text 時，可能會導致不必要的重新渲染。

8.3.5 避免使用 `v-model` 和 `.sync` 修飾符混合使用

在使用 v-model 和 .sync 修飾符時，可能會導致不必要的重新渲染。

8.3.6 避免使用 `watch` 監聽陣列

在使用 watch 時，可能會導致不必要的重新渲染。

8.3.7 避免使用 `watch` 監聽物件

在使用 watch 時，可能會導致不必要的重新渲染。

8.3.8 避免使用 `deep` 選項

在使用 deep 選項時，可能會導致不必要的重新渲染。

8.3.9 避免使用 `immediate` 選項

在使用 immediate 選項時，可能會導致不必要的重新渲染。

8.3.10 避免使用 `computed` 和 `watch` 混合使用

在使用 computed 和 watch 時，可能會導致不必要的重新渲染。

8.3.11 避免使用 `methods` 和 `computed` 混合使用

在使用 methods 和 computed 時，可能會導致不必要的重新渲染。

8.3.12 避免使用 `created` 和 `mounted` 混合使用

在使用 created 和 mounted 時，可能會導致不必要的重新渲染。

8.3.13 避免使用 `beforeDestroy` 和 `destroyed` 混合使用

在使用 beforeDestroy 和 destroyed 時，可能會導致不必要的重新渲染。

8.3.14 避免使用 `activated` 和 `deactivated` 混合使用

在使用 activated 和 deactivated 時，可能會導致不必要的重新渲染。

8.3.15 避免使用 `keep-alive` 和 `v-if` 混合使用

在使用 keep-alive 和 v-if 時，可能會導致不必要的重新渲染。

8.3.16 避免使用 `transition` 和 `v-if` 混合使用

在使用 transition 和 v-if 時，可能會導致不必要的重新渲染。

8.3.17 避免使用 `v-else` 和 `v-else-if` 混合使用

在使用 v-else 和 v-else-if 時，可能會導致不必要的重新渲染。

8.3.18 避免使用 `v-for` 和 `v-if` 混合使用

在使用 v-for 和 v-if 時，可能會導致不必要的重新渲染。

8.3.19 避免使用 `v-model` 和 `.sync` 修飾符混合使用

在使用 v-model 和 .sync 修飾符時，可能會導致不必要的重新渲染。

8.3.20 避免使用 `v-model` 和 `v-for` 混合使用

在使用 v-model 和 v-for 時，可能會導致不必要的重新渲染。

8.3.21 避免使用 `v-model` 和 `v-show` 混合使用

在使用 v-model 和 v-show 時，可能會導致不必要的重新渲染。

8.3.22 避免使用 `v-model` 和 `v-once` 混合使用

在使用 v-model 和 v-once 時，可能會導致不必要的重新渲染。

8.3.23 避免使用 `v-model` 和 `v-memo` 混合使用

在使用 v-model 和 v-memo 時，可能會導致不必要的重新渲染。

8.3.24 避免使用 `v-model` 和 `v-pre` 混合使用

在使用 v-model 和 v-pre 時，可能會導致不必要的重新渲染。

8.3.25 避免使用 `v-model` 和 `v-cloak` 混合使用

在使用 v-model 和 v-cloak 時，可能會導致不必要的重新渲染。

8.3.26 避免使用 `v-model` 和 `v-html` 混合使用

在使用 v-model 和 v-html 時，可能會導致不必要的重新渲染。

8.3.27 避免使用 `v-model` 和 `v-text` 混合使用

在使用 v-model 和 v-text 時，可能會導致不必要的重新渲染。

8.3.28 避免使用 `v-model` 和 `Object.freeze` 混合使用

在使用 v-model 和 Object.freeze 時，可能會導致不必要的重新渲染。

8.3.29 避免使用 `v-model` 和 `$once` 混合使用

在使用 v-model 和 $once 時，可能會導致不必要的重新渲染。

8.3.30 避免使用 `v-model` 和 `$off` 混合使用

在使用 v-model 和 $off 時，可能會導致不必要的重新渲染。

8.3.31 避免使用 `v-model` 和 `$on` 混合使用

在使用 v-model 和 $on 時，可能會導致不必要的重新渲染。

8.3.32 避免使用 `v-model` 和 `$emit` 混合使用

在使用 v-model 和 $emit 時，可能會導致不必要的重新渲染。

8.3.33 避免使用 `v-model` 和 `$refs` 混合使用

在使用 v-model 和 $refs 時，可能會導致不必要的重新渲染。

8.3.34 避免使用 `v-model` 和 `$nextTick` 混合使用

在使用 v-model 和 $nextTick 時，可能會導致不必要的重新渲染。

8.3.35 避免使用 `v-model` 和 `vm.$forceUpdate` 混合使用

在使用 v-model 和 vm.$forceUpdate 時，可能會導致不必要的重新渲染。

8.3.36 避免使用 `v-model` 和 `vm.$set` 混合使用

在使用 v-model 和 vm.$set 時，可能會導致不必要的重新渲染。

8.3.37 避免使用 `v-model` 和 `vm.$delete` 混合使用

在使用 v-model 和 vm.$delete 時，可能會導致不必要的重新渲染。

8.3.38 避免使用 `v-model` 和 `vm.$watch` 混合使用

在使用 v-model 和 vm.$watch 時，可能會導致不必要的重新渲染。

8.3.39 避免使用 `v-model` 和 `vm.$watch` 深度監聽混合使用

在使用 v-model 和 vm.$watch 深度監聽時，可能會導致不必要的重新渲染。

8.3.40 避免使用 `v-model` 和 `vm.$watch` 立即執行混合使用

在使用 v-model 和 vm.$watch 立即執行時，可能會導致不必要的重新渲染。

8.3.41 避免使用 `v-model` 和 `vm.$set` 陣列混合使用

在使用 v-model 和 vm.$set 陣列時，可能會導致不必要的重新渲染。

8.3.42 避免使用 `v-model` 和 `vm.$delete` 陣列混合使用

在使用 v-model 和 vm.$delete 陣列時，可能會導致不必要的重新渲染。

8.3.43 避免使用 `v-model` 和 `vm.$watch` 陣列混合使用

在使用 v-model 和 vm.$watch 陣列時，可能會導致不必要的重新渲染。

8.3.44 避免使用 `v-model` 和 `vm.$watch` 陣列深度監聽混合使用

在使用 v-model 和 vm.$watch 陣列深度監聽時，可能會導致不必要的重新渲染。

8.3.45 避免使用 `v-model` 和 `vm.$watch` 陣列立即執行混合使用

在使用 v-model 和 vm.$watch 陣列立即執行時，可能會導致不必要的重新渲染。

8.3.46 避免使用 `v-model` 和 `vm.$set` 物件混合使用

在使用 v-model 和 vm.$set 物件時，可能會導致不必要的重新渲染。

8.3.47 避免使用 `v-model` 和 `vm.$delete` 物件混合使用

在使用 v-model 和 vm.$delete 物件時，可能會導致不必要的重新渲染。

8.3.48 避免使用 `v-model` 和 `vm.$watch` 物件混合使用

在使用 v-model 和 vm.$watch 物件時，可能會導致不必要的重新渲染。

Vue 生命週期鉤子
2022-04-14
Vue
Vue生命週期鉤子函式
2019-07-12
Vue函式
Vue生命週期鉤子簡介
2019-06-25
Vue
Vue 生命週期與鉤子函式
2019-08-03
Vue函式
Vue例項的生命週期鉤子
2020-11-06
Vue
vue生命週期鉤子，一張圖片
2017-07-28
Vue
vue[原始碼]生命週期鉤子的實現
2019-04-01
Vue原始碼
vue所有生命週期函式/鉤子函式理解
2018-12-16
Vue函式
Vue父子元件生命週期執行順序及鉤子函式的個人理解
2018-08-11
Vue元件函式
Vue父子元件生命週期
2020-09-19
Vue元件
Vue的鉤子函式[路由導航守衛、keep-alive、生命週期鉤子]
2018-07-23
Vue函式路由Keep-Alive
談談 React 新的生命週期鉤子
2019-03-03
React
Hive Query生命週期 —— 鉤子（Hook）函式篇
2021-01-18
HiveHook函式
對Angular中的生命週期鉤子的理解
2017-07-30
Angular
探索 React 元件之間的生命週期
2019-05-01
React元件
vue父元件和子元件的生命週期到底誰先執行？
2020-11-02
Vue元件
vue總結「三」--元件生命週期
2020-10-24
Vue元件
Angular2生命週期鉤子函式
2017-09-06
Angular函式
Nuxt3 的生命週期和鉤子函式（一）
2024-06-25
UX函式
Nuxt3 的生命週期和鉤子函式（二）
2024-06-26
UX函式
Nuxt3 的生命週期和鉤子函式（三）
2024-06-27
UX函式
Nuxt3 的生命週期和鉤子函式（四）
2024-06-28
UX函式
Nuxt3 的生命週期和鉤子函式（五）
2024-06-29
UX函式
Nuxt3 的生命週期和鉤子函式（六）
2024-06-30
UX函式
Nuxt3 的生命週期和鉤子函式（七）
2024-07-01
UX函式
Nuxt3 的生命週期和鉤子函式（八）
2024-07-02
UX函式
Nuxt3 的生命週期和鉤子函式（九）
2024-07-03
UX函式
Nuxt3 的生命週期和鉤子函式（十）
2024-07-04
UX函式
Nuxt3 的生命週期和鉤子函式（十一）
2024-07-05
UX函式
vue - 生命週期
2019-01-10
Vue
vue生命週期
2024-04-23
Vue
【譯】Vue 的小奇技（第十篇）：監聽第三方元件的生命週期鉤子
2019-03-19
Vue元件
React 元件生命週期
2023-12-08
React元件
React元件生命週期
2018-05-18
React元件
UIAbility元件生命週期
2024-11-07
UI元件
vue 生命週期梳理
2018-10-27
Vue
理解VUE生命週期
2021-01-01
Vue
vue的生命週期
2017-10-10
Vue

Vue 元件生命週期：探索鉤子

第 1 章：介紹與背景

第 2 章：元件生命週期概述

第 3 章：建立階段

第 4 章：執行階段

第 5 章：銷燬階段

第 6 章：非同步資料載入

6.1 使用生命週期函式進行資料請求

示例：在 created 鉤子中發起資料請求

6.2 在合適的時機取消請求

示例：在 beforeDestroy 鉤子中取消請求

第 7 章：元件通訊

7.1 父子元件通訊

父元件向子元件傳遞資料

示例：父元件向子元件傳遞資料

子元件向父元件傳送事件

示例：子元件向父元件傳送事件

7.2 兄弟元件通訊

使用中間元件

示例：使用中間元件

使用事件匯流排

示例：使用事件匯流排

7.3 跨層級元件通訊

使用 provide 和 inject

示例：使用 provide 和 inject

使用 Vuex

示例：使用 Vuex

第 8 章：元件最佳化

8.1 效能最佳化

8.1.1 使用 v-if 和 v-for 時注意順序

8.1.2 使用 key 來最佳化 v-for

8.1.3 使用 v-once 渲染靜態內容

8.1.4 使用 v-memo 快取元件

8.1.5 使用 v-pre 跳過編譯

8.1.6 使用 v-cloak 隱藏未編譯的Mustache標籤

8.2 記憶體最佳化

8.2.1 使用 v-if 和 v-for 時注意效能

8.2.2 使用 v-show 渲染靜態內容

8.2.3 使用 Object.freeze 凍結資料

8.2.4 使用 v-once 渲染靜態內容

8.2.5 使用 $once 監聽事件

8.2.6 使用 $off 取消事件監聽

8.3 避免常見的陷阱

8.3.1 避免使用 Array.prototype.splice 修改陣列

8.3.2 避免使用 Object.assign 修改物件

8.3.3 避免使用箭頭函式

8.3.4 避免使用 v-html 和 v-text 混合使用

8.3.5 避免使用 v-model 和 .sync 修飾符混合使用

8.3.6 避免使用 watch 監聽陣列

8.3.7 避免使用 watch 監聽物件

8.3.8 避免使用 deep 選項

8.3.9 避免使用 immediate 選項

8.3.10 避免使用 computed 和 watch 混合使用

8.3.11 避免使用 methods 和 computed 混合使用

8.3.12 避免使用 created 和 mounted 混合使用

8.3.13 避免使用 beforeDestroy 和 destroyed 混合使用

8.3.14 避免使用 activated 和 deactivated 混合使用

8.3.15 避免使用 keep-alive 和 v-if 混合使用

8.3.16 避免使用 transition 和 v-if 混合使用

8.3.17 避免使用 v-else 和 v-else-if 混合使用

8.3.18 避免使用 v-for 和 v-if 混合使用

8.3.19 避免使用 v-model 和 .sync 修飾符混合使用

8.3.20 避免使用 v-model 和 v-for 混合使用

8.3.21 避免使用 v-model 和 v-show 混合使用

8.3.22 避免使用 v-model 和 v-once 混合使用

8.3.23 避免使用 v-model 和 v-memo 混合使用

8.3.24 避免使用 v-model 和 v-pre 混合使用

8.3.25 避免使用 v-model 和 v-cloak 混合使用

8.3.26 避免使用 v-model 和 v-html 混合使用

8.3.27 避免使用 v-model 和 v-text 混合使用

8.3.28 避免使用 v-model 和 Object.freeze 混合使用

8.3.29 避免使用 v-model 和 $once 混合使用

8.3.30 避免使用 v-model 和 $off 混合使用

8.3.31 避免使用 v-model 和 $on 混合使用

8.3.32 避免使用 v-model 和 $emit 混合使用

8.3.33 避免使用 v-model 和 $refs 混合使用

8.3.34 避免使用 v-model 和 $nextTick 混合使用

8.3.35 避免使用 v-model 和 vm.$forceUpdate 混合使用

8.3.36 避免使用 v-model 和 vm.$set 混合使用

8.3.37 避免使用 v-model 和 vm.$delete 混合使用