前端

服务端

计算机基础

Webpack是一个现代JavaScript应用程序的静态模块打包器，它主要的工作就是分析项目结构，找到JavaScript模块以及其它的一些浏览器不能直接运行的拓展语言（如TypeScript等），并将其转换和打包为合适的格式供浏览器使用。 

Webpack的工作流程主要分为以下几个阶段：

### 初始化

在Webpack启动后，它会从配置文件（默认是 `webpack.config.js`）中读取配置的参数，合并命令行传递过来的参数，形成最终的配置对象。

### 编译（Compiling）

Webpack开始编译整个项目。在这个阶段，Webpack会根据配置中的入口（Entry）开始递归解析所有依赖项。配置文件中的 `entry`属性用于定义入口文件，可能是一个或多个。

### 构建（Building）

针对每个依赖项，Webpack会使用对应的loader去处理文件，例如使用 `babel-loader`来处理JavaScript文件，`css-loader`处理CSS文件，`file-loader`处理图片等资源。Loaders的定义让Webpack能够去处理非JavaScript文件（Webpack本身只理解JavaScript）。

### 生成（Output）

经过加载和转换，Webpack会根据配置中的 `output`部分，把处理过的文件生成到文件系统中。通常是在项目的 `dist`目录下生成 `bundle.js`或者其他自定义名称的文件。

### 优化（Optimizing）

在生成出来的文件中，Webpack可以进行代码压缩、分割代码以实现按需加载等优化操作。这通过配置 `plugins`来实现，比如 `UglifyJsPlugin`、`SplitChunksPlugin`等。

### 输出（Emitting）

将所有的资源文件输出到指定目录下，此时，Webpack的工作就算是完成了。

### 示例

例如，您有一个项目，其入口文件是 `src/index.js`。Webpack会解析这个文件，并解析出这个文件依赖的模块。假如 `index.js`中依赖了 `src/print.js`，Webpack会继续解析 `print.js`的依赖。

假设 `index.js`中还使用了ES6的语法和 `.scss`样式文件，那么在构建阶段，Webpack会使用 `babel-loader`将ES6代码转换为ES5代码，使用 `sass-loader`将SCSS文件转换为CSS文件，并且结合 `css-loader`和 `style-loader`将CSS代码注入到JavaScript中，这样就可以通过JavaScript将样式添加到DOM上。

在优化阶段，可能会有插件去检查代码，去除未引用的代码(dead code)，压缩混淆输出的文件，以减少文件大小和提高加载速度。

最终，在输出阶段，Webpack会在 `dist`目录下输出 `bundle.js`，其中包含了所有的应用程序代码，以及所有的样式打包成的CSS代码。

这就是Webpack的一个基本工作流程。它的强大之处在于可扩展性，通过配置文件和插件系统，可以适应各种复杂的项目需求。


Webpack 的详细工作流程

CSS 性能优化是 web 项目性能优化中的重要部分。

以下是一些策略来帮助优化 CSS 的性能：

1. **减少冗余代码**

   为类或元素重复写入相同的 CSS 规则会浪费带宽和浏览解析时间。实用工具如 [PurgeCSS](https://purgecss.com/) 可帮助删除无用的 CSS。
2. **CSS 压缩**

   CSS 压缩可以移除所有多余的字符，包括空格、换行符和注释。使用CSS 压缩工具如 [CSSO](https://github.com/css/csso) 或 [clean-css](https://github.com/jakubpawlowicz/clean-css)。
3. **使用 CSS 雪碧图**

   CSS 雪碧图合并了一系列的小图片到一张大的图片中。这可以减少HTTP请求的数量，提高加载速度。
4. **CSS 对象模型（CSSOM) 和 渲染树**

   浏览器通过解析 HTML 和 CSS 成 CSSOM 和 DOM ，然后结合他们形成渲染树。因此，应该尽量把 CSS 放在 HTML 文档的顶部，以加快渲染速度。
5. **避免使用过于复杂的选择器**

   复杂的选择器可能会导致浏览器使用更多的资源来解析它们，优先使用类和 ID 选择器。
6. **使用 CSS 预处理器**

   CSS 预处理器如 Sass 或 Less 可以使 CSS 更易于维护，同时可以使用变量，嵌套，混入 (Mixins) 等高级特性。
7. **使用硬件加速**

   利用 GPU 来提供高效渲染，例如 transform 或 opacity。
8. **避免使用 @import**

   `@import` 可能会导致更多的 HTTP 请求，使页面加载速度变慢。应该尽量使用命令行工具或构建系统的导入功能，以便在构建过程中进行文件合并。
9. **按需加载 CSS**

   只加载需要立即使用的 CSS。
10. **缩小 CSS 的范围**

    例如， instead of using `* {margin: 0; padding: 0;}`, 用类似 `.myClass {margin: 0; padding: 0;}` 更好。


如何做 CSS 的性能优化

在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 之间的区别是什么

在React中，**受控组件(Controlled Components)**和**非受控组件(Uncontrolled Components)**都是处理表单输入的方式，但它们处理数据的方式不同。

### 受控组件(Controlled Components)

受控组件是React的一种模式，在这种模式下，表单数据是由React组件的状态管理的。这意味着每次字段的值发生变化时，我们都会通过一个事件处理函数（通常是 `onChange`）来更新组件的状态。然后，组件的状态被用作输入字段的值，确保组件的状态是数据的唯一来源。

**示例：**
假设我们有一个受控的 `<input>`元素：

```jsx
class ControlledComponent extends React.Component {
  constructor(props) {
    super(props);
    this.state = {value: ''};
  }

  handleChange = (event) => {
    this.setState({value: event.target.value});
  }

  render() {
    return (
      <form>
        <label>
          Name:
          <input type="text" value={this.state.value} onChange={this.handleChange} />
        </label>
      </form>
    );
  }
}
```

在上面的例子中，`<input>`的值始终由 `this.state.value`决定，而且每当用户输入时，`handleChange`函数都会被调用，更新状态，因此界面显示的内容总是和状态同步。

### 非受控组件(Uncontrolled Components)

非受控组件是另一种模式，在这种模式下，表单数据是由DOM本身处理的，而不是由React状态管理。这就像传统的HTML表单工作方式。在非受控组件中，我们通常使用 `ref`来从DOM节点获取表单数据，而不是为每个状态变化编写事件处理函数。

**示例：**
下面是一个非受控组件的例子：

```jsx
class UncontrolledComponent extends React.Component {
  constructor(props) {
    super(props);
    this.inputRef = React.createRef();
  }

  handleSubmit = (event) => {
    alert('A name was submitted: ' + this.inputRef.current.value);
    event.preventDefault();
  }

  render() {
    return (
      <form onSubmit={this.handleSubmit}>
        <label>
          Name:
          <input type="text" ref={this.inputRef} />
        </label>
        <button type="submit">Submit</button>
      </form>
    );
  }
}
```

在上面的例子中，`<input>`不是通过状态来控制其值，而是通过 `ref`来访问DOM节点获取其值。  

### 总结

- 受控组件允许你更好地控制表单的行为，因为组件的状态充当了数据的真实来源。
- 非受控组件舍弃了对表单状态的即时控制，使得组件的代码更简洁，但可能会更难管理表单的状态，尤其是在复杂的表单交互时。

在实际的开发实践中，受控组件通常是首选方法，因为它们更加符合React的数据流概念，使得状态的管理更加清晰和可预测。然而，对于一些简单的表单或者集成第三方DOM库时，非受控组件也可能是一个不错的选择。


什么是 React 的受控组件和非受控组件?

当我们在JavaScript中使用`new`操作符创建一个新对象时，实际上会发生以下几个步骤：

1. **创建一个新对象。** 使用`new`操作符时，JavaScript会自动为我们创建一个新的空对象。

2. **设置原型链。** 新对象内部的`[[Prototype]]`（或者`__proto__`）属性会被赋值为构造函数的`prototype`属性，这样新对象就可以访问到构造函数原型上的属性和方法。

3. **绑定`this`并执行构造函数。** 构造函数内部的`this`将会被绑定到新创建的对象上，然后执行构造函数中的代码，这样新对象就可以具有构造函数中定义的属性和方法。

4. **返回新对象。** 如果构造函数返回的是一个对象，则返回该对象；如果没有返回对象或者返回的不是一个对象，那么将返回步骤1创建的新对象。

如果我们要手写一个`new`的实现，可以定义一个函数来模拟这个过程。以下是一个例子：

```javascript
function myNew(constructor, ...args) {
    // 步骤1：创建一个空对象，并设置原型链
    const obj = Object.create(constructor.prototype);
    
    // 步骤2：将构造函数的this绑定到新对象上，并执行构造函数
    const result = constructor.apply(obj, args);
    
    // 步骤3：根据返回值判断
    return result instanceof Object ? result : obj;
}

// 测试用例
function Person(name, age) {
    this.name = name;
    this.age = age;
    this.sayHello = function() {
        console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
    };
}

// 使用自定义的myNew来替代new操作符
const person = myNew(Person, 'Alice', 30);
person.sayHello(); // 输出: Hello, my name is Alice and I am 30 years old.
```

以上代码中，`myNew`函数模拟了`new`操作符的所有关键步骤，能够模拟出通过`new`操作符创建对象的效果。

手写 javascript 中 new 的实现过程

在Redux中，中间件是一种强大的机制，允许开发者在action被发送到reducer之前插入自己的逻辑。创建自定义的Redux中间件涉及到编写一个函数，该函数按照Redux中间件API的规格返回一个满足特定签名的函数。

我将向您展示如何自定义实现一个简单的日志中间件，该中间件的作用是在action被派发时在控制台输出日志信息。

以下是自定义Redux中间件的基本步骤：

1. 编写一个函数，该函数接收`store`的`dispatch`和`getState`方法。
2. 该函数返回一个接收下一个中间件的`next`函数的函数。
3. 返回的函数再返回一个接收action的函数。
4. 在最内层的函数体内，可以执行自定义的逻辑，然后调用`next(action)`将action传递给链中的下一个中间件或reducer。

下面是一个自定义日志中间件的例子：

```javascript
// 自定义日志中间件
const loggerMiddleware = store => next => action => {
  // 自定义的逻辑：在当前action被处理之前输出日志
  console.log('dispatching', action);

  // 调用链中的下一个中间件或reducer
  let result = next(action);

  // 自定义的逻辑：在action被处理后输出新的状态
  console.log('next state', store.getState());

  // 返回result，因为middleware的链需要从next(action)获取返回值
  return result;
};

export default loggerMiddleware;
```

在上述的中间件代码中：

- `store`: Redux store实例，它包含了`dispatch`和`getState`方法。
- `next`: 是一个将action传递给链中下一个处理者（中间件或reducer）的函数。
- `action`: 是当前正在处理的action对象。

使用这个中间件的典型方式是在创建Redux store时应用它：

```javascript
import { createStore, applyMiddleware } from 'redux';
import rootReducer from './reducers';
import loggerMiddleware from './middleware/loggerMiddleware';

// 使用applyMiddleware来增强store，添加自定义的loggerMiddleware
const store = createStore(
  rootReducer,
  applyMiddleware(loggerMiddleware)
);

export default store;
```

在这个例子中，任何派发到store的action都会先经过`loggerMiddleware`这个中间件，在控制台输出action信息，然后继续沿中间件链传递，直到最终被reducer处理。

这只是自定义中间件的一个简单例子，但您可以根据需要在中间件中实现更复杂的逻辑，例如异步操作、路由导航或其他您想要的任何自定义行为。

如何自定义实现 Redux 中间件

CSS中清除浮动（Float）的几种常见方法如下：

### 1. 使用`clear`属性

在浮动元素之后添加一个空的元素，并为其设置`clear`属性。

```html
<div class="float-element"></div>
<div class="clear"></div>
```

```css
.float-element {
  float: left;
}

.clear {
  clear: both;
}
```

**优点:**

- 简单易懂。
- 兼容性好，适用于所有浏览器。

**缺点:**

- 需要额外的标记（markup），可能导致HTML结构变得臃肿。
- 与内容分离度不高，不符合现代Web开发的最佳实践。

### 2. 使用`overflow`属性

为父元素设置`overflow: auto`或`overflow: hidden`可以清除子元素的浮动。

```css
.parent {
  overflow: auto;
}
```

**优点:**

- 不需要添加额外的HTML元素。
- 代码简洁。

**缺点:**

- 在某些情况下可能会导致不期望的滚动条出现。
- 如果子元素需要超出父容器边界显示，此方法可能会剪切子元素的部分内容。

### 3. 使用伪元素清除浮动（clearfix hack）

通过在父元素上添加一个伪元素来清除浮动。

```css
.clearfix::after {
  content: "";
  display: block;
  clear: both;
}
```

**优点:**

- 不需要在HTML中添加额外的元素。
- 代码整洁且符合无障碍标准。
- 被广泛采纳，成为一种标准做法。

**缺点:**

- 在旧版IE浏览器中可能需要额外的兼容性处理。

### 4. 使用Flexbox

将父元素设为Flex容器。

```css
.parent {
  display: flex;
}
```

**优点:**

- 为现代网站提供了更强大的布局选项。
- 自动处理了元素的浮动问题，不需要显式清除。

**缺点:**

- 在不支持Flexbox的老旧浏览器中不可用。
- 涉及到布局方式的更改，可能需要重新考虑整个布局结构。

### 5. 使用Grid布局

将父元素设为Grid容器。

```css
.parent {
  display: grid;
}
```

**优点:**

- 更先进的布局系统，提供了更多布局选项。
- 同样自动处理元素的浮动问题。

**缺点:**

- 兼容性不如Flexbox，特别是在老旧浏览器上。

总的来说，选择哪种方法取决于具体项目的要求、浏览器兼容性，以及开发者对于CSS规范的熟悉程度。清除浮动是一个常见的问题，现代前端开发倾向于使用`clearfix`技术或更现代的布局方法（如Flexbox或Grid）来避免这个问题。

css 清除浮动的几种方式以及各自的优缺点

React 的异步组件（通常被称为懒加载组件）主要是通过动态 `import()` 语法和 React 的 `React.lazy` 函数来实现的。它们用于在需要时才加载组件，可以显著提高应用程序的性能，尤其是当应用程序很大并且有许多不同的页面和组件时。接下来，我会详细介绍如何使用异步组件以及它们的使用场景。 

### 如何使用异步组件

使用 React 异步组件的基本步骤如下：

1. 使用 `React.lazy` 函数分别导入组件。这个函数允许你定义一个动态导入的组件。该函数接受一个函数，这个函数必须调用一个 `import()`，它返回一个 `Promise`，该 `Promise` 解析为一个有 `default` 导出的模块。

   ```jsx
   const AsyncComponent = React.lazy(() => import('./AsyncComponent'));
   ```
2. 将 `React.lazy` 返回的组件与 `React.Suspense` 组件结合使用。`Suspense` 组件允许你指定加载指示器（例如：加载中的旋转器），在等待异步组件加载时显示给用户。

   ```jsx
   import React, { Suspense } from 'react';

   // 异步导入组件
   const AsyncComponent = React.lazy(() => import('./AsyncComponent'));

   function App() {
     return (
       <div>
         <Suspense fallback={<div>Loading...</div>}>
           <AsyncComponent />
         </Suspense>
       </div>
     );
   }
   ```

### 使用场景

1. **性能优化：** 对于大型应用程序，将不同的页面或功能分割成独立的代码块，然后只在用户需要时才加载，可以减少应用程序的初始负载时间。
2. **条件渲染组件：** 当一个组件只在某些条件下才需要时，例如特定的用户角色或权限，可以使用异步组件按需加载，从而节省资源。
3. **路由懒加载：** 在使用如 React Router 这样的库进行路由管理时，可以结合 `React.lazy` 和 `Suspense` 来实现路由级别的懒加载。

   ```jsx
   import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';
   import React, { Suspense } from 'react';

   const Home = React.lazy(() => import('./Home'));
   const About = React.lazy(() => import('./About'));

   const App = () => (
     <Router>
       <Suspense fallback={<div>Loading...</div>}>
         <Switch>
           <Route exact path="/" component={Home} />
           <Route path="/about" component={About} />
         </Switch>
       </Suspense>
     </Router>
   );
   ```
4. **组件库懒加载：** 如果你的应用程序使用了庞大的第三方组件库，而只有少数组件被频繁使用，可以选择仅懒加载那些较少使用的组件，以减少初始包的大小。

使用异步组件的主要目标是提升用户体验，减少页面加载时间，并且按需加载资源，避免浪费客户端的计算和带宽资源。React 的懒加载功能是实现上述目标的重要手段之一。


React 如何使用异步组件以及异步组件的使用场景

React Router 可以通过配合 React 的 `React.lazy()` 和 `Suspense` 组件来配置组件的懒加载。以下是使用 React Router 实现懒加载的基本步骤：

1. **使用 `React.lazy` 实现动态导入**: `React.lazy()` 是一个允许你动态加载组件的函数。它可以让你定义一个动态导入的组件，并且这个组件会在首次渲染时自动加载。

   ```jsx
   const LazyComponent = React.lazy(() => import('./LazyComponent'));
   ```

2. **使用 `Suspense` 组件包裹路由**: 在你的应用中，你需要使用 `Suspense` 组件来包裹懒加载的路由。`Suspense` 可以指定一个加载指示器（比如一个 spinner），它会在懒加载组件加载完成之前显示。

   ```jsx
   import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';
   import React, { Suspense } from 'react';

   const LazyComponent = React.lazy(() => import('./LazyComponent'));

   function App() {
     return (
       <Router>
         <Suspense fallback={<div>Loading...</div>}>
           <Switch>
             <Route path="/lazy" component={LazyComponent} />
             {/* 其他路由 */}
           </Switch>
         </Suspense>
       </Router>
     );
   }
   ```

3. **为懒加载组件创建独立的 chunk**: 当你使用 `create-react-app` 或其他构建工具时，它会为每个用 `React.lazy()` 引入的组件自动创建一个独立的 JavaScript chunk 文件。这意味着这些代码只会在用户需要时才会被加载。

举个例子，假设你有一个很大的组件 `BigComponent`，你不希望它在应用首次加载时就加载进来，而是希望当用户真正访问到该组件对应的路由时再加载，你可以这样设置：

```jsx
import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';
import React, { Suspense } from 'react';

const BigComponent = React.lazy(() => import('./BigComponent'));

function App() {
  return (
    <Router>
      <Suspense fallback={<div>Loading Big Component...</div>}>
        <Switch>
          <Route path="/big-component" component={BigComponent} />
          {/* 其他路由 */}
        </Switch>
      </Suspense>
    </Router>
  );
}
```

在上述例子中，当用户访问 `/big-component` 路径时，`BigComponent` 会被动态加载。用户会看到 "Loading Big Component..." 的文本，直到 `BigComponent` 加载完成并准备好渲染。这样可以减少应用的初始加载时间，并且按需加载资源，提高性能。

面试题手册