前端

服务端

计算机基础

回文字符串是一个正向和反向都相同的字符串。比如 "madam" 或者 "racecar" 就是回文字符串。

以下是一个用Python编写的简单函数，用于检测一个字符串是否是回文：

```python
def is_palindrome(s):
    # 首先，我们将字符串转为小写，并移除非字母字符
    clean_s = ''.join(c for c in s.lower() if c.isalnum())

    # 然后我们比较字符串与其翻转后的版本是否相同
    return clean_s == clean_s[::-1]
```

在这个函数中，我们首先将输入字符串转换为全部小写，并且移除了所有非字母和非数字字符，这样我们就能只关注字母和数字，忽略掉标点和空白。然后我们简单地将处理过的字符串与其自身的倒序版本进行比较，来判断它是否是回文。

让我们用一些例子来测试这个函数：

```python
print(is_palindrome("Madam"))    # 应该输出: True
print(is_palindrome("racecar"))  # 应该输出: True
print(is_palindrome("hello"))    # 应该输出: False
print(is_palindrome("A man, a plan, a canal, Panama"))  # 应该输出: True
```

在最后一个例子中，尽管原始字符串包含了空格和标点符号，但是在我们的 `is_palindrome`函数中，这些字符都被移除了，所以最终验证的字符串是"amanaplanacanalpanama"，这是一个回文字符串。


实现一个函数，判断输入是不是回文字符串

在React项目中，统一监听组件报错并处理错误可以通过几种方式来实现，其中最常见和有效的方式是使用错误边界（Error Boundaries）。

### 错误边界（Error Boundaries）

错误边界是React 16引入的一种新的概念，它允许我们捕获后代组件树中JavaScript错误，并记录这些错误，并显示一个备用UI，而不是使整个组件树崩溃。

#### 实现方式

1. **创建一个错误边界组件**：

我们可以创建一个类组件，并在其中定义`static getDerivedStateFromError()`和`componentDidCatch()`这两个生命周期方法。

```jsx
class ErrorBoundary extends React.Component {
  constructor(props) {
    super(props);
    this.state = { hasError: false };
  }

  static getDerivedStateFromError(error) {
    // 更新状态使下一次渲染能够显示降级后的UI
    return { hasError: true };
  }

  componentDidCatch(error, errorInfo) {
    // 你同样可以将错误记录到一个错误报告服务
    logErrorToMyService(error, errorInfo);
  }

  render() {
    if (this.state.hasError) {
      // 你可以自定义降级后的UI并渲染
      return <h1>Something went wrong.</h1>;
    }

    return this.props.children; 
  }
}
```

2. **在应用中使用错误边界组件**：

错误边界组件可以包裹在任何你希望捕获其内部错误的组件外部。如果一个class组件内部发生了错误，但是它并没有被任何错误边界包裹，那么整个React组件树将会卸载。

```jsx
<ErrorBoundary>
  <MyComponent />
</ErrorBoundary>
```

### 错误报告服务

在`componentDidCatch`方法中，我们不仅可以将错误渲染为备用UI，还可以将错误信息发送到服务器或错误监控服务，比如Sentry、LogRocket或者自己的错误收集系统中。

#### 实现方式

```javascript
componentDidCatch(error, errorInfo) {
  // Example: Sentry integration
  Sentry.captureException(error, { extra: errorInfo });
}
```

### 总结

通过使用错误边界组件(Error Boundaries)，我们可以在React应用中统一监听组件报错。每当组件树中的某部分发生JavaScript错误时，错误边界将会捕获这些错误，并能够显示备用UI来避免整个应用崩溃。同时，利用`componentDidCatch`可以处理错误，例如记录到日志服务中。

这种方式不仅能够提高用户体验，还能帮助开发者及时发现并解决问题。不过需要注意，错误边界无法捕获以下场景中的错误：

- 事件处理（了解更多请使用`try`/`catch`）
- 异步代码（例如`setTimeout`或`requestAnimationFrame`回调函数）
- 服务器端渲染
- 它自身（错误边界组件自己的错误）抛出的错误

在实践中，我们通常建议在高层组件（如路由层级）使用错误边界，以便能够捕获更多未预期的错误情况。

React 项目中如何统一监听组件报错，并且处理报错情况？

Vite 之所以能快速启动，主要得益于它的两个核心设计理念：使用原生 ES 模块（ESM）和按需编译。

1. **原生 ES 模块加载（ESM）**：
   Vite 利用现代浏览器支持的原生 ES 模块特性来服务模块。在开发模式下，Vite 作为一个由浏览器原生支持的模块服务器，它不需要对代码进行打包和构建，而是通过 `<script type="module">` 直接加载模块。这样可以快速启动服务器，并且在请求代码时，浏览器只需加载需要的模块，而不是整个应用程序的打包文件。

2. **按需编译**：
   当使用传统的打包工具时，比如 Webpack，整个应用的所有依赖在启动时都需要先被打包，这包括了构建第三方库和应用代码。这个过程需要时间，特别是当应用规模庞大时。与此相反，Vite 在开发模式下采用了按需编译的策略。这意味着只有当请求某个文件时，Vite 才会对这个文件进行编译和处理。这种方式显著减少了启动时间，并且能够快速响应代码的热更新。

3. **缓存优化**：
   Vite 对依赖的预构建过程进行了优化。它会在第一次运行时将所有的依赖项编译成 ESM，并将结果缓存起来。在随后的启动中，如果没有依赖变化，它会直接使用缓存的结果而不是重新编译，这进一步提高了启动速度。

4. **快速的 HMR（热模块替换）**：
   Vite 的热模块替换是模块级别的，当文件发生变化时，只有那个文件和依赖它的链会被重新加载和编译。这比 Webpack 这样的打包器进行整体刷新要快得多。

5. **高效的依赖预打包（Pre-bundling）**：
   对于某些复杂的依赖（如 CommonJS 或者依赖其他模块的库），Vite 使用 esbuild 预打包这些依赖。esbuild 是用 Go 语言编写的，它的打包速度远远超过基于 JavaScript 的打包器，如 webpack 和 Rollup。

例如，假设你有一个具有数百个模块的大型应用程序。在传统的打包器中，即使你只修改了一个模块，也需要重新打包整个应用程序，这可能需要几十秒甚至更长时间。而在 Vite 中，如果你修改了一个模块，只有这个模块会被重新编译和返回，因此你几乎可以立即看到变化，从而极大提高了开发效率。

总的来说，Vite 之所以能够实现快速的启动，是因为它摈弃了在开发阶段不必要的打包步骤，采用了更现代的模块加载方式，并通过智能的缓存和预编译策略来提高效率。这些设计理念使得 Vite 在开发过程中能够提供极致的快速响应体验。

Vite 为什么启动非常快

发布-订阅模式（Publish-Subscribe Pattern）和观察者模式（Observer Pattern）都是用于在对象之间传递消息的行为设计模式，但它们在对象如何进行通信和解耦方面存在一些关键区别。

### 观察者模式

**定义与工作原理：**
在观察者模式中，被称为“主题”（Subject）的对象维护一组依赖于它的对象，也称为“观察者”（Observers）。当主题的状态发生变化时，会自动通知所有观察者对象。观察者模式通常用于实现分布式事件处理系统，其中一个对象的状态的变化需要影响一个或多个其他对象。

**特点：**

- 直接的通信：主题直接通知它的观察者，没有中间人。
- 紧耦合：观察者必须知道主题并且能够注册自己以接收更新。
- 实时更新：观察者收到状态更新通知通常是同步的。

**例子：**
假设我们有一个股票市场应用程序，其中一个“股票”对象（主题）负责追踪股票价格的变化。投资者对象（观察者）会注册到股票对象上以获取价格更新。一旦股票价格发生变化，股票对象就会通知每个注册的投资者。

### 发布-订阅模式

**定义与工作原理：**
在发布-订阅模式中，组件间的消息传递是通过一个称为“消息代理”或“事件总线”的中间件来进行的，它维护了一张主题-订阅者列表。发布者（Publishers）发布消息到消息代理，而不是直接发送给订阅者（Subscribers）。消息代理负责分发消息到所有注册到相关主题的订阅者。

**特点：**

- 解耦的通信：发布者和订阅者不需要知道对方的存在，它们通过消息代理进行通信。
- 可扩展性：系统可以容易地添加更多发布者或订阅者而不影响其他组件。
- 异步处理：订阅者可以异步处理收到的消息。

**例子：**
同样是股票市场应用程序的场景，不同的服务或组件可以发布关于股票价格更新的消息到消息代理。投资者不直接与股票对象或服务通信，而是订阅了股票价格更新的消息。消息代理负责将更新分发给各个订阅者，这些订阅者可能会异步地接收和处理这些信息。

### 总结区别

- **通信方式**：观察者模式中，观察者和主题直接通信；而发布-订阅模式中，发布者和订阅者间有消息代理作为中介。
- **耦合程度**：观察者模式下，主题和观察者之间耦合性较高；发布-订阅模式促进了更低的耦合度。
- **异步与同步**：观察者模式通常是同步的，即观察者立刻得到通知；发布-订阅模式则通常支持异步处理，订阅者可以在稍后处理消息。


发布订阅者模式和观察者模式的区别是什么？

广度优先遍历（Breadth-First Traversal, BFT）是一种遍历或搜索树或图结构的算法，它从根节点开始，然后遍历所有邻近的节点，再对每个邻近节点做同样的处理，依此类推，直到遍历完所有可达的节点。在DOM树中应用广度优先遍历同样遵循这个原则，其中DOM树的根节点通常是`document`对象的`documentElement`属性，通常指向HTML文档的`<html>`元素。

在JavaScript中执行DOM树的广度优先遍历，我们可以使用队列（Queue）这一数据结构来辅助实现。以下是一个简单的例子：

```javascript
function breadthFirstTraversal(root) {
  // 创建一个队列，并将根节点入队
  let queue = [root];
  
  // 当队列不为空时，循环执行
  while (queue.length > 0) {
    // 出队一个节点并访问
    let currentNode = queue.shift();
    console.log(currentNode.tagName); // 打印当前节点的标签名

    // 将当前节点的所有子节点入队
    [].slice.call(currentNode.children).forEach(child => {
      queue.push(child);
    });
  }
}

// 调用函数，传入document.documentElement作为遍历的起点
breadthFirstTraversal(document.documentElement);
```

在这个例子中，我定义了一个名为`breadthFirstTraversal`的函数，它接收一个DOM节点作为遍历的起点。然后，我使用一个数组作为队列来存放待访问的节点。在while循环中，我不断地从队列中取出节点，访问它，并将它的子节点加入队列末尾。通过这种方式，我能够按照广度优先的顺序访问整个DOM树的每一个节点。

这个例子中，`console.log(currentNode.tagName)`是对当前节点的访问方式，实际应用中可以替换为其他操作，比如获取或修改节点信息等。此外，`.slice.call(currentNode.children)`是一种常见的技巧，用来将`HTMLCollection`或`NodeList`对象转换为数组，以便使用数组的`forEach`方法。在现代的JavaScript中，你也可以直接使用`Array.from(currentNode.children)`来进行转换。

如何广度优先遍历DOM树？

React 的 setState是如何批量更新的？

在HTML中，`meta` 标签本身并不直接将 HTTP 切换到 HTTPS。`meta` 标签通常用于定义网页文档的元数据，比如页面描述、关键字、文档的作者、最后修改时间以及其他元数据。这些元数据不会直接显示在页面上，但会被搜索引擎和浏览器用于处理网页数据。

将网站从 HTTP 协议切换到更安全的 HTTPS 协议，通常需要在服务器层面上进行配置，而不是通过 HTML。这通常包括以下几个步骤：

1. **购买和安装 SSL/TLS 证书**：首先，您需要为您的网站购买 SSL（Secure Sockets Layer）或 TLS（Transport Layer Security）证书。这些证书可以从证书颁发机构（CA）获得，它能够为你的网站提供加密，从而确保数据安全传输。

2. **配置 Web 服务器**：安装证书之后，您需要配置您的 Web 服务器（比如 Apache、Nginx、IIS 等）来使用这个证书，并启动 HTTPS 协议。这通常涉及到编辑服务器配置文件来指定证书的位置，并设置服务器监听 443 端口（HTTPS 默认端口）的请求。

3. **重定向所有 HTTP 请求到 HTTPS**：为了确保用户访问的是 HTTPS 版本的网站，您需要设置 HTTP 到 HTTPS 的重定向。在 Web 服务器配置中，您可以设置规则来自动将所有 HTTP 请求重定向到 HTTPS。例如，在 Apache 服务器中，您可以使用 `.htaccess` 文件来设置重定向规则，如下：

   ```apache
   RewriteEngine On
   RewriteCond %{HTTPS} off
   RewriteRule ^(.*)$ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]
   ```

   在上面的例子中，如果用户访问的是 HTTP 版本的网站，服务器将会发送一个 HTTP 状态码为 301（永久重定向）的响应，告诉浏览器该资源已经被永久地移动到了对应的 HTTPS URL。

虽然 `meta` 标签不能用于切换 HTTP 到 HTTPS，但它有一个相关的用途，那就是设置 HTTP 的**内容安全策略**（Content Security Policy, CSP）。通过 CSP，您可以使用 `meta` 标签来增强网站的安全性。例如：

```html
<meta http-equiv="Content-Security-Policy" content="upgrade-insecure-requests">
```

这个 `meta` 标签的作用是指示兼容的浏览器自动将页面上所有可用的不安全 URL（HTTP）请求升级为安全的 URL（HTTPS）。这不是将整个站点从 HTTP 切换到 HTTPS 的方法，而是一个辅助措施，用于提高页面中单独资源请求的安全性。

html meta标签如何把http换成https的？ 

在讨论HTTPS和HTTP的缓存差异之前，让我们首先明确这两者的基本区别：HTTP是一种无安全性加成的数据传输协议，而HTTPS是HTTP的安全版本，它通过SSL/TLS协议在客户端和服务器之间提供端到端的加密。

现在，谈到它们在缓存方面的区别：

### 1. 安全性：
**HTTPS：** 当内容使用HTTPS传输时，中间人（如代理服务器、CDNs等）很难对数据进行篡改或查看内容，因此提供了更高的安全性。由于这种安全性，浏览器和代理服务器通常更加谨慎地缓存HTTPS内容，以防止敏感信息泄露或被不当使用。

**HTTP：** HTTP缺少加密，因此传输的数据可以被第三方查看或修改。因此，HTTP内容的缓存通常被认为是不那么敏感的，可以更容易地在代理服务器和浏览器之间共享。

### 2. 可缓存性：
**HTTPS：** HTTPS资源的可缓存性通常取决于证书的有效性和相关的缓存控制头。由于安全考虑，某些浏览器可能不会缓存来自HTTPS的资源，除非显式地通过`Cache-Control`或`Expires`头部指定。

**HTTP：** HTTP资源的缓存更加直观和简单。如果响应头中包含了合适的`Cache-Control`或`Expires`头部，它们可以被缓存，并且这些缓存可以在不同用户之间共享。

### 3. 第三方缓存：
**HTTPS：** 由于加密的特性，HTTPS内容通常不会在网络中的第三方缓存，如ISP缓存或其他共享缓存中存储，除非这些第三方缓存支持HTTPS并且遵守正确的缓存策略。

**HTTP：** HTTP内容可以被网络中的任何缓存节点缓存，如ISP或公司网络，这可能会提高内容的交付速度，但也可能带来隐私和数据一致性的问题。

### 4. 性能：
**HTTPS：** 尽管现代技术已经大大减少了HTTPS的开销，但由于其加密解密的需要，它在某种程度上会影响缓存资源的检索时间。

**HTTP：** 由于没有额外的TLS/SSL握手和加密处理，HTTP缓存检索通常比HTTPS快。

### 示例：
假设有一个在线银行网站，出于安全考虑，该网站使用HTTPS。网站的登录页面和交易页面包含敏感信息，因此必须确保这些信息不能被他人轻易读取或修改。因此，这些页面的缓存策略会设置得非常严格，或者根本不允许缓存。即使浏览器缓存了这些信息，也会通过SSL加密，使得无法在用户之间共享缓存。

相比之下，一个使用HTTP的新闻网站可能允许其文章和媒体内容在各种缓存服务器中缓存，以便更快地向用户提供服务。即使这些内容被缓存在用户的本地浏览器缓存或任何其他中间代理中，也不存在泄露敏感信息的风险。

HTTPS 和 HTTP 的缓存有什么区别？

Fetch API和XMLHttpRequest（XHR）都是用于在浏览器中发起HTTP请求的技术。  

**XMLHttpRequest (XHR):**

1. **历史悠久：** XHR出现的比较早，它是Ajax技术的基石，自2000年代初以来一直被广泛使用。
2. **复杂性：** XHR的API相对复杂，使用时需要管理不同的事件和状态变化。
3. **支持状态：** 它支持对请求的细粒度控制，比如可以在下载过程中监控进度事件。
4. **灵活性：** XHR允许同步和异步通信。
5. **兼容性：** 它的兼容性很好，支持老旧的浏览器。

**Fetch API:**

1. **现代替代：** Fetch是一个现代化的替代方案，提供了更简单、更强大的方式来发起网络请求。
2. **基于Promise：** Fetch API基于Promise，这使得异步操作更加简洁，易于管理。
3. **语法简洁：** Fetch提供了一个更加简洁和清晰的API，易于阅读和写作。
4. **无需额外的库：** 与XHR配合一些库（如jQuery）使用相比，Fetch不需要额外的库或框架。
5. **默认异步：** Fetch只支持异步操作，这有助于防止阻塞用户界面的问题。

**例子：**

使用XHR发起GET请求的代码可能如下：

```javascript
var xhr = new XMLHttpRequest();
xhr.open('GET', 'https://api.example.com/data', true);
xhr.onreadystatechange = function() {
  if (xhr.readyState === 4 && xhr.status === 200) {
    console.log(xhr.responseText);
  }
};
xhr.send();
```

而使用Fetch API完成同样的任务的代码则更加简洁：

```javascript
fetch('https://api.example.com/data')
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error(error));
```

Fetch API的优势在于它的简洁性和基于Promise的结构，这使得异步编码更加直观和易于维护。同时，Fetch还支持Request和Response接口，这有利于进一步控制请求和响应的细节。不过，对于一些需要细粒度控制的场合，或者在需要支持老旧浏览器的环境下，XHR仍然是一个可行的选择。


fetch 和 xhr 有什么区别？

AMD（Asynchronous Module Definition）和ESModule（ECMAScript Module）是JavaScript中的两种不同的模块化标准。这两者之间存在几个关键区别： 

### AMD（Asynchronous Module Definition）

1. **异步加载：** AMD是设计用来支持浏览器中的异步模块加载。它允许模块和它们的依赖项可以在不阻塞页面渲染的情况下被异步加载。
2. **动态加载：** AMD模块可以在运行时动态加载，这意味着你可以根据需要随时加载模块。
3. **模块定义：** AMD模块被定义为一个函数，这个函数接受一个依赖数组和一个工厂函数。工厂函数返回模块的导出值。
4. **实现库：** 代表性的实现库是RequireJS。

   例如，使用AMD定义一个模块可能是这样的：

   ```javascript
   define(['dependency1', 'dependency2'], function (dep1, dep2) {
       function myModuleFunction() {
           // 使用依赖项的代码
       }
       return myModuleFunction;
   });
   ```

### ESModule（ECMAScript Module）

1. **静态结构：** ESModules设计为具有静态结构，这意味着模块的导入和导出必须位于模块的顶层，并且不能动态改变。
2. **同步和异步加载：** ESModules可以被同步加载，也可以被异步加载。在浏览器中，可以使用 `<script type="module">`标签异步加载模块。
3. **模块语法：** ESModules使用 `import`和 `export`语法直接在JavaScript语言层面进行模块化。
4. **原生支持：** 现代的浏览器和最新的Node.js版本都原生支持ESModules。

   例如，使用ESModule导入和导出可能是这样的：

   ```javascript
   // 导入
   import { myFunction } from './myModule.js';

   // 导出
   export function myFunction() {
       // 函数实现
   }
   ```

### Tree-Shaking 的优势

Tree-Shaking是一种用于移除JavaScript中未被使用代码(dead code)的技术。ESModule的静态结构特性让工具（如Webpack和Rollup）可以在构建时静态分析代码中的导入和导出，这样可以更容易地确定哪些代码是未被使用的。

由于AMD是动态的，模块依赖在运行时解析，这使得确定未使用代码变得更加困难。因此，ESModule由于其静态结构，在进行Tree-Shaking时更有效，可以更好地优化最终的bundle大小。

Tree-Shaking的工作方式有赖于导入语句在代码中的位置，以及它们是否被其他代码引用。由于ESModule的 `import`和 `export`语句是静态的，构建工具可以在打包过程中准确地识别并去除那些未被使用的导出，这样就可以减少最终包(bundle)的大小并提升加载性能。


面试题手册