Vue3從入門到精通(三)

vue3插槽Slots

在 Vue3 中，插槽（Slots）的使用方式與 Vue2 中基本相同，但有一些細微的差異。以下是在 Vue3 中使用插槽的範例：

// ChildComponent.vue
<template>
  <div>
    <h2>Child Component</h2>
    <slot></slot>
  </div>
</template>
​
// ParentComponent.vue
<template>
  <div>
    <h1>Parent Component</h1>
    <ChildComponent>
      <p>This is the content of the slot.</p>
    </ChildComponent>
  </div>
</template>
​
<script>
  import { defineComponent } from 'vue'
  import ChildComponent from './ChildComponent.vue'
​
  export default defineComponent({
    name: 'ParentComponent',
    components: {
      ChildComponent
    }
  })
</script>

在上面的範例中，ChildComponent 元件定義了一個預設插槽，使用 <slot></slot> 標籤來表示插槽的位置。在 ParentComponent 元件中，使用 <ChildComponent> 標籤包裹了一段內容 <p>This is the content of the slot.</p>，這段內容將被插入到 ChildComponent 元件的插槽位置。

需要注意的是，在 Vue3 中，預設插槽不再具有具名插槽的概念。如果需要使用具名插槽，可以使用 v-slot 指令。以下是一個範例：

// ChildComponent.vue
<template>
  <div>
    <h2>Child Component</h2>
    <slot name="header"></slot>
    <slot></slot>
    <slot name="footer"></slot>
  </div>
</template>
​
// ParentComponent.vue
<template>
  <div>
    <h1>Parent Component</h1>
    <ChildComponent>
      <template v-slot:header>
        <h3>This is the header slot</h3>
      </template>
      <p>This is the content of the default slot.</p>
      <template v-slot:footer>
        <p>This is the footer slot</p>
      </template>
    </ChildComponent>
  </div>
</template>
​
<script>
  import { defineComponent } from 'vue'
  import ChildComponent from './ChildComponent.vue'
​
  export default defineComponent({
    name: 'ParentComponent',
    components: {
      ChildComponent
    }
  })
</script>

在上面的範例中，ChildComponent 元件定義了三個插槽，分別是名為 header、預設插槽和名為 footer 的插槽。在 ParentComponent 元件中，使用 <template v-slot:header> 來定義 header 插槽的內容，使用 <template v-slot:footer> 來定義 footer 插槽的內容。預設插槽可以直接寫在元件標籤內部。

需要注意的是，在 Vue3 中，v-slot 只能用在 <template> 標籤上，不能用在普通的 HTML 標籤上。如果要在普通 HTML 標籤上使用插槽，可以使用 v-slot 的縮寫語法 #。例如，<template v-slot:header> 可以簡寫為 #header。

vue3元件生命週期

在 Vue3 中，元件的生命週期勾點函數與 Vue2 中有一些變化。以下是 Vue3 中常用的元件生命週期勾點函數：

1. beforeCreate: 在範例初始化之後、資料觀測之前被呼叫。

2. created: 在範例建立完成之後被呼叫。此時，範例已完成資料觀測、屬性和方法的運算，但尚未掛載到 DOM 中。

3. beforeMount: 在掛載開始之前被呼叫。在此階段，模板已經編譯完成，但尚未將模板渲染到 DOM 中。

4. mounted: 在掛載完成之後被呼叫。此時，元件已經被掛載到 DOM 中，可以存取到 DOM 元素。

5. beforeUpdate: 在資料更新之前被呼叫。在此階段，虛擬 DOM 已經重新渲染，並將計算得到的變化應用到真實 DOM 上，但尚未更新到檢視中。

6. updated: 在資料更新之後被呼叫。此時，元件已經更新到最新的狀態，DOM 也已經更新完成。

7. beforeUnmount: 在元件解除安裝之前被呼叫。在此階段，元件範例仍然可用，可以存取到元件的資料和方法。

8. unmounted: 在元件解除安裝之後被呼叫。此時，元件範例已經被銷燬，無法再存取到元件的資料和方法。

需要注意的是，Vue3 中移除了一些生命週期勾點函數，如 beforeDestroy 和 destroyed。取而代之的是 beforeUnmount 和 unmounted。

另外，Vue3 中還引入了新的生命週期勾點函數 onRenderTracked 和 onRenderTriggered，用於追蹤元件的渲染過程和觸發的依賴項。

需要注意的是，Vue3 推薦使用 Composition API 來編寫元件邏輯，而不是依賴於生命週期勾點函數。Composition API 提供了 setup 函數，用於元件的初始化和邏輯組織。在 setup 函數中，可以使用 onBeforeMount、onMounted、onBeforeUpdate、onUpdated、onBeforeUnmount 等函數來替代相應的生命週期勾點函數。

vue3生命週期應用

Vue3 的生命週期勾點函數可以用於在元件的不同生命週期階段執行相應的操作。以下是一些 Vue3 生命週期的應用場景範例：

1. beforeCreate 和 created：在元件範例建立之前和建立之後執行一些初始化操作，如設定初始資料、進行非同步請求等。

export default {
  beforeCreate() {
    console.log('beforeCreate hook');
    // 執行一些初始化操作
  },
  created() {
    console.log('created hook');
    // 執行一些初始化操作
  },
};

2. beforeMount 和 mounted：在元件掛載之前和掛載之後執行一些 DOM 操作，如獲取 DOM 元素、繫結事件等。

export default {
  beforeMount() {
    console.log('beforeMount hook');
    // 執行一些 DOM 操作
  },
  mounted() {
    console.log('mounted hook');
    // 執行一些 DOM 操作
  },
};

3. beforeUpdate 和 updated：在元件資料更新之前和更新之後執行一些操作，如更新 DOM、傳送請求等。

export default {
  beforeUpdate() {
    console.log('beforeUpdate hook');
    // 執行一些操作
  },
  updated() {
    console.log('updated hook');
    // 執行一些操作
  },
};

4. beforeUnmount 和 unmounted：在元件解除安裝之前和解除安裝之後執行一些清理操作，如取消訂閱、清除定時器等。

export default {
  beforeUnmount() {
    console.log('beforeUnmount hook');
    // 執行一些清理操作
  },
  unmounted() {
    console.log('unmounted hook');
    // 執行一些清理操作
  },
};

這些範例展示了 Vue3 生命週期勾點函數的一些常見應用場景。根據具體需求，你可以在相應的生命週期勾點函數中執行適當的操作。

vue3動態元件

在 Vue3 中，可以使用動態元件來根據不同的條件或狀態動態地渲染不同的元件。使用動態元件可以使應用更加靈活和可延伸。以下是使用動態元件的範例：

1. 使用 component 元素和 :is 屬性來實現動態元件的渲染：

<template>
  <div>
    <component :is="currentComponent"></component>
    <button @click="toggleComponent">Toggle Component</button>
  </div>
</template>
​
<script>
import ComponentA from './ComponentA.vue';
import ComponentB from './ComponentB.vue';
​
export default {
  data() {
    return {
      currentComponent: 'ComponentA',
    };
  },
  methods: {
    toggleComponent() {
      this.currentComponent = this.currentComponent === 'ComponentA' ? 'ComponentB' : 'ComponentA';
    },
  },
  components: {
    ComponentA,
    ComponentB,
  },
};
</script>

在上面的範例中，根據 currentComponent 的值動態地渲染 ComponentA 或 ComponentB 元件。點選按鈕時，切換 currentComponent 的值，從而實現動態元件的切換。

2. 使用 v-if 和 v-else 來根據條件渲染不同的元件：

<template>
  <div>
    <component-a v-if="showComponentA"></component-a>
    <component-b v-else></component-b>
    <button @click="toggleComponent">Toggle Component</button>
  </div>
</template>
​
<script>
import ComponentA from './ComponentA.vue';
import ComponentB from './ComponentB.vue';
​
export default {
  data() {
    return {
      showComponentA: true,
    };
  },
  methods: {
    toggleComponent() {
      this.showComponentA = !this.showComponentA;
    },
  },
  components: {
    ComponentA,
    ComponentB,
  },
};
</script>

在上面的範例中，根據 showComponentA 的值使用 v-if 和 v-else 來渲染 ComponentA 或 ComponentB 元件。點選按鈕時，切換 showComponentA 的值，從而實現動態元件的切換。

這些範例演示了在 Vue3 中如何使用動態元件來根據條件或狀態動態地渲染不同的元件。你可以根據具體需求選擇適合的方式來使用動態元件。

vue3元件保持存活

在 Vue3 中，可以使用 <keep-alive> 元件來保持元件的存活狀態，即使元件在元件樹中被切換或銷燬，它的狀態仍然會被保留。這對於需要在元件之間共用狀態或快取資料的場景非常有用。以下是使用 <keep-alive> 元件來保持元件存活的範例：

<template>
  <div>
    <button @click="toggleComponent">Toggle Component</button>
    <keep-alive>
      <component :is="currentComponent"></component>
    </keep-alive>
  </div>
</template>
​
<script>
import ComponentA from './ComponentA.vue';
import ComponentB from './ComponentB.vue';
​
export default {
  data() {
    return {
      currentComponent: 'ComponentA',
    };
  },
  methods: {
    toggleComponent() {
      this.currentComponent = this.currentComponent === 'ComponentA' ? 'ComponentB' : 'ComponentA';
    },
  },
  components: {
    ComponentA,
    ComponentB,
  },
};
</script>

在上面的範例中，使用 <keep-alive> 元件將 <component> 包裹起來，這樣在切換元件時，被包裹的元件的狀態將會被保留。點選按鈕時，切換 currentComponent 的值，從而切換要渲染的元件。

需要注意的是，被 <keep-alive> 包裹的元件在切換時會觸發一些特定的生命週期勾點函數，如 activated 和 deactivated。你可以在這些勾點函數中執行一些特定的操作，如獲取焦點、傳送請求等。

<template>
  <div>
    <h2>Component A</h2>
  </div>
</template>
​
<script>
export default {
  activated() {
    console.log('Component A activated');
    // 執行一些操作
  },
  deactivated() {
    console.log('Component A deactivated');
    // 執行一些操作
  },
};
</script>

在上面的範例中，當元件 A 被啟用或停用時，分別在 activated 和 deactivated 勾點函數中輸出相應的資訊。

使用 <keep-alive> 元件可以方便地保持元件的存活狀態，並在元件之間共用狀態或快取資料。

vue3非同步元件

在 Vue3 中，可以使用非同步元件來延遲載入元件的程式碼，從而提高應用的效能和載入速度。非同步元件在需要時才會被載入，而不是在應用初始化時就載入所有元件的程式碼。以下是使用非同步元件的範例：

1. 使用 defineAsyncComponent 函數來定義非同步元件：

<template>
  <div>
    <button @click="loadComponent">Load Component</button>
    <component v-if="isComponentLoaded" :is="component"></component>
  </div>
</template>
​
<script>
import { defineAsyncComponent } from 'vue';
​
const AsyncComponent = defineAsyncComponent(() =>
  import('./Component.vue')
);
​
export default {
  data() {
    return {
      isComponentLoaded: false,
      component: null,
    };
  },
  methods: {
    loadComponent() {
      this.isComponentLoaded = true;
      this.component = AsyncComponent;
    },
  },
};
</script>

在上面的範例中，使用 defineAsyncComponent 函數來定義非同步元件 AsyncComponent。當點選按鈕時，設定 isComponentLoaded 為 true，並將 component 設定為 AsyncComponent，從而載入非同步元件。

2. 使用 Suspense 元件來處理非同步元件的載入狀態：

<template>
  <div>
    <Suspense>
      <template #default>
        <component :is="component"></component>
      </template>
      <template #fallback>
        <div>Loading...</div>
      </template>
    </Suspense>
    <button @click="loadComponent">Load Component</button>
  </div>
</template>
​
<script>
import { defineAsyncComponent, Suspense } from 'vue';
​
const AsyncComponent = defineAsyncComponent(() =>
  import('./Component.vue')
);
​
export default {
  data() {
    return {
      component: null,
    };
  },
  methods: {
    loadComponent() {
      this.component = AsyncComponent;
    },
  },
};
</script>

在上面的範例中，使用 Suspense 元件來處理非同步元件的載入狀態。在 default 插槽中，渲染非同步元件，而在 fallback 插槽中，渲染載入狀態的提示資訊。當點選按鈕時，載入非同步元件。

這些範例演示了在 Vue3 中如何使用非同步元件來延遲載入元件的程式碼。使用非同步元件可以提高應用的效能和載入速度，特別是在應用中有大量元件時。

vue3依賴注入

在 Vue3 中，可以使用依賴注入來在元件之間共用資料或功能。Vue3 提供了 provide 和 inject 兩個函數來實現依賴注入。

1. 使用 provide 函數在父元件中提供資料或功能：

<template>
  <div>
    <ChildComponent></ChildComponent>
  </div>
</template>
​
<script>
import { provide } from 'vue';
import MyService from './MyService';
​
export default {
  setup() {
    provide('myService', new MyService());
  },
};
</script>

在上面的範例中，使用 provide 函數在父元件中提供了一個名為 myService 的資料或功能，它的值是一個 MyService 的範例。

2. 使用 inject 函數在子元件中注入提供的資料或功能：

<template>
  <div>
    <p>{{ message }}</p>
  </div>
</template>
​
<script>
import { inject } from 'vue';
​
export default {
  setup() {
    const myService = inject('myService');
    const message = myService.getMessage();
​
    return {
      message,
    };
  },
};
</script>

在上面的範例中，使用 inject 函數在子元件中注入了父元件提供的名為 myService 的資料或功能。通過注入的 myService 範例，可以呼叫其中的方法或存取其中的屬性。

通過使用 provide 和 inject 函數，可以在元件之間實現依賴注入，從而實現資料或功能的共用。這在多個元件需要存取相同的資料或功能時非常有用。

vue3應用

Vue3 是一個用於構建使用者介面的現代化 JavaScript 框架。它具有響應式資料繫結、元件化、虛擬 DOM 等特性，使得開發者可以更高效地構建互動式的 Web 應用。

下面是一些使用 Vue3 開發應用的步驟：

1. 安裝 Vue3：使用 npm 或 yarn 安裝 Vue3 的最新版本。

npm install vue@next

2. 建立 Vue3 應用：建立一個新的 Vue3 專案。

vue create my-app

3. 編寫元件：在 src 目錄下建立元件檔案，例如 HelloWorld.vue。

<template>
  <div>
    <h1>{{ message }}</h1>
    <button @click="changeMessage">Change Message</button>
  </div>
</template>
​
<script>
import { ref } from 'vue';
​
export default {
  setup() {
    const message = ref('Hello, Vue3!');
​
    const changeMessage = () => {
      message.value = 'Hello, World!';
    };
​
    return {
      message,
      changeMessage,
    };
  },
};
</script>

在上面的範例中，使用 ref 函數建立了一個響應式的資料 message，並在模板中使用它。通過點選按鈕，可以改變 message 的值。

4. 使用元件：在 App.vue 中使用自定義的元件。

<template>
  <div>
    <HelloWorld></HelloWorld>
  </div>
</template>
​
<script>
import HelloWorld from './components/HelloWorld.vue';
​
export default {
  components: {
    HelloWorld,
  },
};
</script>

在上面的範例中，匯入並註冊了自定義的 HelloWorld 元件，並在模板中使用它。

5. 執行應用：在命令列中執行以下命令啟動應用。

npm run serve

這將啟動開發伺服器，並在瀏覽器中開啟應用。

這只是一個簡單的範例，你可以根據實際需求編寫更復雜的元件和應用邏輯。Vue3 還提供了許多其他功能和工具，如路由、狀態管理、單檔案元件等，以幫助你構建更強大的應用。

希望這個簡單的範例能幫助你入門 Vue3 應用的開發！