前端

服务端

计算机基础

Vue.js（简称 Vue）是一种开源的轻量级 JavaScript 框架，由 Evan You 于2014年首次发布。Vue 致力于在用户界面（UI）开发中实现数据与视图的双向绑定，为创建现代化 Web 应用、单页面应用（SPA）以及多种复杂界面提供了一种简洁、高效且可扩展的解决方案。

#### 核心特性

- **组件化：** Vue 包含了独立的、可复用的组件，有助于将 UI 切成逻辑部分、提高代码质量。
- **双向数据绑定：** 利用双向数据绑定，Vue 能自动更新 UI，对应数据模型发生改变时同步更新视图。
- **声明式渲染：** 编写模板完成数据驱动的视图，自动追踪依赖关系，并且在数据模型发生更改时仅重新计算最小必要部分。
- **虚拟DOM：** 通过 Vue 的虚拟 DOM 进行更效率的视图更新，降低视图更新所需的计算量。
- **响应式系统：** Vue 拥有一个响应式系统，当数据更改时会自动跟踪和更新所有相关视图。
- **易于集成：** Vue 可与其他 JavaScript 库或现有项目相互集成，同时方便和流行的前端工具链合作。

#### 主要模块

- **Vue Router：** 官方提供的路由管理器，有助于构建单页面应用程序。
- **Vuex：** 是一个状态管理库，有助于简化和规范在组件之间共享的数据和方法。
- **Vue CLI：** 是一个命令行工具，匹配各种扩展，有助于快速搭建 Vue 项目，包括开发、构建和部署。

#### 适用场景

- 单页面应用（SPA）开发：在单一页面中完成路由切换、状态管理和 UI 渲染等流程。
- Web 应用程序开发： Vue 可与其他库如 Axios 结合，方便地建立发起 HTTP 请求的 API 客户端。
- 组件库和 UI 框架：借助 Vue 的组件系统，可以构建封装的、具有丰富功能的 UI 组件和框架。
- 原型开发：使用 Vue 快速构建和验证产品原型，提高开发效率。

Vue 因易于入门、高度灵活、丰富的生态系统以及优异的性能而受到许多开发者的欢迎，是 Web 开发领域一种非常值得学习的前端框架。

在Vue.js的Composition API中，逻辑复用是通过使用可组合函数（composables）来实现的。可组合函数是可以封装和重用Vue组件逻辑的函数。Composition API引入了一种新的组织和重用组件逻辑的方式，它提供了更灵活的代码组织结构，使得函数的复用变得更加简单和清晰。

要实现逻辑复用，你可以按照以下步骤操作：

1. **创建可组合函数（composables）：**你可以创建一个独立的JavaScript函数，这个函数利用Composition API中的`ref`, `reactive`, `computed`, `watch`, `watchEffect`等响应性API来创建和管理状态或逻辑。

2. **在组件中使用可组合函数：**在Vue组件的`setup`函数中，你可以引入和使用这些可组合函数。这样，你就可以在多个组件之间共享和重用相同的逻辑，而无需复制代码。

3. **传递参数和返回值：**可组合函数可以接受参数并返回一些响应式引用、方法或其他值，这使得它们可以与组件进行交互并根据组件的需要进行调整。

下面我将通过一个简单的例子来说明这一过程：

假设我们有一个用于处理用户信息的逻辑，这部分逻辑需要在多个组件中复用。我们可以创建一个名为`useUser`的可组合函数来封装这部分逻辑。

```javascript
// useUser.js
import { ref } from 'vue';

export function useUser() {
  const user = ref(null);
  const isLoading = ref(false);

  async function loadUser(userId) {
    isLoading.value = true;
    try {
      const response = await fetch(`/api/users/${userId}`);
      user.value = await response.json();
    } catch (error) {
      console.error('Failed to load user', error);
    } finally {
      isLoading.value = false;
    }
  }

  return { user, isLoading, loadUser };
}
```

在上面的例子中，`useUser`函数创建了一个用户信息的响应式引用`user`和一个加载状态的响应式引用`isLoading`。它还提供了一个异步函数`loadUser`来加载用户数据。

现在，我们可以在组件中使用这个可组合函数了：

```javascript
// UserProfile.vue
<template>
  
</template>

<script>
import { onMounted } from 'vue';
import { useUser } from './useUser';

export default {
  setup() {
    const { user, isLoading, loadUser } = useUser();

    onMounted(() => {
      loadUser('123'); // 假设'123'是用户ID
    });

    return { user, isLoading };
  }
};
</script>
```

在`UserProfile.vue`组件的`setup`函数中，我们引入并调用`useUser`可组合函数，并在组件被挂载时调用`loadUser`函数来加载用户数据。这样，`user`和`isLoading`就可以在组件的模板中直接使用了。

这种方法不仅使得代码更加清晰和易于维护，而且还提高了代码的复用性。通过这种方式，我们可以将逻辑抽离出来，并在多个组件之间共享。

Composition API 如何实现逻辑复用

Composition API 和 Options API 是 Vue.js 框架中用于创建和组织组件的两种不同的API。Vue.js 是一个流行的前端JavaScript框架，用于构建用户界面和单页应用程序。下面我将详细说明它们之间的区别：

### Options API

Options API 是 Vue.js 最初提供的接口，它是基于一个包含描述组件选项的对象的概念。这些选项包括了`data`、`methods`、`props`、`computed`、`watch`、`lifecycle hooks`等属性。这种API的特点是将组件的不同方面划分到这些选项中，代码按功能组织。

**例子**：

```javascript
export default {
  data() {
    return {
      message: 'Hello Vue!',
    };
  },
  props: {
    user: String,
  },
  computed: {
    normalizedUser() {
      return this.user.trim().toLowerCase();
    },
  },
  methods: {
    sayHello() {
      alert(this.message);
    },
  },
};
```

在这个例子中，`data`是组件的状态，`props`是外部传入的属性，`computed`是计算属性，`methods`是组件的方法。

**优点**：

- 易于理解和上手，特别是对于初学者。
- 由于选项类型的组织方式，IDEs 和静态类型检查工具通常可以提供更好的支持。

**缺点**：

- 在大型和复杂的组件中，相互关联的逻辑会被拆分到不同的选项中，导致代码维护和理解上的困难。
- 当组件变得庞大时，相同功能的代码可能散布在不同的选项中，难以追踪和组织。

### Composition API

Composition API 是在 Vue.js 3 中引入的，旨在解决 Options API 在构建大型应用时遇到的问题。它提供了更加灵活的方式来组织和重用代码。使用Composition API，开发者可以更容易地将组件逻辑基于功能划分和抽象成可复用的函数。

**例子**：

```javascript
import { ref, computed } from 'vue';

export default {
  setup(props) {
    const message = ref('Hello Vue!');
    const normalizedUser = computed(() => props.user.trim().toLowerCase());

    function sayHello() {
      alert(message.value);
    }

    return {
      message,
      normalizedUser,
      sayHello,
    };
  },
  props: {
    user: String,
  },
};
```

在这个例子中，`setup`函数是组件中所有Composition API逻辑的起点。通过导入`ref`和`computed`，我们可以定义响应式状态和计算属性。`setup` 函数返回的对象将定义组件的响应式状态和方法。

**优点**：

- 更好的逻辑复用和抽象，便于开发者根据功能组织代码，使得代码更加模块化。
- 更容易控制变量的作用域和生命周期。
- 更好地与TypeScript集成，提升类型推断的能力和开发体验。

**缺点**：

- 学习曲线相对较陡峭，特别是对于那些习惯于 Options API 的开发者。
- 尽管它提供了更大的灵活性，但在小型项目或简单组件中可能会引入不必要的复杂性。

### 结论

Options API 和 Composition API 都是 Vue.js 提供的强大工具，它们各有优势。选择哪种API取决于项目的需求、组件的复杂性以及开发团队的偏好。Composition API 在处理大型项目和复杂组件时优势明显，而Options API 在小型项目或对于新手更

Composition API和Options API 之间的区别是什么

在Vue.js中，组件之间的通信是一个非常重要的话题，因为它关系到应用程序如何将数据和事件在多个组件之间传递。Vue提供了多种组件通信的方式，适用于不同的场景。下面是一些常见的通信方式：

### 1. Props 和 Events

这是最基本也是最常用的组件间通信方式。父组件通过props向子组件传递数据，子组件通过事件向父组件发送消息。

**例子**：
在父组件中：
```vue
<template>
  <Child :parentData="data" @childEvent="handleEvent"/>
</template>

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

export default {
  components: { Child },
  data() {
    return {
      data: 'data from parent',
    };
  },
  methods: {
    handleEvent(payload) {
      console.log('Event received from child:', payload);
    },
  },
};
</script>
```

在子组件中：
```vue
<template>
  <button @click="sendToParent">Send to Parent</button>
</template>

<script>
export default {
  props: ['parentData'],
  methods: {
    sendToParent() {
      this.$emit('childEvent', 'data from child');
    },
  },
};
</script>
```

### 2. Event Bus

Event bus 是一种使用Vue实例作为中央事件总线的方法，在不直接关联的组件之间传递消息。

**例子**：
```javascript
// eventBus.js
import Vue from 'vue';
export const EventBus = new Vue();
```

在发送事件的组件中：
```javascript
import { EventBus } from './eventBus.js';

export default {
  methods: {
    sendEvent() {
      EventBus.$emit('do-something', 'some data');
    },
  },
};
```

在接收事件的组件中：
```javascript
import { EventBus } from './eventBus.js';

export default {
  created() {
    EventBus.$on('do-something', data => {
      console.log(data);
    });
  },
};
```

### 3. Vuex

Vuex是Vue.js的状态管理库，可以用来管理所有组件的共享状态，是一种全局的通信方式。

**例子**：
```javascript
// store.js
import Vue from 'vue';
import Vuex from 'vuex';

Vue.use(Vuex);

export default new Vuex.Store({
  state: {
    message: '',
  },
  mutations: {
    updateMessage(state, message) {
      state.message = message;
    },
  },
});
```

在一个组件中更新状态：
```vue
<template>
  <button @click="update">Update Message</button>
</template>

<script>
import { mapMutations } from 'vuex';

export default {
  methods: {
    ...mapMutations([
      'updateMessage', // 映射 this.updateMessage() 为 this.$store.commit('updateMessage')
    ]),
    update() {
      this.updateMessage('Hello from Component A');
    },
  },
};
</script>
```

在另一个组件中获取状态：
```vue
<template>
  <div>{{ message }}</div>
</template>

<script>
import { mapState } from 'vuex';

export default {
  computed: {
    ...mapState([
      'message', // 映射 this.message 为 this.$store.state.message
    ]),
  },
};
</script>
```

### 4. Provide / Inject

这是一种在更深层次的嵌套组件中传递数据的方法，不需要通过每个组件层次传递props。

**例子**：
在祖先组件中：
```vue
<script>
export default {
  provide() {
    return {
      theme: 'dark',
    };
  },
};
</script>
```

在任意后代组件中：
```vue
<script>
export default {
  inject: ['theme'],
  mounted() {
    console.log(this.theme); // 输出: 'dark'
  },
};
</script>
```

这些通信方式各有优缺点，适用于不同的场景和需求，通常在实际开发中需要根据应用的具体需求来选择合适的通信方式。

Vue组件之间通信方式有哪些

事件总线是一种模式，可以通过一个中央通道分发事件，让不同的系统部分实现解耦。在Vue.js中，事件总线通常是通过一个空的Vue实例来实现的。 

以下是我如何在Vue项目中实现一个事件总线，以及我可能会用到它的一个场景：

### 实现事件总线

1. 创建事件总线：

```javascript
// event-bus.js
import Vue from 'vue';
export const EventBus = new Vue();
```

2. 在组件中使用事件总线：

**发射事件**:

```javascript
// ComponentA.vue
<template>
  
</template>

<script>
import { EventBus } from './event-bus.js';

export default {
  methods: {
    someMethod() {
      EventBus.$emit('my-event', { someData: 'Some data to send' });
    }
  }
}
</script>
```

**监听事件**:

```javascript
// ComponentB.vue
<template>
  
</template>

<script>
import { EventBus } from './event-bus.js';

export default {
  mounted() {
    EventBus.$on('my-event', this.handleMyEvent);
  },
  beforeDestroy() {
    EventBus.$off('my-event', this.handleMyEvent);
  },
  methods: {
    handleMyEvent(payload) {
      console.log('Event received', payload);
      // 处理事件
    }
  }
}
</script>
```

在这个例子中，`ComponentA` 发射了一个事件 `my-event`，并传递了一些数据。`ComponentB` 监听这个事件，并定义了一个方法 `handleMyEvent` 来处理接收到的事件。

### 例子：事件总线的使用场景

假设我们有一个应用，其中有一个组件负责用户的认证（例如登录状态的显示），而另一个组件是一个模态框，用于登录。这两个组件位于不同的层级，也可能不直接相关。

我们不希望在每个需要知道登录状态的组件中都直接与模态框组件通信，因为这会导致高耦合和难以维护的代码。

在这种情况下，事件总线就派上了用场：

- 当用户在模态框中登录成功后，模态框组件可以发射一个事件，比如 `login-success`。
- 认证组件可以监听 `login-success` 事件，并据此更新用户的显示状态。

这样，我们就可以保持组件间的解耦，同时使它们能够有效地沟通。

### 注意事项

Vue 2.x中支持使用 `$on`, `$emit`, 和 `$off` 这样的实例方法来实现事件总线。然而，在Vue 3.x中，这种模式已经不再推荐，因为它违背了Vue 3推崇的Composition API的设计原则。在Vue 3中，推荐使用 `provide`/`inject`、Vuex或者Vue Composition API中的 `reactive`、`ref`以及 `watchEffect`来在组件间共享状态。

结合 Vue 项目实现事件总线 Event Bug

在Vue中，`watch`和`watchEffect`是两种响应式侦听器，都能够对响应式状态的变化作出反应，但是它们的工作方式和使用场景有所不同。

### watch

`watch` API 允许我们侦听特定的数据源，并在数据源改变时执行回调函数。它是响应式系统的一部分，非常适合于执行异步操作或比较昂贵的操作，因为你可以精确控制何时以及如何响应状态的变化。

- **精确性**: `watch`允许你指定确切的响应式引用或计算属性来侦听。
- **懒执行**: `watch`默认情况下不会立即执行回调，它只会在侦听的响应式源发生变化时才执行。
- **深度监听**: `watch`可以配置为深度监听，侦听对象内部属性的变化。
- **旧值和新值**: `watch`回调提供新旧值，便于比较。
- **停止监听**: `watch`返回一个停止观察函数，你可以用它来停止监听。

**例子**:

```vue
<template>
  <div>{{ count }}</div>
</template>

<script>
export default {
  data() {
    return {
      count: 0
    }
  },
  watch: {
    count(newVal, oldVal) {
      // 当 count 改变时，这个函数将被调用
      console.log(`Count changed from ${oldVal} to ${newVal}`);
    }
  }
}
</script>
```

### watchEffect

`watchEffect`是一个响应式侦听器，它自动追踪它的函数内部使用的任何响应式状态，当这些状态改变时会重新执行该函数。

- **自动追踪**: `watchEffect`会自动侦听函数内部所有的响应式引用，并在引用更新时重新运行。
- **立即执行**: `watchEffect`在创建时会立即执行一次，确保响应式效果与当前的状态同步。
- **无需指定侦听源**: 不需要像`watch`那样指定侦听的具体状态，它会自动收集依赖。
- **无旧值**: `watchEffect`不提供旧值，因为它不侦听特定的数据源。
- **停止监听**: `watchEffect`同样返回一个停止监听的函数。

**例子**:

```vue
<template>
  <div>{{ count }}</div>
</template>

<script>
import { ref, watchEffect } from 'vue';

export default {
  setup() {
    const count = ref(0);

    watchEffect(() => {
      // 这个函数会在 setup() 时立即执行一次，并在 count 改变时再次执行
      console.log(`Count is now: ${count.value}`);
    });
    
    return { count };
  }
}
</script>
```

总结一下，`watch`更适用于当你需要侦听特定数据并在变化时进行比较或执行复杂逻辑时，而`watchEffect`则更适用于当你希望自动追踪并响应响应式状态变化，而不需要过多地控制侦听源和执行时机时。

在 Vue 中，watch和watchEffect的区别是什么？

### MVVM 模式介绍

MVVM 是 Model-View-ViewModel 的缩写，是一种设计模式，专门用于简化用户界面的事件驱动编程。它将用户界面（UI）的表示和业务逻辑分离开来，以达到更好的关注点分离（Separation of Concerns），从而使得开发和维护变得更加容易。

### MVVM 的组成部分

- **Model（模型）**：代表的是数据和业务逻辑层。这是应用程序的核心，包含了数据的状态以及对数据的处理方法。
- **View（视图）**：是用户界面层，显示数据并捕获用户行为。视图的任务是向用户展示信息，并接收用户的输入。
- **ViewModel（视图模型）**：是视图的抽象，它负责处理视图的逻辑。它会监听模型的变化并更新视图，反之亦然，它也会处理视图的用户输入并可能影响模型。

### MVVM 解决的问题

1. **UI与业务逻辑分离**：MVVM 通过引入 ViewModel，实现了界面逻辑与业务逻辑的分离。开发人员可以专注于业务逻辑，而设计师可以专注于界面设计，两者可以独立进行。
   
2. **双向数据绑定**：ViewModel 通常实现了双向数据绑定，即当数据发生变化时，UI自动更新；用户界面变化（如用户输入），数据也会同步更新。这极大地简化了状态同步的复杂性。

3. **更易于测试**：由于 ViewModel 不依赖于视图层的具体实现，因此可以在不涉及用户界面的情况下进行测试。

4. **提高代码的可维护性**：将视图逻辑（如状态的显示和转换）移动到 ViewModel 可以减少视图代码的复杂性，使其变得更加整洁和可维护。

5. **提高可复用性**：ViewModel 可以从视图中抽象出来，因此可以在不同的视图中复用。

### 实例应用

假设我们的应用中有一个用户表单界面，用户需要输入他们的信息。在不使用 MVVM 的情况下，视图代码可能会变得非常复杂，因为它需要处理数据的加载、显示、编辑、验证和保存等逻辑。

在 MVVM 模式下，这些逻辑将会从视图中分离出来：

- **Model**：包含用户信息的数据结构。它可能还包含与数据存储和业务规则相关的逻辑。
- **View**：显示一个表单，用户可以在其中输入他们的信息。它不包含逻辑，只是简单的显示和收集用户输入。
- **ViewModel**：处理表单的显示逻辑，例如当用户点击保存时验证输入并更新模型。

通过这种方式，视图不需要知道数据是如何被处理和验证的，而 ViewModel 中的逻辑可以被独立测试，不需要考虑用户界面的具体实现。

什么是 MVVM 模式？是为了解决什么问题？

双向绑定是一种编程模式，用于简化用户界面与应用状态之间的同步。在传统的单向绑定中，用户界面(UI)只是从应用状态中读取数据并显示出来；而在双向绑定模式中，UI不仅可以显示出应用状态，还可以修改它，反过来也一样，应用状态的改变也会立即反映在UI上。

在Vue.js中，双向绑定主要通过`v-model`指令实现。`v-model`指令在内部使用了Vue的响应式系统，这个系统基于Object.defineProperty或Proxy(在Vue 3中)实现。下面是Vue实现双向绑定的两个主要步骤：

1. **响应式数据的建立**：
   - 在Vue 2.x版本中，Vue通过Object.defineProperty方法拦截对data对象属性的访问和修改。Vue将data对象中的每个属性都转换为getter/setter，并且在内部追踪这些属性的依赖（即哪些组件或计算属性依赖于这个数据属性）。
   - 在Vue 3.x版本中，Vue使用了ES6的Proxy特性来实现响应式。Proxy可以更灵活地拦截和定义对象属性的行为，包括属性的读取、写入以及枚举等，并且它是以更精细的方式工作，不再需要递归地遍历每个属性。
   
2. **依赖收集与派发更新**：
   - 当组件进行渲染时，会访问与之相关的响应式数据属性，这时Vue会进行依赖收集，即记录下当前组件依赖了哪些数据。
   - 当响应式数据发生变化时，Vue会通知所有依赖于这个数据的组件进行更新。
   - 如果是通过`v-model`绑定的输入元素（如`<input>`, `<select>`, `<textarea>`等）发生了用户输入，`v-model`会监听这些输入事件，将新的值赋值给绑定的数据属性。数据的更新又会触发组件的重新渲染，从而将更新反映在UI上。

例如，考虑下面的Vue模板代码：

```html
<input v-model="message">
```

这里的`v-model`指令绑定了一个名为`message`的数据属性。当用户在输入框中输入文字时，`message`的值会被更新，同时，如果其他地方的代码改变了`message`的值，输入框中显示的内容也会相应更新。

这种机制的好处是，开发者不需要手动监听输入事件然后更新数据，也不需要观察数据的变化再去更新UI，Vue的双向绑定机制会自动处理这一切。

什么是双向绑定？Vue 是如何实现双向绑定功能的？

在 Vue 3 中，`setup` 函数是组件选项 API 的替代，它允许您在组件创建之前使用组合式 API 设置组件的响应式状态和函数。通常情况下，`setup` 函数内部并不直接提供组件实例，因为它在组件实例创建之前就被调用了。但是，您可以通过 Vue 提供的 `getCurrentInstance` 方法来获取当前组件实例。

请注意，`getCurrentInstance` 主要用于库和框架的开发者，而不是推荐给普通应用程序开发中使用，因为它暴露了一些内部的 API，可能会导致与 Vue 的未来版本不兼容。

下面是如何在 `setup` 函数中获取组件实例的示例：

```javascript
import { getCurrentInstance } from 'vue';

export default {
  setup() {
    // 获取当前组件实例
    const instance = getCurrentInstance();
    
    // 确保 instance 不为 null
    if (instance) {
      // 现在你可以访问组件实例的属性和方法
      console.log(instance.proxy); // 输出 Vue 代理对象，包含 data、methods 等
    }

    // 定义 setup 函数返回的响应式数据和方法
    return {
      // ...
    };
  },
};
```

在上述代码中，我们首先从 `vue` 导入了 `getCurrentInstance` 函数。在 `setup` 函数内部，我们调用了这个函数以获取当前组件的实例。`getCurrentInstance` 返回的是一个包含组件实例的内部数据的对象，其中 `instance.proxy` 属性代表了组件的代理对象，它包含组件的所有响应式数据、计算属性以及方法等。

使用 `getCurrentInstance` 时，请确保您的代码不过度依赖于 Vue 的内部实现，以免在未来的 Vue 版本升级中产生兼容问题。

Vue面试题手册