Vue 考试

1年前 ⋅ 0

1.vuex解决了什么问题（2分）

  1. 中央化状态管理：在复杂的 Vue.js 应用中，多个组件之间可能需要共享状态（数据）。如果这些状态分散在不同组件中，数据流会变得混乱，难以维护。Vuex 提供了一个中央化的状态管理机制，将应用的状态集中存储在一个地方，以便多个组件能够共享和访问相同的数据，而无需通过繁琐的 prop 和事件传递来传递数据。
  2. 状态可预测性：Vuex 强制实施了一种单向数据流的模型，其中状态的更改只能通过提交 mutations 来进行。这确保了状态更改的可预测性，因为只有 mutations 可以修改状态，而且它们都是同步执行的。这使得开发者能够更容易跟踪应用中状态的变化，调试和诊断问题。
  3. 方便的数据共享：Vuex 提供了一种在组件之间共享数据的方便方式。任何组件都可以访问 Vuex 存储的状态，而不必将数据传递给子组件或通过事件来通信。这在大型应用程序中特别有用，因为它简化了组件之间的数据共享和协作。
  4. 开发工具支持：Vuex 提供了强大的开发者工具，用于检查应用状态的变化、时间旅行调试（time-travel debugging）、以及性能分析。这些工具使开发者更容易调试和优化应用。
  5. 模块化：Vuex 支持将应用的状态划分为模块，每个模块都有自己的状态、mutations、actions，以及 getters。这有助于组织和管理大型应用的状态，并将其分解为更小的可维护部分。

总之，Vuex 主要解决了状态管理、数据共享、可维护性和可预测性等与大型 Vue.js 应用相关的问题，使应用的状态管理更加有效和可维护。

2.什么时候适合使用vuex（2分）

  1. 大型应用：当你构建一个大型的 Vue.js 应用，应用中包含多个组件，这些组件需要共享状态或需要在不同组件之间传递数据时，Vuex 是一个非常有用的工具。它可以帮助你管理和维护应用的状态，以便更容易地处理数据流。
  2. 复杂的状态管理：如果你的应用状态相对复杂，包含了多个关联的数据，需要在多个组件之间同步更新，那么使用 Vuex 可以帮助你更清晰地组织和管理这些状态。
  3. 跨组件通信：当你需要实现跨组件通信，即不同组件之间需要共享数据或在一个组件中更新的数据需要立即反映到其他组件时，Vuex 提供了一种集中的数据存储方式，使这种通信更容易。
  4. 可预测的状态管理：如果你需要确保状态更改的可预测性，即状态的变化必须通过 mutations 进行，从而可以更容易追踪状态的变化和调试问题，那么使用 Vuex 可以强制实施这种模型。
  5. 时间旅行调试和性能分析：Vuex 提供了开发者工具，可以用于时间旅行调试（时光旅行式的调试，可以回溯到之前的状态快照）和性能分析。这些工具使开发和调试更加高效。
  6. 模块化和可维护性：如果你希望将应用的状态拆分为模块，以便更好地组织和管理代码，Vuex 的模块系统允许你划分应用状态为多个小块，使应用更容易维护。

尽管 Vuex 是一个强大的工具，但不是所有应用都需要它。对于小型应用或简单的组件通信，使用 Vue.js 的内置状态管理和事件传递机制可能已足够。只有当你的应用变得更复杂、更大型、或需要更强大的状态管理时，再考虑引入 Vuex。在做决定之前，考虑你的应用的规模和需求是非常重要的。

3.vuex中的五个核心属性（10分）

在 Vuex 中，有五个核心属性，它们构成了 Vuex 应用状态管理的核心。这些属性包括：

  1. state：state 是应用中的状态数据。它代表了应用的数据状态，可以被各个组件访问和共享。state 是一个响应式对象，即当状态发生变化时，所有依赖这个状态的视图会自动更新。例如： 

    const store = new Vuex.Store({
state: {
count: 0
}
});

  2. getters：getters 允许你在获取 state 数据时进行计算或转换。它类似于 Vue.js 组件中的计算属性。getters 可以用于派生状态或进行复杂的数据操作，但它们不会修改 state。例如： 

    const store = new Vuex.Store({
state: {
todos: [...]
},
getters: {
completedTodos: state => {
  return state.todos.filter(todo => todo.completed);
}
}
});

  3. mutations：mutations 是用来修改 state 的唯一途径。它们是同步函数，用于描述状态的变更。mutations 接受一个当前状态对象（state）和一个载荷对象，通常用于传递需要修改的数据。例如： 

    const store = new Vuex.Store({
state: {
count: 0
},
mutations: {
increment: (state) => {
  state.count++;
}
}
});

  4. actions：actions 用于处理异步操作、调用 API、或触发多个 mutations。它们可以包含异步代码，例如 HTTP 请求，并且在完成后调用 mutations 来更新 state。actions 接受一个上下文对象，可以访问 state、getters、commit 和 dispatch。例如： 

    const store = new Vuex.Store({
state: {
count: 0
},
mutations: {
increment: (state) => {
  state.count++;
}
},
actions: {
incrementAsync: ({ commit }) => {
  setTimeout(() => {
    commit('increment');
  }, 1000);
}
}
});

  5. modules：modules 允许你将 Vuex 的 state、getters、mutations 和 actions 划分为模块。这对于将大型应用状态拆分为更小的模块以提高可维护性非常有用。每个模块可以拥有自己的 state、getters、mutations 和 actions。例如： 

    const store = new Vuex.Store({
modules: {
moduleA: {
  state: { ... },
  getters: { ... },
  mutations: { ... },
  actions: { ... }
},
moduleB: {
  state: { ... },
  getters: { ... },
  mutations: { ... },
  actions: { ... }
}
}
});

    这五个核心属性一起构成了 Vuex 的核心，用于实现应用状态的集中管理和跟踪。通过这些属性，你可以更容易地管理和维护应用的状态，以及处理状态的变更和异步操作。

    4.怎么修改state中的数据（2分）

    在 Vuex 中，要修改 state 中的数据，你需要使用 mutations 或 actions。mutations 用于同步地修改 state 中的数据，而 actions 用于处理异步操作或触发 mutations 来修改数据。
    以下是如何在 Vuex 中修改 state 中的数据的示例：
    使用 mutations：

  6. 定义 **mutations**：在你的 Vuex store 中定义一个或多个 mutations，每个 mutation 对应一个状态的修改操作。 

    const store = new Vuex.Store({
state: {
count: 0
},
mutations: {
increment(state) {
  state.count++;
},
decrement(state) {
  state.count--;
}
}
});

  7. 触发 **mutations**：在组件中通过 commit 方法触发 mutations 来修改状态。例如，在组件的方法中调用 commit： 

    this.$store.commit('increment');

    这将触发 increment mutation，从而递增 state.count 的值。
    使用 actions：

  8. 定义 **actions**：在 Vuex store 中定义一个或多个 actions，每个 action 可以包含异步操作，并最终通过 commit 触发 mutations 来修改状态。 

    const store = new Vuex.Store({
state: {
count: 0
},
mutations: {
increment(state) {
  state.count++;
}
},
actions: {
incrementAsync(context) {
  setTimeout(() => {
    context.commit('increment');
  }, 1000);
}
}
});

  9. 触发 **actions**：在组件中通过 dispatch 方法触发 actions。例如，在组件的方法中调用 dispatch： 

    this.$store.dispatch('incrementAsync');

    这将触发 incrementAsync action，它会在异步操作后触发 increment mutation，从而递增 state.count 的值。
    综上所述，你可以使用 mutations 或 actions 来修改 state 中的数据，具体取决于操作是否需要同步或异步。mutations 用于同步操作，而 actions 用于处理异步操作。在组件中，你可以使用 commit 来触发 mutations 或 dispatch 来触发 actions。

    5.怎么在组件中调用mutation和action（4分）

    在 Vue.js 中，你可以在组件中调用 Vuex 中的 mutations 和 actions 来修改或处理应用的状态。下面是如何在组件中调用 mutations 和 actions 的示例：
    调用 Mutation：

  10. 定义 Mutation： 首先，在 Vuex store 中定义一个 mutation。例如： 

    // 在 Vuex store 中定义一个 mutation
mutations: {
increment(state) {
state.count++;
}
}

  11. 在组件中调用 Mutation： 在组件中，你可以使用 $store.commit 方法来触发 mutation。例如，在组件的方法中调用： 

    // 在组件中调用 mutation
this.$store.commit('increment');

    这将触发名为 "increment" 的 mutation，从而修改 Vuex store 中的状态。
    调用 Action：

  12. 定义 Action： 首先，在 Vuex store 中定义一个 action。例如： 

    // 在 Vuex store 中定义一个 action
actions: {
incrementAsync(context) {
setTimeout(() => {
  context.commit('increment');
}, 1000);
}
}

  13. 在组件中调用 Action： 在组件中，你可以使用 $store.dispatch 方法来触发 action。例如，在组件的方法中调用： 

    // 在组件中调用 action
this.$store.dispatch('incrementAsync');

    这将触发名为 "incrementAsync" 的 action，它可以包含异步操作，然后在操作完成后触发名为 "increment" 的 mutation 来修改 Vuex store 中的状态。
    总之，你可以使用 $store.commit 来触发 mutations，用于同步修改状态，或使用 $store.dispatch 来触发 actions，用于处理异步操作。在组件中，这些方法允许你与 Vuex store 交互，以便更改或处理应用状态。

    6.怎么在组件中批量使用Vuex的state和getter属性（4分）

    在组件中批量使用 Vuex 的 state 和 getters 属性，你可以使用 mapState 和 mapGetters 辅助函数，它们可以帮助你将多个状态或 getter 属性映射到组件的计算属性，从而使你能够更轻松地在组件中访问这些属性。这可以大大简化组件中的代码。
    首先，确保你已经在组件中引入 Vuex 并创建了 Vuex 实例。以下是使用 mapState 和 mapGetters 的示例：

    
<template>
<div>
<p>Count: {{ count }}</p>
<p>Completed Todos: {{ completedTodos }}</p>
</div>
</template>
在上述示例中，我们使用 `mapState` 和 `mapGetters` 辅助函数将 `state` 中的 `count` 属性和 `getters` 中的 `completedTodos` 属性映射为组件的计算属性。这使你能够在模板中轻松访问这些属性，而不必显式地使用 `this.$store.state` 或 `this.$store.getters`。<br />使用这种方式，你可以方便地批量映射多个状态和 getter 属性，从而使组件代码更清晰和可维护。
<a name="EOPeI"></a>
#### 7.Vuex中action和mutation有什么区别？（8分）
在 Vuex 中，`action` 和 `mutation` 都是用于管理应用状态的关键概念，但它们有不同的用途和区别：

1.  **Mutations (Mutation)：** 
   - **同步操作**：Mutations 是同步操作，用于修改 Vuex 的 `state` 中的数据。它们是纯函数，接收当前的状态对象 (state) 和负载数据 (payload)，并通过这些数据来计算新的状态。由于 mutations 是同步操作，它们在 store 中是按顺序执行的。
   - **唯一途径**：Mutations 是修改状态的唯一途径。这意味着状态的更改必须通过 mutations 来进行，以确保状态更改的可跟踪性和可预测性。

示例： 
```javascript
mutations: {
  increment(state) {
    state.count++;
  }
}
  1. Actions (Action)：
    • 可以包含异步操作：Actions 主要用于处理异步操作，例如数据获取、API 请求等。它们可以包含任意异步代码，并在完成后触发 mutations 来修改 state。Actions 接收一个上下文对象 (context)，其中包含了一些有用的方法和属性，如 commit 用于触发 mutations，dispatch 用于触发其他 actions。
    • 用于业务逻辑：Actions 通常用于处理业务逻辑，尤其是异步逻辑。它们可以包装多个 mutations 操作，以便在一个 actions 中执行一系列 mutations。

示例： 

actions: {
  incrementAsync(context) {
    setTimeout(() => {
      context.commit('increment');
    }, 1000);
  }
}

总结：

  • Mutations 用于同步修改状态，是对 state 的一种直接修改。
  • Actions 用于处理异步操作，执行业务逻辑，可以触发 mutations 来修改 state。
  • Mutations 是必须同步执行的，而 Actions 可以包含异步代码。

通常情况下，你应该使用 Actions 来处理异步操作和业务逻辑，以及触发 Mutations 来修改状态。这种分工有助于保持状态的可预测性和管理复杂的业务逻辑。

8.为什么用vuex模块，怎么用（6分）

使用 Vuex 模块的主要原因是将 Vuex 的状态管理划分为更小、更可维护的模块，特别适用于大型应用，以降低代码的复杂性，增加代码的可维护性。
当应用变得更大或拥有大量状态、mutations、getters 和 actions 时，一个巨大的单一状态树可能会变得难以维护。这时，将状态分解为多个模块，每个模块负责管理相关的状态，可以更好地组织和维护代码。每个模块拥有自己的状态、mutations、getters 和 actions。
以下是如何使用 Vuex 模块的步骤：

  1. 创建 Vuex 模块：在 Vuex store 中，通过 modules 选项创建模块。每个模块是一个对象，包含模块的状态、mutations、getters 和 actions。例如： 

    const store = new Vuex.Store({
modules: {
moduleA: {
  state: { ... },
  mutations: { ... },
  getters: { ... },
  actions: { ... }
},
moduleB: {
  state: { ... },
  mutations: { ... },
  getters: { ... },
  actions: { ... }
}
}
});

  2. 访问模块中的状态和操作：在组件中，你可以通过 $store 对象来访问模块中的状态和操作。你可以使用模块名称来访问模块的状态、getters 和 dispatch actions。例如： 

    
// 访问模块中的状态
this.$store.state.moduleA.someState;

// 访问模块中的 getter this.$store.getters['moduleA/someGetter'];

// 调用模块中的 action this.$store.dispatch('moduleA/someAction');


3.  **使用命名空间**：如果在模块中使用命名空间（namespace），则可以更容易地访问模块中的状态、getters 和 actions，而不必担心命名冲突。在模块中启用命名空间后，你可以直接通过模块名称来访问它的状态和操作。例如： 
```javascript
const store = new Vuex.Store({
  modules: {
    moduleA: {
      namespaced: true, // 启用命名空间
      state: { ... },
      mutations: { ... },
      getters: { ... },
      actions: { ... }
    }
  }
});

// 访问模块中的状态
this.$store.state.moduleA.someState;

// 访问模块中的 getter
this.$store.getters['moduleA/someGetter'];

// 调用模块中的 action
this.$store.dispatch('moduleA/someAction');

使用 Vuex 模块可以更好地组织和维护大型应用的状态管理，减少状态冲突，并提高代码的可维护性。命名空间是可选的，但通常在使用多个模块时，启用命名空间是一个良好的实践。

9.router怎么重定向页面（2分）

在 Vue Router 中，你可以使用 router.push 或 router.replace 方法来进行页面重定向。这两种方法允许你在 JavaScript 中动态地导航到新的路由。

  1. 使用 **router.push** 进行页面重定向:
    router.push 方法用于将用户导航到新的路由，类似于用户点击链接或输入 URL 地址。你可以通过传递目标路由的路径或名称来进行重定向。 
    
// 通过路径进行重定向
this.$router.push('/new-route');

// 通过名称进行重定向 this.$router.push({ name: 'newRouteName' });


2.  **使用 **`**router.replace**`** 进行页面重定向**:<br />`router.replace` 方法用于在不留下历史记录的情况下进行页面重定向，即不会在浏览器的历史记录中留下记录。这在某些情况下很有用，例如登录后将用户重定向到主页。 
```javascript
// 通过路径进行重定向
this.$router.replace('/new-route');

// 通过名称进行重定向
this.$router.replace({ name: 'newRouteName' });

注意，这些方法需要在 Vue 组件中使用，以便访问 $router 对象。通常，在事件处理程序或组件方法中执行重定向操作。
另外，你还可以使用编程式导航的方式来进行路由重定向，例如在用户登录成功后自动将其重定向到特定页面，或根据某些条件来导航到不同的路由。这允许你动态控制页面的导航，而不仅仅依赖于用户的交互行为。

10.怎么配置404页面（2分）

要配置一个自定义的 404 页面，你需要使用你所使用的前端路由框架或服务器配置进行设置。以下是一些常见的情况：

  1. 在前端路由中配置 404 页面：
    • 使用 Vue Router、React Router 或类似的前端路由框架。
    • 在路由配置中添加一个匹配不到任何路由的通配符路由，然后将其重定向到 404 页面。

以 Vue Router 为例： 

const router = new VueRouter({
  routes: [
    // 其他路由配置
    // ...

    // 404 路由，通常放在最后
    { path: '*', component: NotFoundComponent },
  ],
});
  1. 在服务器配置中配置 404 页面：
    • 如果你使用的是后端服务器（例如 Express、Nginx、Apache 等），你可以在服务器配置中设置自定义 404 页面。
    • 在服务器配置中，通常有一个处理 404 错误的路由或规则，你可以将其指向你的自定义 404 页面。

以 Express.js 为例： 

// 在 Express.js 中设置自定义 404 页面
app.use((req, res) => {
  res.status(404).render('404'); // 渲染自定义 404 页面
});
  1. 在静态文件托管服务中配置 404 页面：
    • 如果你使用的是一个静态文件托管服务（例如 GitHub Pages、Netlify 等），通常它们会允许你上传自定义的 404 页面。
    • 你可以将自定义的 404 页面文件上传到指定的目录，然后服务会自动处理 404 请求并显示你的自定义页面。

这些是常见的配置方法，但具体的步骤可能会因你使用的框架、服务器或托管服务而有所不同。根据你的具体情况，选择适合你项目的配置方法，并创建一个自定义的 404 页面来提供更好的用户体验。

11.常见的模块化规范有哪些（2分）常见的模块化规范主要有以下几种：

  1. CommonJS：
    • 最初是 Node.js 的模块系统，现在也可以在前端使用，例如通过 Browserify。
    • 使用 require 导入模块，使用 module.exports 导出模块。
    • 适用于服务器端和前端构建工具（如Webpack）。

示例： 

// 导入模块
const math = require('./math');

// 导出模块
module.exports = math;
  1. AMD (Asynchronous Module Definition)：
    • 适用于浏览器环境，主要用于异步加载模块。
    • 使用 define 定义模块，使用 require 导入模块。
    • RequireJS 是一个常见的 AMD 实现。

示例： 

// 定义模块
define(['dependency1', 'dependency2'], function(dep1, dep2) {
    // 模块内容
});
  1. ES6 模块：
    • ES6（ECMAScript 2015）引入了官方的模块系统，逐渐被前端社区广泛采用。
    • 使用 import 导入模块，使用 export 导出模块。
    • 可以通过工具如 Babel 转换成旧的模块规范以在现有环境中使用。

示例： 

// 导入模块
import { foo, bar } from './module';

// 导出模块
export { baz };
  1. UMD (Universal Module Definition)：
    • 通用模块规范，可以同时在 CommonJS、AMD、和全局环境中使用。
    • 帮助将模块适配到不同的模块系统，以便在不同环境下工作。
  2. SystemJS：
    • 通用模块加载器，支持加载各种模块规范。
    • 可以在浏览器中异步加载模块。

这些模块化规范的选择通常取决于你的项目和工具链。在现代前端开发中，ES6 模块已经成为主要的模块规范，而在构建过程中通常会使用工具（如Webpack、Rollup、Parcel等）来处理模块。不过，对于遗留项目或特定需求，其他规范仍然有它们的用武之地。

12.路由有几种模式，有什么区别（6分）

在前端路由中，有两种主要的路由模式：哈希路由模式（Hash Mode）和历史路由模式（History Mode）。它们之间的主要区别在于路由的 URL 形式和服务器的配置要求。

  1. 哈希路由模式（Hash Mode）：
    • URL 格式：使用哈希（#）来表示路由。
    • 示例 URL：http://example.com/#/route
    • 主要特点：URL 中的哈希部分不会被发送到服务器，因此在前端路由中使用哈希可以避免与服务器的通信，不需要特殊的服务器配置。
    • 优点：容易部署，不需要服务器配置；可以在静态文件托管服务中使用。
    • 缺点：URL 中的哈希符号可能看起来不太友好；不适用于一些 SEO 方案；在某些情况下，浏览器会在历史记录中留下大量哈希记录。
  2. 历史路由模式（History Mode）：
    • URL 格式：使用常规 URL 形式，不包含哈希。
    • 示例 URL：http://example.com/route
    • 主要特点：需要服务器配置，以确保在客户端路由变化时服务器不返回 404 错误；通常使用 HTML5 History API 来实现。
    • 优点：更友好的 URL 格式；适用于 SEO，搜索引擎可以更好地索引内容；不会在历史记录中留下大量记录。
    • 缺点：需要特殊的服务器配置，以确保在客户端路由变化时返回正确的内容；可能需要对服务器进行配置和处理。

要选择使用哪种路由模式，通常取决于项目的需求和部署环境：

  • 如果你的项目只是一个单页应用，并且不需要考虑 SEO，那么哈希路由模式可能是一个更简单的选择，因为它不需要特殊的服务器配置。
  • 如果你的项目需要更友好的 URL，SEO 是一个重要考虑因素，或者你希望在不同路由之间刷新页面时不产生 404 错误，那么历史路由模式可能更适合，但需要服务器配置支持。

不同的前端框架和库通常都支持这两种路由模式，因此你可以根据项目的需求来选择适合的路由模式。

13.路由守卫怎么写，参数都有什么，可以干什么（10分）

路由守卫是 Vue Router 中的一个重要功能，用于在导航过程中对路由进行拦截和控制。你可以在路由守卫中执行各种操作，如验证用户权限、重定向、取消导航等。以下是一些常见的路由守卫及其参数和用途：

  1. 全局前置守卫 (Global Before Guards):

    • 参数：to（即将要进入的路由对象）、from（即将离开的路由对象）、next（函数，用于控制路由的导航）
    • 用途：执行一些前置检查，如身份验证、权限检查，以确定是否允许导航到新路由。通过调用 next 控制是否继续导航或中断导航。 
      router.beforeEach((to, from, next) => {
// 示例：检查用户是否已登录，如果未登录，则重定向到登录页面
if (!userIsLoggedIn) {
next('/login');
} else {
next();
}
});

  2. 全局解析守卫 (Global Resolve Guards):

    • 参数：与全局前置守卫相同
    • 用途：执行一些解析操作，通常在导航到新路由之前被调用，但与全局前置守卫不同，不会中断导航。 
      router.beforeResolve((to, from, next) => {
// 示例：在导航前确保数据已加载
loadDataForRoute(to).then(() => {
next();
});
});

  3. 全局后置守卫 (Global After Hooks):

    • 参数：to（进入的目标路由对象）、from（离开的路由对象）
    • 用途：通常用于记录日志或分析，不会影响导航本身。 
      router.afterEach((to, from) => {
// 示例：记录导航日志
logNavigation(to, from);
});

  4. 路由独享守卫 (Per-Route Guard):

    • 参数：beforeEnter 函数，包含 to、from 和 next 参数
    • 用途：在单个路由的配置中定义的守卫，只会在该路由的导航中执行。 
      const route = {
path: '/example',
component: Example,
beforeEnter: (to, from, next) => {
// 示例：路由独享守卫，用于特定路由的拦截
if (userIsAllowedToEnter) {
next();
} else {
next('/forbidden');
}
}
};

      这些路由守卫提供了丰富的控制和灵活性，允许你在路由导航中执行各种操作，以满足应用程序的需求。你可以根据项目的需求来选择使用哪种守卫，或者结合多种守卫以实现复杂的导航逻辑。

      14.怎么给路由添加信息，在路由守卫中怎么获取（4分）

      在 Vue Router 中，你可以给路由添加额外的信息，通常通过在路由配置对象中的 meta 字段中添加信息。这些信息可以是任何自定义的数据，用于描述路由或用于路由守卫中的逻辑。以下是如何添加和获取路由的元信息：
      添加路由元信息：
      你可以在路由配置中的 meta 字段中添加信息。例如：

const routes = [
  {
    path: '/dashboard',
    component: Dashboard,
    meta: { requiresAuth: true } // 添加一个名为 requiresAuth 的元信息
  },
  // 其他路由配置
];

在上面的示例中，我们为 /dashboard 路由添加了一个名为 requiresAuth 的元信息，用于标识该路由需要用户身份验证。
获取路由元信息：
你可以在路由守卫中通过路由对象来获取路由的元信息。在路由守卫中，to 参数包含即将进入的路由对象，你可以从这个对象中获取元信息。例如：

router.beforeEach((to, from, next) => {
  // 获取路由的元信息
  const requiresAuth = to.meta.requiresAuth;

  if (requiresAuth) {
    // 如果路由需要身份验证，执行相应的逻辑
    if (userIsLoggedIn) {
      next(); // 继续导航
    } else {
      next('/login'); // 重定向到登录页
    }
  } else {
    next(); // 不需要身份验证，继续导航
  }
});

在上述示例中，我们通过 to.meta.requiresAuth 获取了路由的元信息，并根据它执行不同的导航逻辑。
路由的元信息非常有用，因为它们可以用于在路由守卫中进行条件检查、权限验证、页面标题设置以及其他自定义逻辑。你可以根据项目需求自由地定义和使用路由的元信息。

15.简述路由的两种传参方式及怎么获取（10分）

在前端路由中，有两种常见的传参方式：路由参数（Route Parameters）和查询参数（Query Parameters）。下面简要描述这两种传参方式以及如何获取它们：

  1. 路由参数（Route Parameters）：
    • 路由参数是通过路由路径中的占位符来传递的，通常用于标识唯一的资源或页面。
    • 例如，在路由路径中定义一个占位符 :id，可以通过不同的 id 值来访问不同的资源。
    • 获取路由参数：在路由组件中，可以通过 $route.params 对象来获取路由参数。

示例： 

const routes = [
  { path: '/user/:id', component: UserProfile }
];

获取路由参数： 

// 在组件中获取路由参数
this.$route.params.id;
  1. 查询参数（Query Parameters）：
    • 查询参数通常用于传递可选的、附加的信息，如搜索关键字、过滤条件等。
    • 查询参数出现在 URL 中的 ? 后，可以包含多个键值对，每个键值对以 key=value 形式表示，键值对之间使用 & 分隔。
    • 获取查询参数：在路由组件中，可以通过 $route.query 对象来获取查询参数。

示例： 

// URL 示例：http://example.com/search?query=vue&category=frontend

获取查询参数： 

// 在组件中获取查询参数
this.$route.query.query; // 返回 'vue'
this.$route.query.category; // 返回 'frontend'

这两种传参方式在前端路由中非常常见，可以根据你的项目需求来选择使用哪种方式。路由参数通常用于标识唯一资源，而查询参数通常用于传递可选的参数和过滤条件。在路由组件中，你可以通过 $route.params 获取路由参数，通过 $route.query 获取查询参数，以访问和使用这些参数。

16.写出三种跳转路由的方法（8分）

在 Vue Router 中，有多种方法可以进行路由跳转。以下是其中三种常见的跳转路由的方法：

  1. 使用**<router-link>**组件：
    Vue Router提供了<router-link>组件，它可以用于生成导航链接，它会自动处理路由的跳转。你可以在模板中使用它来创建可点击的导航链接。 

    <router-link to="/about">Go to About Page</router-link>

  2. 使用**this.$router.push**：
    在组件的JavaScript代码中，你可以使用this.$router.push方法来进行路由跳转。你可以将目标路由路径或路由对象传递给它。 

    
// 通过路径跳转
this.$router.push('/about');

// 通过路由对象跳转 this.$router.push({ path: '/about' });


3.  **使用编程式导航**：<br />编程式导航是在 JavaScript 代码中手动触发路由跳转的方法。它通常用于在某些条件下进行路由跳转，例如在异步操作完成后跳转或根据用户的交互行为跳转。 
```javascript
// 根据某些条件进行路由跳转
if (conditionIsMet) {
  this.$router.push('/about');
}

这些方法允许你根据不同的需求来进行路由跳转。你可以根据具体情况选择使用其中的一种或多种方法。

17.$route和$router有什么区别（8分）

$route 和 $router 是 Vue Router 中的两个不同的对象，用于处理路由相关的信息和操作。它们有以下不同点：

  1. $route：
    • $route 是一个表示当前活动路由的对象，提供了有关当前路由的信息，如路由路径、参数、查询参数、哈希等。
    • 它是一个只读对象，用于获取当前路由的信息。
    • 通常在组件的模板或计算属性中使用。

示例： 

<template>
  <div>
    <p>Current Route Path: {{ $route.path }}</p>
    <p>Query Parameter: {{ $route.query.param }}</p>
  </div>
</template>
  1. $router：
    • $router 是 Vue Router 的路由实例，它提供了路由的方法，如路由导航、跳转、前进、后退等。
    • 通过 $router，你可以在组件的 JavaScript 代码中编程式地控制路由。
    • 它允许你触发路由的跳转，而不仅仅是获取路由信息。

示例： 

// 在组件的方法中使用 $router 来进行编程式导航
methods: {
  navigateToAboutPage() {
    this.$router.push('/about');
  }
}

总结：$route 用于获取当前路由的信息，而 $router 用于编程式地进行路由操作和导航。它们分别用于不同的路由相关任务，但都是 Vue Router 提供的重要对象，用于实现路由控制和导航。

18.写出组件切换的三种方式（10分）

在 Vue 中，你可以使用不同的方式实现组件切换，以下是三种常见的方式：

  1. 使用**<component>**元素：
    使用<component>元素可以动态地渲染不同的组件，通常根据某个条件或状态的变化来切换组件。这个条件可以是一个 data 中的属性或计算属性。 

    <template>
<div>
<button @click="toggleComponent">Toggle Component</button>
<component :is="currentComponent"></component>
</div>
</template>
<script>
export default {
data() {
  return {
    currentComponent: 'FirstComponent',
  };
},
methods: {
  toggleComponent() {
    this.currentComponent = this.currentComponent === 'FirstComponent' ? 'SecondComponent' : 'FirstComponent';
  },
},
};
</script>

  2. 使用**v-if**和**v-else**：
    你可以使用v-if和v-else指令来条件性地渲染组件。这种方法适用于只有两个状态的组件切换。 

    <template>
<div>
<button @click="toggleComponent">Toggle Component</button>
<FirstComponent v-if="showFirstComponent" />
<SecondComponent v-else />
</div>
</template>
<script>
export default {
data() {
  return {
    showFirstComponent: true,
  };
},
methods: {
  toggleComponent() {
    this.showFirstComponent = !this.showFirstComponent;
  },
},
};
</script>

  3. 使用动态路由：
    如果你希望根据路由来切换组件，你可以使用动态路由。在路由配置中定义多个路由，每个路由对应一个组件，然后通过路由参数来切换。 

    const routes = [
{ path: '/component/:id', component: ComponentSwitcher, props: true },
];
    <template>
<div>
<button @click="toggleComponent(1)">Show Component 1</button>
<button @click="toggleComponent(2)">Show Component 2</button>
<router-view :key="componentKey" />
</div>
</template>
<script>
export default {
data() {
  return {
    componentKey: 0,
  };
},
methods: {
  toggleComponent(id) {
    this.componentKey = id;
  },
},
};
</script>

    这些方法可以根据项目的需要和组件的复杂度来选择。<component> 元素允许你动态渲染任意数量的组件，v-if 和 v-else 适用于仅有两个状态的组件切换，而动态路由允许你基于路由参数来切换不同的组件。

    10.Vuex中action通常是异步的，那么如何知道action什么时候结束呢？（2分）

    在 Vuex 中，你可以知道一个异步的 action 什么时候结束，有几种方法可以实现：

  4. 使用 Promise：
    在 Vuex 的 action 中，你可以返回一个 Promise 对象，然后在组件中调用这个 action 时，可以使用 .then() 方法来监听 Promise 的解析。这样可以知道 action 何时完成。 

    // Vuex 中的 action
actions: {
async fetchData({ commit }) {
const data = await fetchDataFromServer();
commit('SET_DATA', data);
return data;
}
}
    // 在组件中调用 action
this.$store.dispatch('fetchData').then(data => {
// 在这里可以处理数据
});

  5. 使用 **async/await**：
    如果你的 JavaScript 环境支持 async/await，你可以直接在组件中使用 await 关键字来等待异步 action 完成。 

    // 在组件中调用 action 使用 async/await
async fetchData() {
const data = await this.$store.dispatch('fetchData');
// 在这里可以处理数据
}

  6. 使用回调函数：
    你可以在异步 action 中传递一个回调函数，当异步操作完成后，调用这个回调函数。 

    // Vuex 中的 action
actions: {
fetchData({ commit }, callback) {
fetchDataFromServer().then(data => {
  commit('SET_DATA', data);
  if (callback) {
    callback(data);
  }
});
}
}
    // 在组件中调用 action
this.$store.dispatch('fetchData', data => {
// 在这里可以处理数据
});

    这些方法允许你在异步 action 完成后执行一些后续操作或处理数据。你可以根据你的需求选择最适合的方式来知道异步 action 何时结束。