next.js是一个基于React的通用JavaScript框架，next.js为React组件模型提供了扩展，支持基于服务器的组件渲染，同时也支持在客户端继续进行渲染

next.js是一个基于React的通用JavaScript框架，next.js为React组件模型提供了扩展，支持基于服务器的组件渲染，同时也支持在客户端继续进行渲染

next.js是一个基于React的通用JavaScript框架，next.js为React组件模型提供了扩展，支持基于服务器的组件渲染，同时也支持在客户端继续进行渲染



Next.js

在 Next.js 13 中，获取客户端的真实 IP 地址通常需要在 API 路由中处理 HTTP 请求。对于大多数应用来说，由于可能部署在具有负载平衡器或反向代理的环境中，直接从请求中获取 IP 可能不是真实的客户端 IP。因此，需要考虑 HTTP 头 `X-Forwarded-For` 来获取原始请求的 IP 地址。

### 步骤说明

1. **创建 Next.js API 路由**:
   在 Next.js 应用中，您可以通过在 `/pages/api` 目录下创建一个文件来添加一个 API 路由。例如，创建 `/pages/api/client-ip.js`。

2. **编写获取 IP 地址的逻辑**:
   在该 API 路由中，您需要解析 `X-Forwarded-For` HTTP 头部，此头部通常包含了客户端的原始 IP 地址。

3. **考虑部署环境**:
   如果你的应用部署在支持 `X-Forwarded-For` 的环境中（如 Vercel、AWS 或使用 Nginx/Apache 作为反向代理），则可以信任此头部。但如果你不确定环境是否支持或正确配置了 `X-Forwarded-For`，你可能需要做额外的配置或验证。

### 示例代码

下面是一个简单的示例，展示如何在 Next.js 13 的 API 路由中获取客户端的真实 IP 地址：

```javascript
// 文件路径: /pages/api/client-ip.js

export default function handler(req, res) {
  let ipAddress;

  // 尝试获取 X-Forwarded-For 头部的值
  const xForwardedFor = req.headers['x-forwarded-for'];

  if (xForwardedFor) {
    // 可能包含多个 IP 地址，因此需要取第一个
    ipAddress = xForwardedFor.split(',')[0];
  } else {
    // 直接从连接信息中获取 IP 地址
    ipAddress = req.socket.remoteAddress;
  }

  // 返回客户端 IP 地址
  res.status(200).json({ clientIp: ipAddress });
}
```

### 注意事项

- 确保你了解部署环境中对 `X-Forwarded-For` 的支持。
- 如果你的应用部署在不支持或未正确配置 `X-Forwarded-For` 的环境中，直接依赖 `req.socket.remoteAddress` 可能只会获取到代理或负载均衡器的 IP 地址，而非客户端的真实 IP。
- 出于安全考虑，如果你依赖 IP 地址进行重要的验证，请确保对 `X-Forwarded-For` 的值进行适当的验证和过滤，避免 IP 伪造的风险。

通过上述方法，你应该能够在 Next.js 13 的环境中可靠地获取客户端的真实 IP 地址。在Next.js 13中，获取客户端的真实IP地址通常需要在API路由或中间件中操作，因为在服务端执行的代码可以直接访问请求信息。以下是如何在Next.js 13的API路由中获取客户端真实IP地址的方法。

### 步骤说明：

1. **创建API路由**：
   在 `pages/api` 目录下创建一个新的文件，例如 `user-ip.js`。这将用于处理获取IP的请求。

2. **读取请求头**：
   请求头中的 `x-forwarded-for` 属性通常用于识别通过HTTP代理或负载均衡器发送请求的客户端的原始IP地址。但注意，这个头可以被伪造，所以在安全性要求较高的场景下需要谨慎使用。

3. **实现API路由逻辑**：
   在API路由文件中，你可以通过 `req.headers['x-forwarded-for']` 或 `req.socket.remoteAddress` 来获取IP地址。`x-forwarded-for` 可能包含多个IP地址（如果请求经过多个代理），通常第一个是原始客户端的IP。

### 示例代码：

```javascript
// pages/api/user-ip.js
export default function handler(req, res) {
  // 获取x-forwarded-for头部，这通常由代理设置，如Nginx或负载均衡器
  const xForwardedFor = req.headers['x-forwarded-for'];
  
  // x-forwarded-for 可能包含多个IP地址，用逗号分隔
  const ip = xForwardedFor ? xForwardedFor.split(',')[0] : req.socket.remoteAddress;

  // 返回客户端IP地址
  res.status(200).json({ ip: ip });
}
```

### 注意事项：

- **安全性**：如前所述，`x-forwarded-for` 可能被伪造，如果你依赖于IP地址进行安全性控制（如IP白名单），则需要额外注意。
- **部署环境**：在使用Vercel或其他云平台时，确保了解平台如何处理IP地址转发和记录。不同的云服务提供商可能有不同的设置和行为。

通过使用上面的代码，你可以在Next.js 13应用中有效地获取到客户端的真实IP地址，但记得根据你的具体部署环境和安全需求进行相应的调整和测试。

在 Next.js 13 中，获取客户端的真实 IP 地址通常需要在 API 路由中处理 HTTP 请求。对于大多数应用来说，由于可能部署在具有负载平衡器或反向代理的环境中，直接从请求中获取 IP 可能不是真实的客户端 IP。因此，需要考虑 HTTP 头 `X-Forwarded-For` 来获取原始请求的 IP 地址。

### 步骤说明

1. **创建 Next.js API 路由**:
   在 Next.js 应用中，您可以通过在 `/pages/api` 目录下创建一个文件来添加一个 API 路由。例如，创建 `/pages/api/client-ip.js`。

2. **编写获取 IP 地址的逻辑**:
   在该 API 路由中，您需要解析 `X-Forwarded-For` HTTP 头部，此头部通常包含了客户端的原始 IP 地址。

3. **考虑部署环境**:
   如果你的应用部署在支持 `X-Forwarded-For` 的环境中（如 Vercel、AWS 或使用 Nginx/Apache 作为反向代理），则可以信任此头部。但如果你不确定环境是否支持或正确配置了 `X-Forwarded-For`，你可能需要做额外的配置或验证。

### 示例代码

下面是一个简单的示例，展示如何在 Next.js 13 的 API 路由中获取客户端的真实 IP 地址：

```javascript
// 文件路径: /pages/api/client-ip.js

export default function handler(req, res) {
  let ipAddress;

  // 尝试获取 X-Forwarded-For 头部的值
  const xForwardedFor = req.headers['x-forwarded-for'];

  if (xForwardedFor) {
    // 可能包含多个 IP 地址，因此需要取第一个
    ipAddress = xForwardedFor.split(',')[0];
  } else {
    // 直接从连接信息中获取 IP 地址
    ipAddress = req.socket.remoteAddress;
  }

  // 返回客户端 IP 地址
  res.status(200).json({ clientIp: ipAddress });
}
```

### 注意事项

- 确保你了解部署环境中对 `X-Forwarded-For` 的支持。
- 如果你的应用部署在不支持或未正确配置 `X-Forwarded-For` 的环境中，直接依赖 `req.socket.remoteAddress` 可能只会获取到代理或负载均衡器的 IP 地址，而非客户端的真实 IP。
- 出于安全考虑，如果你依赖 IP 地址进行重要的验证，请确保对 `X-Forwarded-For` 的值进行适当的验证和过滤，避免 IP 伪造的风险。

通过上述方法，你应该能够在 Next.js 13 的环境中可靠地获取客户端的真实 IP 地址。

在 Next.js 13 中，获取客户端的真实 IP 地址通常需要在 API 路由中处理 HTTP 请求。对于大多数应用来说，由于可能部署在具有负载平衡器或反向代理的环境中，直接从请求中获取 IP 可能不是真实的客户端 IP。因此，需要考虑 HTTP 头 `X-Forwarded-For` 来获取原始请求的 IP 地址。

### 步骤说明

1. **创建 Next.js API 路由**:
   在 Next.js 应用中，您可以通过在 `/pages/api` 目录下创建一个文件来添加一个 API 路由。例如，创建 `/pages/api/client-ip.js`。

2. **编写获取 IP 地址的逻辑**:
   在该 API 路由中，您需要解析 `X-Forwarded-For` HTTP 头部，此头部通常包含了客户端的原始 IP 地址。

3. **考虑部署环境**:
   如果你的应用部署在支持 `X-Forwarded-For` 的环境中（如 Vercel、AWS 或使用 Nginx/Apache 作为反向代理），则可以信任此头部。但如果你不确定环境是否支持或正确配置了 `X-Forwarded-For`，你可能需要做额外的配置或验证。

### 示例代码

下面是一个简单的示例，展示如何在 Next.js 13 的 API 路由中获取客户端的真实 IP 地址：

```javascript
// 文件路径: /pages/api/client-ip.js

export default function handler(req, res) {
  let ipAddress;

  // 尝试获取 X-Forwarded-For 头部的值
  const xForwardedFor = req.headers['x-forwarded-for'];

  if (xForwardedFor) {
    // 可能包含多个 IP 地址，因此需要取第一个
    ipAddress = xForwardedFor.split(',')[0];
  } else {
    // 直接从连接信息中获取 IP 地址
    ipAddress = req.socket.remoteAddress;
  }

  // 返回客户端 IP 地址
  res.status(200).json({ clientIp: ipAddress });
}
```

### 注意事项

- 确保你了解部署环境中对 `X-Forwarded-For` 的支持。
- 如果你的应用部署在不支持或未正确配置 `X-Forwarded-For` 的环境中，直接依赖 `req.socket.remoteAddress` 可能只会获取到代理或负载均衡器的 IP 地址，而非客户端的真实 IP。
- 出于安全考虑，如果你依赖 IP 地址进行重要的验证，请确保对 `X-Forwarded-For` 的值进行适当的验证和过滤，避免 IP 伪造的风险。

通过上述方法，你应该能够在 Next.js 13 的环境中可靠地获取客户端的真实 IP 地址。
在Next.js 13中，获取客户端的真实IP地址通常需要在API路由或中间件中操作，因为在服务端执行的代码可以直接访问请求信息。以下是如何在Next.js 13的API路由中获取客户端真实IP地址的方法。

### 步骤说明：

1. **创建API路由**：
   在 `pages/api` 目录下创建一个新的文件，例如 `user-ip.js`。这将用于处理获取IP的请求。

2. **读取请求头**：
   请求头中的 `x-forwarded-for` 属性通常用于识别通过HTTP代理或负载均衡器发送请求的客户端的原始IP地址。但注意，这个头可以被伪造，所以在安全性要求较高的场景下需要谨慎使用。

3. **实现API路由逻辑**：
   在API路由文件中，你可以通过 `req.headers['x-forwarded-for']` 或 `req.socket.remoteAddress` 来获取IP地址。`x-forwarded-for` 可能包含多个IP地址（如果请求经过多个代理），通常第一个是原始客户端的IP。

### 示例代码：

```javascript
// pages/api/user-ip.js
export default function handler(req, res) {
  // 获取x-forwarded-for头部，这通常由代理设置，如Nginx或负载均衡器
  const xForwardedFor = req.headers['x-forwarded-for'];
  
  // x-forwarded-for 可能包含多个IP地址，用逗号分隔
  const ip = xForwardedFor ? xForwardedFor.split(',')[0] : req.socket.remoteAddress;

  // 返回客户端IP地址
  res.status(200).json({ ip: ip });
}
```

### 注意事项：

- **安全性**：如前所述，`x-forwarded-for` 可能被伪造，如果你依赖于IP地址进行安全性控制（如IP白名单），则需要额外注意。
- **部署环境**：在使用Vercel或其他云平台时，确保了解平台如何处理IP地址转发和记录。不同的云服务提供商可能有不同的设置和行为。

通过使用上面的代码，你可以在Next.js 13应用中有效地获取到客户端的真实IP地址，但记得根据你的具体部署环境和安全需求进行相应的调整和测试。

如何在nextjs 13中获取客户端的真实 ip 地址？

### 回答：

部署NextJS应用到NGINX涉及几个关键步骤，主要包括构建应用、配置NGINX以及维护和监控。以下是详细步骤：

#### 1. **构建NextJS应用**

   首先，需要确保您的NextJS应用已经开发完成并可以在本地运行。接下来，执行构建命令来为生产环境准备应用。

   ```
   npm run build
   ```

   这个命令会创建一个`.next`文件夹，其中包含了用于生产环境的优化后的文件。

#### 2. **准备生产服务器**

   - **安装Node.js**: 确保您的生产服务器已经安装了Node.js，因为NextJS是一个Node.js框架。
   - **安装PM2**: 推荐使用PM2来管理您的Node.js应用程序，它可以帮助您管理日志、监控应用以及在崩溃后自动重启应用。

   ```
   npm install pm2 -g
   ```

   - **使用PM2启动应用**:

   ```
   pm2 start npm --name "next-app" -- start
   ```

#### 3. **配置NGINX**

   - **安装NGINX**: 确保NGINX已经在服务器上安装。
   - **配置反向代理**: 编辑NGINX配置文件（通常位于`/etc/nginx/sites-available/default`），设置反向代理以将请求从NGINX转发到您的NextJS应用。

     ```nginx
     server {
       listen 80;

       server_name your-domain.com;

       location / {
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
         proxy_set_header Host $http_host;
         proxy_set_header X-NginX-Proxy true;

         proxy_pass http://localhost:3000;
         proxy_redirect off;
       }
     }
     ```

   - **重启NGINX**:

   ```
   sudo systemctl restart nginx
   ```

#### 4. **维护和监控**

   - **监控应用**: 使用PM2的监控功能来查看应用的性能和日志。
   - **SSL配置**: 为了安全，建议使用Let's Encrypt为您的网站配置SSL。

这些步骤涵盖了从应用构建到部署的全过程，确保应用在生产环境中的稳定运行。希望这些信息对您有帮助，如果有任何问题，我乐意进一步讨论。

部署NextJS应用到NGINX涉及几个关键步骤，主要包括构建应用、配置NGINX以及维护和监控。以下是详细步骤：

#### 1. **构建NextJS应用**

首先，需要确保您的NextJS应用已经开发完成并可以在本地运行。接下来，执行构建命令来为生产环境准备应用。

```
npm run build
```

这个命令会创建一个 `.next`文件夹，其中包含了用于生产环境的优化后的文件。

#### 2. **准备生产服务器**

- **安装Node.js**: 确保您的生产服务器已经安装了Node.js，因为NextJS是一个Node.js框架。
- **安装PM2**: 推荐使用PM2来管理您的Node.js应用程序，它可以帮助您管理日志、监控应用以及在崩溃后自动重启应用。

```
npm install pm2 -g
```

- **使用PM2启动应用**:

```
pm2 start npm --name "next-app" -- start
```

#### 3. **配置NGINX**

- **安装NGINX**: 确保NGINX已经在服务器上安装。
- **配置反向代理**: 编辑NGINX配置文件（通常位于 `/etc/nginx/sites-available/default`），设置反向代理以将请求从NGINX转发到您的NextJS应用。 

  ```nginx
  server {
    listen 80;

    server_name your-domain.com;

    location / {
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header Host $http_host;
      proxy_set_header X-NginX-Proxy true;

      proxy_pass http://localhost:3000;
      proxy_redirect off;
    }
  }
  ```
- **重启NGINX**:

```
sudo systemctl restart nginx
```

#### 4. **维护和监控**

- **监控应用**: 使用PM2的监控功能来查看应用的性能和日志。
- **SSL配置**: 为了安全，建议使用Let's Encrypt为您的网站配置SSL。

这些步骤涵盖了从应用构建到部署的全过程，确保应用在生产环境中的稳定运行。

如何使用 NGINX 部署 NextJS ？

在Next.js中，为了检测用户何时离开页面，您可以利用浏览器提供的 `beforeunload` 事件。这个事件会在窗口、标签页或者浏览器即将卸载当前文档时触发。

首先，您需要在您的 Next.js 组件中添加事件监听器，一般会在 `useEffect` 钩子中进行，以确保代码在组件加载时执行。以下是一个简单的示例代码：

```jsx
import { useEffect } from 'react';

function MyComponent() {
  useEffect(() => {
    const handleBeforeUnload = (event) => {
      event.preventDefault();
      // 在这里，您可以执行一些清理操作或者最后的保存操作
      // 设置 returnValue 以兼容一些老版本浏览器
      event.returnValue = '';
    };

    // 添加事件监听器
    window.addEventListener('beforeunload', handleBeforeUnload);

    // 组件卸载时，移除事件监听器
    return () => {
      window.removeEventListener('beforeunload', handleBeforeUnload);
    };
  }, []);

  return (
    <div>
      <h1>Welcome to my page!</h1>
    </div>
  );
}

export default MyComponent;
```

在上述代码中，`handleBeforeUnload` 函数会在用户尝试离开页面时调用。你可以在这个函数中执行一些操作，比如弹出确认对话框，让用户确认是否真的要离开页面。

需要注意的是，现代浏览器对于 `beforeunload` 事件中的弹出窗口有一些限制，以避免滥用导致的用户不便。因此，如果你尝试在此事件中使用 `alert()` 或 `confirm()` 弹窗，可能不会按预期工作。

此外，这种方法主要用于捕捉用户关闭标签页或浏览器的行为，如果用户通过点击链接离开当前页面，您可能需要另外处理，比如在路由切换时进行检测。

在 Next.js 中，您还可以利用其路由功能（例如 `next/router`）来检测路由变化，从而进一步掌控用户何时离开页面的行为。例如：

```jsx
import { useEffect } from 'react';
import { useRouter } from 'next/router';

function MyComponent() {
  const router = useRouter();

  useEffect(() => {
    const handleRouteChange = (url) => {
      console.log('App is changing to:', url);
    };

    router.events.on('routeChangeStart', handleRouteChange);

    return () => {
      router.events.off('routeChangeStart', handleRouteChange);
    };
  }, [router]);

  return (
    <div>
      <h1>Welcome to my page!</h1>
    </div>
  );
}

export default MyComponent;
```

在这段代码中，我们监听了路由变化的开始，这可以帮助我们检测用户何时通过 Next.js 的 Link 组件或编程式导航离开当前页面。

NextJS 如何检测用户何时离开页面？

在 Next.js 中，获取上一个页面的 URL 通常是通过 `referer` HTTP 头部来完成的。`referer` 头部在用户从一个页面导航到另一个页面时，会被浏览器自动设置，以指示请求是从哪个页面发起的。

这里有一个实际的例子，演示如何在 Next.js 的页面或 API 路由中获取 `referer` 头部：

### 步骤 1: 创建一个 API 路由

在 Next.js 项目中，你可以在 `pages/api` 目录下创建一个新的 API 文件。比如说，创建一个名为 `referer.js` 的文件：

```js
// pages/api/referer.js

export default function handler(req, res) {
  const referer = req.headers['referer'] || 'Direct visit without referer';

  res.status(200).json({ referer });
}
```

这个 API 路由会检查来自客户端请求的 `referer` 头部，并将其发送回客户端。如果没有 `referer` 头部，它会假设是直接访问。

### 步骤 2: 在页面中调用 API

你可以在任何页面组件中调用这个 API 以获取 `referer` 头部。例如，在 `pages/index.js` 文件中：

```jsx
// pages/index.js
import { useEffect, useState } from 'react';

function HomePage() {
  const [referer, setReferer] = useState('');

  useEffect(() => {
    async function fetchReferer() {
      const response = await fetch('/api/referer');
      const data = await response.json();
      setReferer(data.referer);
    }

    fetchReferer();
  }, []);

  return (
    <div>
      <h1>Welcome to the homepage!</h1>
      <p>The referer URL is: {referer}</p>
    </div>
  );
}

export default HomePage;
```

这个例子中，页面会在加载时调用我们创建的 `/api/referer` API，并展示从哪里被访问。

### 注意事项

- 请注意，`referer` 头部可以被用户或某些浏览器扩展修改或删除，因此不应依赖于它来进行重要的安全决策。
- 这个方法主要用于跟踪和日志记录目的。

使用以上方法，你应该能够在 Next.js 应用中有效地获取并利用上一个页面的 URL。

Nextjs 如何获取上一个页面的 URL

在 Next.js 中，默认不支持使用 hash 路由（也称为 hash-based routing），这主要是因为 Next.js 是设计来支持服务端渲染（SSR）的，而 hash 路由主要用于客户端路由的管理。在使用 hash 路由时，路由的变化只在客户端发生，不会向服务器发送请求，这使得服务端渲染变得复杂或不可实现。

然而，如果你确实需要在 Next.js 项目中使用类似于 hash 路由的功能，有几种方法可以间接实现：

### 1. 使用 URL 的查询参数（Query strings）
你可以通过动态路由和查询参数来管理应用状态，而不是通过 hash。例如，你可以使用 Next.js 的动态路由功能来捕获路径和查询参数，然后在页面组件中根据这些参数调整显示内容。

```jsx
// pages/[section].js
import { useRouter } from 'next/router';

const SectionPage = () => {
  const router = useRouter();
  const { section, tab } = router.query;

  return (
    <div>
      <h1>当前部分: {section}</h1>
      {tab && <h2>当前标签页: {tab}</h2>}
    </div>
  );
};

export default SectionPage;
```

访问 `/section1?tab=tab1` 将渲染出当前部分为 `section1`，当前标签页为 `tab1`。

### 2. 客户端路由劫持
通过自定义 `_app.js` 文件，可以捕获路由事件并实现类似 hash 路由的效果。这涉及到监听路由变化事件并在发生变化时处理逻辑，但这会复杂一些，需要你对 Next.js 的路由系统有较深的理解。

### 3. 第三方库
使用一些客户端路由管理的第三方库，如 `react-router-dom`，这可以让你在 Next.js 中实现更灵活的客户端路由处理，包括 hash 路由。不过，这通常不推荐，因为它可能与 Next.js 的一些内置优化和功能相冲突。

综上所述，虽然 Next.js 本身不支持 hash 路由，但你可以通过其他方法达到类似的效果。根据你的具体需求选择合适的方案。

是否可以在nextjs 中使用 hash 路由？

在Next.js 14中设置cookie通常涉及服务端（例如在API路由中）和客户端两种情况。以下是在这两种情况下设置cookie的方法：

### 1. 在服务端设置Cookie（例如在API路由中）

在服务端设置cookie通常用于处理诸如身份验证后设置session cookie等场景。你可以使用Node.js的`http`模块或者使用第三方库如`cookie`和`js-cookie`来帮助设置。这里以`cookie`库为例，展示在API路由中如何设置cookie：

首先，你需要安装`cookie`库：

```bash
npm install cookie
```

然后，你可以在Next.js的API路由中设置cookie，如下所示：

```javascript
// pages/api/set-cookie.js
import { serialize } from 'cookie';

export default function handler(req, res) {
  const cookie = serialize('myCookie', 'cookieValue', {
    httpOnly: true,
    secure: process.env.NODE_ENV !== 'development',
    maxAge: 60 * 60 * 24 * 7, // 1 week
    path: '/',
  });

  res.setHeader('Set-Cookie', cookie);
  res.status(200).json({ message: 'Cookie has been set' });
}
```

### 2. 在客户端设置Cookie

在客户端设置cookie通常用于在用户的浏览器上存储非敏感信息。你可以使用`js-cookie`库来简化在客户端的cookie操作。首先，需要安装`js-cookie`：

```bash
npm install js-cookie
```

然后，在客户端代码中设置cookie，如下所示：

```javascript
import Cookies from 'js-cookie';

function setClientCookie() {
  Cookies.set('clientCookie', 'clientValue', { expires: 7, path: '' });
}
```

这个函数可以在任何客户端事件或React组件中调用，例如在用户点击按钮时设置cookie。

### 总结

使用Next.js时，根据你的具体需求（是否涉及敏感信息、是否需要服务端渲染等），你可以选择在服务端或客户端设置cookie。务必注意安全设置，如使用`httpOnly`和`secure`选项，以增强应用的安全性。

如何在 nextjs14 中设置 cookie

在Next.js中，如果您想在应用程序启动时运行某些函数或脚本，通常有几种方式可以实现这一点，取决于您希望执行这些脚本的具体场景和时机。以下是几种常见的方法：

### 1. 使用`getServerSideProps`或`getStaticProps`

如果您想在每次页面请求时运行某些代码，或者在构建时运行，可以使用`getServerSideProps`（服务端渲染）或`getStaticProps`（静态生成）。

**例子：**

假设您想在渲染首页之前从API获取一些数据。

```jsx
// pages/index.js
export async function getServerSideProps(context) {
  const res = await fetch('https://api.example.com/data');
  const data = await res.json();

  // 运行其他需要的函数
  customFunction();

  return {
    props: { data }, // 将data作为prop传递给页面组件
  };
}

function HomePage({ data }) {
  return (
    <div>
      <h1>Welcome to our website</h1>
      <p>{data.message}</p>
    </div>
  );
}

export default HomePage;

function customFunction() {
  console.log("这个函数在每次页面请求时被调用");
}
```

### 2. 在`_app.js`中运行代码

如果您希望在应用程序初始化时运行代码，可以在`_app.js`文件中添加逻辑。这个文件控制着Next.js应用的页面初始化。

**例子：**

```jsx
// pages/_app.js
function MyApp({ Component, pageProps }) {
  React.useEffect(() => {
    // 这里的代码在浏览器端运行，页面加载完成后运行
    console.log("应用启动了");
  }, []);

  // 进行API调用或其他服务器端逻辑
  serverInitFunction();

  return <Component {...pageProps} />
}

export default MyApp;

function serverInitFunction() {
  console.log("这个函数在服务器端运行，每次有新的请求时运行");
}
```

### 3. 使用自定义`server.js`文件

对于更复杂的场景，比如您需要在应用程序启动时连接数据库或执行一些只需运行一次的初始化脚本，您可以使用自定义的Node.js服务器。

**例子：**

```javascript
// server.js
const express = require('express');
const next = require('next');

const dev = process.env.NODE_ENV !== 'production';
const app = next({ dev });
const handle = app.getRequestHandler();

app.prepare().then(() => {
  const server = express();

  server.get('*', (req, res) => {
    return handle(req, res);
  });

  server.listen(3000, (err) => {
    if (err) throw err;
    console.log('> Ready on http://localhost:3000');
    // 运行启动脚本
    startupFunction();
  });
});

function startupFunction() {
  console.log("应用启动时运行此函数，只运行一次");
}
```

通过这些方法，您可以根据需要在Next.js应用程序启动时运行各种函数和脚本。

Nextjs 如何在启动应用程序时运行函数/脚本

在 Tailwind CSS 中使用模板文本来动态更改类是一种非常强大的技术，它能让我们根据不同的条件灵活地应用不同的样式类。主要的实现方法是通过 JavaScript (或者在使用现代前端框架时，如React、Vue等，通过框架内的绑定机制) 来动态构建 CSS 类字符串。

### 基本思路

基本的思路是使用 JavaScript 中的模板字符串功能（使用反引号 ` `` ` ），根据组件的状态或属性来动态插入所需的 Tailwind 类。

### 实例演示

#### 1. 纯 JavaScript 示例

假设我们有一个按钮，我们想根据一个变量 `isActive` 来改变它的背景色。

```html
<button id="myButton" class="p-2 text-white">Click me</button>

<script>
  const myButton = document.getElementById('myButton');
  let isActive = false;

  myButton.addEventListener('click', function() {
    isActive = !isActive;
    myButton.className = `p-2 text-white ${isActive ? 'bg-blue-500' : 'bg-red-500'}`;
  });
</script>
```

在这个例子中，每次按钮被点击时，`isActive` 的状态就会改变，随之按钮的 `className` 也会根据 `isActive` 的值动态更新。

#### 2. 在 React 中使用

在 React 中，你会使用类似的逻辑，但结合 React 的 state 和 JSX。

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

function DynamicButton() {
  const [isActive, setIsActive] = useState(false);

  return (
    <button
      className={`p-2 text-white ${isActive ? 'bg-blue-500' : 'bg-red-500'}`}
      onClick={() => setIsActive(!isActive)}
    >
      Click me
    </button>
  );
}

export default DynamicButton;
```

这里使用了 React 的 hooks（`useState`）来管理按钮的激活状态，并在按钮的 `className` 中动态插入了 Tailwind 的背景色类。

### 结论

通过这种方式，我们可以非常灵活地根据应用的状态动态地应用不同的 Tailwind CSS 类，从而实现更丰富的交互效果和视觉表现。这种技术在实际开发中非常实用，尤其是在需要根据用户行为或数据变化动态更改样式时。

如何使用 tailwindcss 中的模板文本来动态更改类？

在Next.js中持久存储数据，通常会涉及以下几种策略：

### 1. 客户端存储
客户端存储通常用于存储用户偏好设置、会话状态等，并且通常只在客户端有效。

- **LocalStorage**: 可用于存储较小的数据片段，数据会在浏览器关闭后依然保留。
  - **例子**: 保存用户的主题偏好设置。
  
    ```javascript
    if (typeof window !== "undefined") {
      localStorage.setItem('theme', 'dark');
    }
    ```

- **SessionStorage**: 类似于LocalStorage，但它的存储生命周期是一次会话（session）。
  - **例子**: 存储用户在一个会话期间的数据，例如表单的部分输入。

    ```javascript
    if (typeof window !== "undefined") {
      sessionStorage.setItem('form_data', JSON.stringify({ name: 'John Doe' }));
    }
    ```

- **Cookies**: 与LocalStorage和SessionStorage不同，cookies可以配置过期时间，而且每次请求时都会发送到服务器。
  - **例子**: 存储用户登录信息，以便进行自动登录。

    ```javascript
    document.cookie = "token=123456; expires=Fri, 31 Dec 2021 23:59:59 GMT";
    ```

### 2. 服务器端存储
在服务器端，你可以使用各种数据库系统来持久化数据，这对于需要跨多个用户或会话存储数据的应用程序来说非常重要。

- **关系型数据库**: 如PostgreSQL, MySQL等，适合结构化数据存储。
  - **例子**: 存储用户帐户信息。

    ```javascript
    // 使用sequelize或其他ORM
    User.create({
      username: 'johndoe',
      password: 'securepassword'
    });
    ```

- **NoSQL数据库**: 如MongoDB, DynamoDB等，适合灵活的、半结构化数据。
  - **例子**: 存储用户生成的内容，如博客帖子。

    ```javascript
    // 使用mongoose或其他NoSQL数据库客户端
    const post = new Post({
      title: 'My First Blog Post',
      content: 'Content of the blog post...',
      author: 'johndoe'
    });

    post.save();
    ```

- **文件系统**: 适合存储大型数据，例如上传的文件。
  - **例子**: 存储用户上传的图片。

    ```javascript
    // Node.js中使用fs模块
    const fs = require('fs');

    fs.writeFile('/path/to/file.jpg', imageData, (err) => {
      if (err) throw err;
      console.log('The file has been saved!');
    });
    ```

### 3. 云服务
云服务，如AWS S3，Google Cloud Storage等，可以用于存储大量数据和静态资源。

- **例子**: 存储用户上传的视频文件。

  ```javascript
  // 使用AWS SDK
  const AWS = require('aws-sdk');
  const s3 = new AWS.S3();

  s3.upload({
    Bucket: 'my-bucket',
    Key: 'user-uploads/video.mp4',
    Body: videoStream
  }, (err, data) => {
    if (err) throw err;
    console.log(`File uploaded successfully at ${data.Location}`);
  });
  ```

### 4. API或微服务
如果你的应用程序是微服务架构的一部分，你可能会通过API调用远程服务来持久化数据。

- **例子**: 通过一个用户管理服务的API来创建新用户。

  ```javascript
  fetch('https://user-management-service.com/users', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      username: 'johndoe',
      email: 'john@example.com'
    }),
  }).then(response => response.json())
    .then(data => console.log(data));
  ```

在选择持久化数据的方法时，需要根据应用程序的需求、数据的类型和大小、安全性需求以及开发和运营的成本来决定。

### 5. IndexedDB
对于需要在客户端存储大量结构化数据的场景，IndexedDB是一个好的选择。它是一个低级的API，允许存储大量数据并且能够创建索引以高效地查询数据。

- **例子**: 存储大型数据集，例如一个离线可用的产品目录。

  ```javascript
  if (typeof window !== "undefined") {
    let request = window.indexedDB.open('ProductCatalog', 1);

    request.onerror = function(event) {
      console.error('Database error:', event.target.error);
    };

    request.onupgradeneeded = function(event) {
      let db = event.target.result;
      let objectStore = db.createObjectStore('products', { keyPath: 'id' });
      objectStore.createIndex('name', 'name', { unique: false });
      objectStore.createIndex('price', 'price', { unique: false });
      // 省略了数据填充部分
    };

    request.onsuccess = function(event) {
      let db = event.target.result;
      let transaction = db.transaction(['products'], 'readwrite');
      let objectStore = transaction.objectStore('products');
      objectStore.add({ id: 1, name: 'Laptop', price: 999 });
    };
  }
  ```

### 6. 环境变量和配置文件
对于一些不经常改变但需要持久化的配置数据，可以使用环境变量或配置文件。

- **例子**: 存储应用程序的配置设置，如API密钥。

  ```javascript
  // 在 .env 文件中
  DATABASE_URL=your-database-url

  // 在 Next.js 中读取环境变量
  const { DATABASE_URL } = process.env;
  ```

### 7. 第三方数据服务
你还可以使用第三方提供的数据服务，例如Firebase Realtime Database或Firestore，来处理数据存储和同步。

- **例子**: 使用Firebase Firestore来存储和同步应用数据。

  ```javascript
  import firebase from 'firebase/app';
  import 'firebase/firestore';

  if (!firebase.apps.length) {
    firebase.initializeApp({
      // 你的Firebase配置
    });
  }

  const db = firebase.firestore();

  const userRef = db.collection('users').doc('user-id');
  userRef.set({
    username: 'johndoe',
    email: 'john@example.com'
  });
  ```

在Next.js中，你还需要考虑数据存储的位置对于性能的影响。例如，如果你使用SSR（服务器端渲染），你可能需要确保数据检索过程是高效的，因为它会直接影响页面加载时间。

最后，无论选择哪种持久化方法，都要考虑到数据的安全性，确保敏感信息被正确加密，使用安全的传输方式，并且合理管理数据的访问权限。

Making a localStorage in Next.js persist is very frustrating, but it is possible, this is a link that I think would help one who wants to store some user preferences and settings, without setting or adding a modal and db to store the user's input. [How to persist data in Next.js with localStorage and no libraries.](https://esselr.vercel.app/thoughts/how-to-persist-and-access-data-in-next-js-using-localstorage-typescript)

Here is a [demo](https://nextlocalstorage.vercel.app/)

In a real app situation you would have a backend which would return your user data (automatically based on a token which is normally saved as a cookie). So each time your app is initialised you would make a request to get your user data and store it in your state management (redux, recoil, etc).

But in your case you want to make sure that you update your `localStorage` each time your user changes (I don't think there is any other case you want to update the localStorage). So your first useEffect should have `user` value in the dependency array like this:

      useEffect(() => {
        if (user) {
          localStorage.setItem('nickname', user);
        }
      }, [user]);
    

If the `user` value hasn't changed it doesn't make sense to update it with the same value.

Also I think you don't need second useEffect if you add the state setting to your first one (so in the end use just one useEffect which looks like this:

      useEffect(() => {
        if (user) {
          localStorage.setItem('nickname', user);
          setNick(user);
        }
      }, [user]);
      
    

)

在Next.js中持久存储数据，通常会涉及以下几种策略：

### 1. 客户端存储
客户端存储通常用于存储用户偏好设置、会话状态等，并且通常只在客户端有效。

- **LocalStorage**: 可用于存储较小的数据片段，数据会在浏览器关闭后依然保留。
  - **例子**: 保存用户的主题偏好设置。
  
    ```javascript
    if (typeof window !== "undefined") {
      localStorage.setItem('theme', 'dark');
    }
    ```

- **SessionStorage**: 类似于LocalStorage，但它的存储生命周期是一次会话（session）。
  - **例子**: 存储用户在一个会话期间的数据，例如表单的部分输入。

    ```javascript
    if (typeof window !== "undefined") {
      sessionStorage.setItem('form_data', JSON.stringify({ name: 'John Doe' }));
    }
    ```

- **Cookies**: 与LocalStorage和SessionStorage不同，cookies可以配置过期时间，而且每次请求时都会发送到服务器。
  - **例子**: 存储用户登录信息，以便进行自动登录。

    ```javascript
    document.cookie = "token=123456; expires=Fri, 31 Dec 2021 23:59:59 GMT";
    ```

### 2. 服务器端存储
在服务器端，你可以使用各种数据库系统来持久化数据，这对于需要跨多个用户或会话存储数据的应用程序来说非常重要。

- **关系型数据库**: 如PostgreSQL, MySQL等，适合结构化数据存储。
  - **例子**: 存储用户帐户信息。

    ```javascript
    // 使用sequelize或其他ORM
    User.create({
      username: 'johndoe',
      password: 'securepassword'
    });
    ```

- **NoSQL数据库**: 如MongoDB, DynamoDB等，适合灵活的、半结构化数据。
  - **例子**: 存储用户生成的内容，如博客帖子。

    ```javascript
    // 使用mongoose或其他NoSQL数据库客户端
    const post = new Post({
      title: 'My First Blog Post',
      content: 'Content of the blog post...',
      author: 'johndoe'
    });

    post.save();
    ```

- **文件系统**: 适合存储大型数据，例如上传的文件。
  - **例子**: 存储用户上传的图片。

    ```javascript
    // Node.js中使用fs模块
    const fs = require('fs');

    fs.writeFile('/path/to/file.jpg', imageData, (err) => {
      if (err) throw err;
      console.log('The file has been saved!');
    });
    ```

### 3. 云服务
云服务，如AWS S3，Google Cloud Storage等，可以用于存储大量数据和静态资源。

- **例子**: 存储用户上传的视频文件。

  ```javascript
  // 使用AWS SDK
  const AWS = require('aws-sdk');
  const s3 = new AWS.S3();

  s3.upload({
    Bucket: 'my-bucket',
    Key: 'user-uploads/video.mp4',
    Body: videoStream
  }, (err, data) => {
    if (err) throw err;
    console.log(`File uploaded successfully at ${data.Location}`);
  });
  ```

### 4. API或微服务
如果你的应用程序是微服务架构的一部分，你可能会通过API调用远程服务来持久化数据。

- **例子**: 通过一个用户管理服务的API来创建新用户。

  ```javascript
  fetch('https://user-management-service.com/users', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      username: 'johndoe',
      email: 'john@example.com'
    }),
  }).then(response => response.json())
    .then(data => console.log(data));
  ```

在选择持久化数据的方法时，需要根据应用程序的需求、数据的类型

在Next.js中持久存储数据，通常会涉及以下几种策略：

### 1. 客户端存储
客户端存储通常用于存储用户偏好设置、会话状态等，并且通常只在客户端有效。

- **LocalStorage**: 可用于存储较小的数据片段，数据会在浏览器关闭后依然保留。
  - **例子**: 保存用户的主题偏好设置。
  
    ```javascript
    if (typeof window !== "undefined") {
      localStorage.setItem('theme', 'dark');
    }
    ```

- **SessionStorage**: 类似于LocalStorage，但它的存储生命周期是一次会话（session）。
  - **例子**: 存储用户在一个会话期间的数据，例如表单的部分输入。

    ```javascript
    if (typeof window !== "undefined") {
      sessionStorage.setItem('form_data', JSON.stringify({ name: 'John Doe' }));
    }
    ```

- **Cookies**: 与LocalStorage和SessionStorage不同，cookies可以配置过期时间，而且每次请求时都会发送到服务器。
  - **例子**: 存储用户登录信息，以便进行自动登录。

    ```javascript
    document.cookie = "token=123456; expires=Fri, 31 Dec 2021 23:59:59 GMT";
    ```

### 2. 服务器端存储
在服务器端，你可以使用各种数据库系统来持久化数据，这对于需要跨多个用户或会话存储数据的应用程序来说非常重要。

- **关系型数据库**: 如PostgreSQL, MySQL等，适合结构化数据存储。
  - **例子**: 存储用户帐户信息。

    ```javascript
    // 使用sequelize或其他ORM
    User.create({
      username: 'johndoe',
      password: 'securepassword'
    });
    ```

- **NoSQL数据库**: 如MongoDB, DynamoDB等，适合灵活的、半结构化数据。
  - **例子**: 存储用户生成的内容，如博客帖子。

    ```javascript
    // 使用mongoose或其他NoSQL数据库客户端
    const post = new Post({
      title: 'My First Blog Post',
      content: 'Content of the blog post...',
      author: 'johndoe'
    });

    post.save();
    ```

- **文件系统**: 适合存储大型数据，例如上传的文件。
  - **例子**: 存储用户上传的图片。

    ```javascript
    // Node.js中使用fs模块
    const fs = require('fs');

    fs.writeFile('/path/to/file.jpg', imageData, (err) => {
      if (err) throw err;
      console.log('The file has been saved!');
    });
    ```

### 3. 云服务
云服务，如AWS S3，Google Cloud Storage等，可以用于存储大量数据和静态资源。

- **例子**: 存储用户上传的视频文件。

  ```javascript
  // 使用AWS SDK
  const AWS = require('aws-sdk');
  const s3 = new AWS.S3();

  s3.upload({
    Bucket: 'my-bucket',
    Key: 'user-uploads/video.mp4',
    Body: videoStream
  }, (err, data) => {
    if (err) throw err;
    console.log(`File uploaded successfully at ${data.Location}`);
  });
  ```

### 4. API或微服务
如果你的应用程序是微服务架构的一部分，你可能会通过API调用远程服务来持久化数据。

- **例子**: 通过一个用户管理服务的API来创建新用户。

  ```javascript
  fetch('https://user-management-service.com/users', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      username: 'johndoe',
      email: 'john@example.com'
    }),
  }).then(response => response.json())
    .then(data => console.log(data));
  ```

在选择持久化数据的方法时，需要根据应用程序的需求、数据的类型
和大小、安全性需求以及开发和运营的成本来决定。

### 5. IndexedDB
对于需要在客户端存储大量结构化数据的场景，IndexedDB是一个好的选择。它是一个低级的API，允许存储大量数据并且能够创建索引以高效地查询数据。

- **例子**: 存储大型数据集，例如一个离线可用的产品目录。

  ```javascript
  if (typeof window !== "undefined") {
    let request = window.indexedDB.open('ProductCatalog', 1);

    request.onerror = function(event) {
      console.error('Database error:', event.target.error);
    };

    request.onupgradeneeded = function(event) {
      let db = event.target.result;
      let objectStore = db.createObjectStore('products', { keyPath: 'id' });
      objectStore.createIndex('name', 'name', { unique: false });
      objectStore.createIndex('price', 'price', { unique: false });
      // 省略了数据填充部分
    };

    request.onsuccess = function(event) {
      let db = event.target.result;
      let transaction = db.transaction(['products'], 'readwrite');
      let objectStore = transaction.objectStore('products');
      objectStore.add({ id: 1, name: 'Laptop', price: 999 });
    };
  }
  ```

### 6. 环境变量和配置文件
对于一些不经常改变但需要持久化的配置数据，可以使用环境变量或配置文件。

- **例子**: 存储应用程序的配置设置，如API密钥。

  ```javascript
  // 在 .env 文件中
  DATABASE_URL=your-database-url

  // 在 Next.js 中读取环境变量
  const { DATABASE_URL } = process.env;
  ```

### 7. 第三方数据服务
你还可以使用第三方提供的数据服务，例如Firebase Realtime Database或Firestore，来处理数据存储和同步。

- **例子**: 使用Firebase Firestore来存储和同步应用数据。

  ```javascript
  import firebase from 'firebase/app';
  import 'firebase/firestore';

  if (!firebase.apps.length) {
    firebase.initializeApp({
      // 你的Firebase配置
    });
  }

  const db = firebase.firestore();

  const userRef = db.collection('users').doc('user-id');
  userRef.set({
    username: 'johndoe',
    email: 'john@example.com'
  });
  ```

在Next.js中，你还需要考虑数据存储的位置对于性能的影响。例如，如果你使用SSR（服务器端渲染），你可能需要确保数据检索过程是高效的，因为它会直接影响页面加载时间。

最后，无论选择哪种持久化方法，都要考虑到数据的安全性，确保敏感信息被正确加密，使用安全的传输方式，并且合理管理数据的访问权限。

NextJS 中如何持久化存储数据？

在 Next.js 中，您可以使用两种主策略来代理请求到后端服务器：

### 1. 使用自定义服务器

您可以创建一个自定义的 Node.js 服务器，比如使用 Express.js，并在这个服务器中设置代理。这样，您可以在 Next.js 应用程序中捕获特定的 API 路径，并将它们转发到后端服务器。

以下是一个使用 Express 和 `http-proxy-middleware` 创建代理的示例：

首先，您需要安装 `http-proxy-middleware`：

```sh
npm install http-proxy-middleware
```

然后创建一个自定义的 Express 服务器，并使用 `http-proxy-middleware` 创建代理：

```js
const express = require('express');
const next = require('next');
const { createProxyMiddleware } = require('http-proxy-middleware');

const port = parseInt(process.env.PORT, 10) || 3000;
const dev = process.env.NODE_ENV !== 'production';
const app = next({ dev });
const handle = app.getRequestHandler();

app.prepare().then(() => {
  const server = express();

  // 设置代理规则
  server.use(
    '/api', // 代理路径
    createProxyMiddleware({
      target: 'http://backend-server.com', // 目标后端服务器
      changeOrigin: true,
      pathRewrite: {
        '^/api': '', // 重写路径
      },
    })
  );

  // 其余的所有请求都通过Next.js处理
  server.all('*', (req, res) => {
    return handle(req, res);
  });

  server.listen(port, (err) => {
    if (err) throw err;
    console.log(`> Ready on http://localhost:${port}`);
  });
});
```

在这个示例中，所有指向 `/api` 的请求都会被代理到 `http://backend-server.com`，并且请求路径会被重写，移除 `/api` 前缀。

### 2. 使用 Next.js API Routes

Next.js 允许您在 `pages/api` 目录中创建 API 路由。您可以在这些路由中使用 Node.js 代码来处理 HTTP 请求，并且还可以在这里设置代理。

```js
// pages/api/some-route.js
import { createProxyMiddleware } from 'http-proxy-middleware';

// 创建代理中间件
export const config = {
  api: {
    bodyParser: false,
    externalResolver: true,
  },
};

const proxy = createProxyMiddleware({
  target: 'http://backend-server.com',
  changeOrigin: true,
  pathRewrite: {
    '^/api': '', // 可以根据需要重写路径
  },
});

export default (req, res) => {
  if (res.finished) return;
  // 使用代理中间件处理请求
  return proxy(req, res, (result) => {
    if (result instanceof Error) {
      throw result;
    }
    throw new Error(`Request '${req.url}' is not proxied! We should never reach here!`);
  });
};
```

在这个例子中，`pages/api/some-route.js` 文件将处理所有指向 `/api/some-route` 的请求，并通过代理转发到后端。

注意：在生产环境中，通常建议直接在网络层级（例如使用 Nginx 或云服务提供商的功能）设置代理，以便于提高性能和可靠性。

使用这些方法，您可以在 Next.js 应用程序中设置代理服务器，并将请求代理到需要的后端服务器。

现在配置中有一个官方功能：**重写**

除了正常的路径重写之外，它们还可以将请求代理到另一个网络服务器

**`next.config.js`:**

    module.exports = {
      async rewrites() {
        return [
          {
            source: '/api/:path*',
            destination: 'http://localhost:8000/:path*' // Proxy to Backend
          }
        ]
      }
    }
    

请参阅[Next.js 文档重写](https://nextjs.org/docs/api-reference/next.config.js/rewrites)

我的**`server.js`**设置，希望对你有帮助：

    import express from 'express';
    import next from 'next';
    import proxy from 'http-proxy-middleware';
    
    const port = parseInt(process.env.PORT, 10) || 3000;
    const dev = process.env.NODE_ENV !== 'production';
    const app = next({ dev });
    const handle = app.getRequestHandler();
    
    app.prepare().then(() => {
        const server = express();
    
        server.use(
            '/api',
            proxy({
                target: process.env.API_HOST,
                changeOrigin: true,
            }),
        );
     
        server.all('*', (req, res) => handle(req, res));
    
        server.listen(port, err => {
            if (err) throw err;
            console.log(`> Ready on http://localhost:${port}`);
        });
    });
    

**`package.json`**:

    "scripts": {
        "dev": "NODE_ENV=development node -r esm server.js",
        "build": "NODE_ENV=production next build",
        "start": "NODE_ENV=production node -r esm server.js",
    },

另一个带有[包罗万象的路线的](https://nextjs.org/docs/routing/dynamic-routes#catch-all-routes)解决方案+ `http-proxy-middleware`：

    // pages/api/proxy/[...slug].js
    
    import { createProxyMiddleware } from "http-proxy-middleware"; // @2.0.6
    
    const proxy = createProxyMiddleware({
      target: process.env.BACKEND_URL,
      secure: false,
      pathRewrite: { "^/api/proxy": "" }, // remove `/api/proxy` prefix
    });
    
    export const config = {
      api: {
        externalResolver: true,
        bodyParser: false,
      },
    }
    
    export default function handler(req, res) {
      proxy(req, res, (err) => {
        if (err) {
          throw err;
        }
    
        throw new Error(
          `Request '${req.url}' is not proxied! We should never reach here!`
        );
      });
    }
    

请参阅： https: [//stackoverflow.com/a/72310680](https://stackoverflow.com/a/72310680)

重写对我不起作用，使用 axios 也不起作用`config.proxy`。

我诉诸了一个很好的老常数：

    const SERVER_URL = 
      process.env.NODE_ENV === 'production' ? 'https://produrl.com : 'http://localhost:8000';
    
    export async function getStaticProps() {
      const data = axios.get(`${SERVER_URL}/api/my-route`)
      // ...
    }
    

我更愿意代理请求并保持我的请求更干净，但我没有一天的时间来处理这个问题。

也许这个非常简单的设置会对其他人有所帮助。

NextJS 如何使用代理服务器将请求代理到后端？

在 Next.js 中，将查询参数附加到动态路由上的常见方法是通过使用链接组件（`Link`）或编程式导航（使用`router.push`或`router.replace`）来实现。

### 使用 Link 组件
当你使用 Next.js 的 `Link` 组件时，可以将查询参数作为对象传递给 `href` 属性。例如，假设你有一个动态路由 `[id].js`，你可以这样创建一个链接：

```jsx
import Link from 'next/link';

const MyComponent = () => {
  return (
    <Link href={{ pathname: '/post/[id]', query: { foo: 'bar' } }} as="/post/123?foo=bar">
      <a>Go to Post</a>
    </Link>
  );
};
```

在这个例子中，`pathname` 是路由模式，`query` 对象包含了你想要附加的查询参数。`as` 属性是实际的URL，可能包含查询参数，用于浏览器地址栏展示。

### 使用编程式导航
如果你想要在代码中触发导航，可以使用 Next.js 的 `useRouter` 钩子来获取 `router` 对象，然后调用 `push` 或 `replace` 方法。

```jsx
import { useRouter } from 'next/router';

const MyComponent = () => {
  const router = useRouter();

  const goToPost = () => {
    router.push({
      pathname: '/post/[id]',
      query: { foo: 'bar' },
    }, '/post/123?foo=bar');
  };

  return (
    <button onClick={goToPost}>Go to Post</button>
  );
};
```

在这个例子中，`pathname` 和 `query` 对象结构与使用 `Link` 组件时相同，`router.push` 的第二个参数是实际的URL，用于浏览器地址栏显示。

### 注意事项
- 在 `Link` 组件或 `router.push`/`router.replace` 中，`query` 参数是可选的。你可以仅提供动态路由的路径，而不带查询参数。
- 当你在 `as` 参数或 `router.push`/`router.replace` 的第二个参数中直接提供查询参数时，确保正确地编码URL，尤其是当查询参数值包含特殊字符时。
- 在动态路由页面中，你可以通过 `useRouter` 钩子的 `query` 对象访问这些查询参数。

下面是一个如何在动态路由页面中获取查询参数的例子：

```jsx
import { useRouter } from 'next/router';

const PostPage = () => {
  const router = useRouter();
  const { id, foo } = router.query;

  return (
    <div>
      <h1>Post: {id}</h1>
      <p>Query Parameter: {foo}</p>
    </div>
  );
};

export default PostPage;
```

这段代码展示了在动态路由页面 `PostPage` 中，如何使用 `useRouter` 的 `query` 对象来获取路由参数和查询参数。

只需向当前路由器添加更多参数，然后推送自身

    const router = useRouter();
    router.query.NEWPARAMS = "VALUE"
    router.push(router)

该解决方案不需要发送整个先前的路由，只需`replace`替换我们需要替换的内容，因此查询参数：

    const router = useRouter();
    router.replace({
       query: { ...router.query, key: value },
    });

如果我们想将其作为链接 - 像这样使用它：

    // ...
    const { query } = useRouter();
    // ...
    
    <Link
        href={{
            pathname: router.pathname,
            query: { ...query, lang },
        }}
        passHref
        shallow
        replace
    ></Link>

当您在 Next.js 中有动态路由并且想要对路由进行浅层调整以反映更新的查询参数时，另一种方法是尝试：

    const router = useRouter()
    const url = {
          pathname: router.pathname,
          query: { ...router.query, page: 2 }
        }
    router.push(url, undefined, { shallow: true })
    

这将检索当前路径 ( `router.pathname`) 和查询 ( `router.query`) 详细信息，并将它们与新的`page`查询参数合并。如果您忘记合并现有的查询参数，您可能会看到如下错误：

> 提供的 href 值缺少需要正确插值的查询值

我尝试将我的参数添加到路由查询中并推送路由器本身，如此处所述[，](https://stackoverflow.com/a/66382571/9424618)它有效，但我收到了很多警告： [![在此输入图像描述](https://i.stack.imgur.com/h0sqO.png)](https://i.stack.imgur.com/h0sqO.png)

因此，我然后推送`/`并传递了我的查询参数，如下所示：

    const router = useRouter();
    router.push({ href: '/', query: { myQueryParam: value  } });
    

我希望这也适合你。

NextJS 如何将 query 参数附加到动态路由上？

在使用 `next-i18next` 这个库时，获取当前语言可以通过多种方式实现，具体的方法取决于你是在服务端还是在客户端上下文中，以及你是在页面组件内部还是外部。以下是一些获取当前语言的方法：

### 1. 使用 `useTranslation` Hook

如果你在一个 React 函数组件中，可以使用 `useTranslation` Hook 来获取当前的语言环境。`useTranslation` 返回的对象中包含一个 `i18n` 实例，你可以从中获取当前的语言设置。

```javascript
import React from 'react';
import { useTranslation } from 'next-i18next';

const MyComponent = () => {
  const { i18n } = useTranslation();

  // 获取当前语言
  const currentLanguage = i18n.language;

  return <p>当前语言：{currentLanguage}</p>;
};

export default MyComponent;
```

### 2. 使用 `withTranslation` 高阶组件

如果你在使用类组件，或者出于某些原因想用高阶组件（HOC）的方式来获取当前语言，你可以使用 `withTranslation`。这同样会注入 `i18n` 实例到你的组件的 props 中：

```javascript
import React from 'react';
import { withTranslation } from 'next-i18next';

class MyComponent extends React.Component {
  render() {
    // 从 props 中获取 i18n 实例
    const { i18n } = this.props;

    // 获取当前语言
    const currentLanguage = i18n.language;

    return <p>当前语言：{currentLanguage}</p>;
  }
}

export default withTranslation()(MyComponent);
```

### 3. 使用 `getInitialProps` 或 `getServerSideProps`

在页面级组件中，你可以通过 `next-i18next` 的服务器端渲染方法来获取当前语言。`getInitialProps` 或者 `getServerSideProps` 都会收到包含 `req`（如果是服务器端的话）的 context 对象，从中可以读取当前语言：

```javascript
import { getServerSideProps } from 'next-i18next/serverSideTranslations';

export const getServerSideProps = async ({ locale }) => {
  // locale 变量包含当前语言环境
  return {
    props: {
      // 需要传递当前语言给页面组件
      language: locale,
    },
  };
};

// 然后在页面组件中使用该属性
const MyPage = ({ language }) => {
  return <p>当前语言：{language}</p>;
};

export default MyPage;
```

### 4. 使用 `Router` 或 `useRouter` Hook

在 `next/router` 中，`Router` 对象或者 `useRouter` Hook 返回的对象中也包含了当前的语言信息：

```javascript
import { useRouter } from 'next/router';

const MyComponent = () => {
  const router = useRouter();

  // 获取当前语言
  const currentLanguage = router.locale;

  return <p>当前语言：{currentLanguage}</p>;
};

export default MyComponent;
```

使用上述任何一种方法，你都可以有效地获取到当前设置的语言，并在你的应用程序中据此进行相应的国际化操作。

`withTranslation`注入`i18n`对象。

    import {withTranslation}  from '../config/next-i18next';
    
    const Home = function Home({ i18n }) {
      return (<div>{i18n.language}</div>)
      // ----------------^
    };
    
    Home.getInitialProps = async () => {
      return {namespacesRequired: ['home']}
    };
    
    export default withTranslation('home')(Home);
    

或者使用 Hooks，

    import {useTranslation}  from '../config/next-i18next';
    
    const Home = function Home() {
      const { i18n } = useTranslation('home');
      return (<div>{i18n.language}</div>)
      // ----------------^
    };
    
    Home.getInitialProps = async () => {
      return {namespacesRequired: ['home']}
    };
    
    export default Home;

对于 Next.js，您还可以使用[useRouter](https://nextjs.org/docs/api-reference/next/router)挂钩。

    import {withTranslation}  from '../config/next-i18next';
    import { useRouter } from 'next/router'
    
    const Home = function Home() {
    const router = useRouter()
    const currentLang =  router.locale // => locale string eg. "en"
      return (<div>test</div>)
    };
    
    Home.getInitialProps = async () => {
      return {namespacesRequired: ['home']}
    };
    
    export default withTranslation('home')(Home);

Nextjs i18next 如何获取当前语言?

在 Next.js 中设置每个页面的标题，您可以使用 `next/head` 模块来包含 HTML 的 `<head>` 部分内容，包括页面标题 `<title>` 标签。以下是如何为 Next.js 应用中的每个页面设置特定标题的步骤：

1. 引入 Head 组件
在您的页面组件文件中，首先需要从 `next/head` 引入 `Head` 组件。

```jsx
import Head from 'next/head';
```

2. 在页面组件中使用 Head 组件
在您的页面组件的 JSX 中，使用 `Head` 组件包裹 `<title>` 标签，并设置您想要的标题。

例如，如果您想为首页设置标题为 "Home Page"，您可以这样做：

```jsx
import Head from 'next/head';

export default function Home() {
  return (
    <>
      <Head>
        <title>Home Page</title>
      </Head>
      {/* 页面的其他内容 */}
    </>
  );
}
```

3. 为不同的页面设置不同的标题
对于您的应用中的每个页面，您可以重复上述步骤，为每个页面设置合适的标题。例如，如果您有一个关于页（about.js），可以设置标题为 "About Us"：

```jsx
import Head from 'next/head';

export default function About() {
  return (
    <>
      <Head>
        <title>About Us</title>
      </Head>
      {/* 关于页面的内容 */}
    </>
  );
}
```

这样每个页面都有个性化的标题，有利于用户体验和SEO优化。当页面被渲染时，浏览器标签上会显示相应的标题。

确保每个页面组件都包含对 `Head` 组件的使用，以确保所有页面都有明确的标题。如果您的应用具有动态页面或路由参数，您也可以根据页面内容或参数动态地设置标题。

您想要使用该`next/head`组件：

    import Head from 'next/head'
    
    export default () =>
      <div>
        <Head>
          <title>My page title</title>
          <meta name="viewport" content="initial-scale=1.0, width=device-width" />
        </Head>
    
        <p>Hello world!</p>
      </div>
    

请参阅文档： https: [//nextjs.org/docs/api-reference/next/head](https://nextjs.org/docs/api-reference/next/head)

_**在 NextJs v13 中 | v14 使用应用程序目录，**_您不必`'next/head'`再使用该组件。您需要做的只是定义一个导出的对象，无论是`layout.js`静态_**地**_`page.js`保留标题，如下例所示：

    export const metadata = {
      title: "Create Next App",
      description: "Generated by create next app",
    };
    

或者，如果您需要**动态**标题，您可以使用该`generateMetadata`函数来实现您需要的功能，如下例所示：

    //in this example I use the generateMetadata function to generate a multi languages title.
    
    export async function generateMetadata({ params: { lng } }) {
    
      const myTitle = lng === "en" ? "Hi" : "مرحبا";
    
      return {
        title: myTitle,
      };
    }
    

参考[基于配置的元数据](https://nextjs.org/docs/app/api-reference/functions/generate-metadata)

当您需要比服务器页面渲染更强大的功能`generateMetadata()`或`export const metadata: Metadata` 优化服务器页面渲染时**，**您可以使用这种简单但不太干净的方法......

    export default async function Page({params}: Props) {
       const extractedData = await extractData()
       const title = getTitle(params,extractedData);
       ...
       return <>
          <title>{title}</title>
          ...
         </>
      }
    

_使用这个......直到出现更好的底层架构。_

Nextjs 如何设置每个页面的标题？

在 Next.js 的服务器端渲染（SSR）环境中，由于没有浏览器窗口对象，无法直接通过 React Hook 获取窗口的大小。但是，我们可以通过使用 React 的生命周期方法来在客户端（浏览器环境）中获取窗口大小，并且可以通过设置状态来使其可用于组件。

下面是使用 React Hook `useState` 和 `useEffect` 来获取窗口大小的方法：

```jsx
import React, { useState, useEffect } from 'react';

const useWindowSize = () => {
  // 初始化状态为 undefined，因为在服务器端渲染时无法确定窗口大小
  const [windowSize, setWindowSize] = useState({
    width: undefined,
    height: undefined,
  });

  useEffect(() => {
    // 只有在客户端环境下才能运行这段代码
    if (typeof window !== 'undefined') {
      // 处理窗口大小变化的函数
      const handleResize = () => {
        setWindowSize({
          width: window.innerWidth,
          height: window.innerHeight,
        });
      };

      // 监听窗口大小变化
      window.addEventListener('resize', handleResize);

      // 立即调用一次，以获取初始窗口大小
      handleResize();

      // 清理函数，在组件卸载时移除事件监听
      return () => window.removeEventListener('resize', handleResize);
    }
  }, []); // 空数组确保效果只在组件挂载和卸载时运行

  return windowSize;
};

// 你的组件
const MyComponent = () => {
  const { width, height } = useWindowSize();

  return (
    <div>
      {width && height ? (
        <p>窗口大小：宽度 {width} px，高度 {height} px</p>
      ) : (
        <p>正在加载窗口大小...</p>
      )}
    </div>
  );
};

export default MyComponent;
```

在上面的代码中，我们定义了一个自定义 Hook `useWindowSize`，它返回当前的窗口大小。在服务器端渲染时，`windowSize` 的状态会被初始化为 `undefined`，因为没有窗口对象。在组件挂载到 DOM 后（客户端环境），`useEffect` 会被调用，这时我们可以安全地访问 `window` 对象来设置窗口大小。当窗口大小变化时，`handleResize` 函数会更新 `windowSize` 状态。

最后，在我们的组件 `MyComponent` 中，我们使用 `useWindowSize` 来获取并展示窗口大小。如果窗口大小还未确定（即在服务器端渲染期间），它可以显示一个加载提示或者某种占位内容。

您可以通过添加以下代码来避免在 ssr 中调用检测函数：

    // make sure your function is being called in client side only
    if (typeof window !== 'undefined') {
      // detect window screen width function
    }
    

您的链接中的完整示例：

    import { useState, useEffect } from 'react';
    
    // Usage
    function App() {
      const size = useWindowSize();
    
      return (
        <div>
          {size.width}px / {size.height}px
        </div>
      );
    }
    
    // Hook
    function useWindowSize() {
      // Initialize state with undefined width/height so server and client renders match
      // Learn more here: https://joshwcomeau.com/react/the-perils-of-rehydration/
      const [windowSize, setWindowSize] = useState({
        width: undefined,
        height: undefined,
      });
    
      useEffect(() => {
        // only execute all the code below in client side
        // Handler to call on window resize
        function handleResize() {
          // Set window width/height to state
          setWindowSize({
            width: window.innerWidth,
            height: window.innerHeight,
          });
        }
        
        // Add event listener
        window.addEventListener("resize", handleResize);
         
        // Call handler right away so state gets updated with initial window size
        handleResize();
        
        // Remove event listener on cleanup
        return () => window.removeEventListener("resize", handleResize);
      }, []); // Empty array ensures that effect is only run on mount
      return windowSize;
    }
    

注意：更新为 Sergey Dubovik 评论，我们不需要验证窗口，因为 useEffect 在客户端运行

由于某种原因，我遇到了错误，但这对我有用。仅适用于宽度：

    const useWidth = () => {
      const [width, setWidth] = useState(0)
      const handleResize = () => setWidth(window.innerWidth)
      useEffect(() => {
          handleResize()
          window.addEventListener('resize', handleResize)
          return () => window.removeEventListener('resize', handleResize)
          // eslint-disable-next-line react-hooks/exhaustive-deps
      }, [])
      return width
    }

NextJS 如何在 SSR 环境通过react hook获取窗口的大小？

在 Next.js 中，当页面切换时添加加载 loading 指示器可以使用几种不同的方法。以下是几个步骤和示例，说明如何实现这一功能：

### 使用路由事件监听

Next.js 的 `Router` 对象提供了路由事件，可以在路由开始和结束时触发函数。我们可以利用这些事件来展示和隐藏一个加载指示器。

```jsx
import { useState, useEffect } from 'react';
import Router from 'next/router';
import NProgress from 'nprogress'; // 这是一个轻量级的进度条库

// 在组件内部可以这样使用：
function MyApp({ Component, pageProps }) {
  const [loading, setLoading] = useState(false);

  useEffect(() => {
    const handleStart = () => setLoading(true); // 开始导航时设置加载状态
    const handleComplete = () => setLoading(false); // 完成导航时解除加载状态

    Router.events.on('routeChangeStart', handleStart);
    Router.events.on('routeChangeComplete', handleComplete);
    Router.events.on('routeChangeError', handleComplete); // 加载发生错误时也解除加载状态

    return () => {
      Router.events.off('routeChangeStart', handleStart);
      Router.events.off('routeChangeComplete', handleComplete);
      Router.events.off('routeChangeError', handleComplete);
    };
  }, []);

  return (
    <div>
      {loading && (
        <div className="loader">Loading...</div> // 这里可以自定义加载指示器的样式
      )}
      <Component {...pageProps} />
    </div>
  );
}
```

使用 `nprogress` 库可以使得加载指示器看起来更加专业和平滑。它会在页面顶部显示一个细长的进度条。使用时，你需要引入 `nprogress` 的样式文件，这通常在你的 `styles.css` 文件或者是 `App` 组件中完成。

```jsx
// 在 _app.js 或者其他全局组件中：

import NProgress from 'nprogress';
import 'nprogress/nprogress.css'; // 这是 nprogress 的默认样式
import Router from 'next/router';

NProgress.configure({ showSpinner: false }); // 你可以选择关闭加载旋转器

Router.events.on('routeChangeStart', () => NProgress.start());
Router.events.on('routeChangeComplete', () => NProgress.done());
Router.events.on('routeChangeError', () => NProgress.done());
```

### 使用自定义的 App 组件

自定义的 App 组件能够在路由变化时增加一个全局的加载状态。这里的原理和使用路由事件监听类似，但是它让你能够更容易地管理状态和传递 props。

```jsx
import App from 'next/app';
import NProgress from 'nprogress';
import Router from 'next/router';

class MyApp extends App {
  constructor(props) {
    super(props);
    this.state = { loading: false };

    Router.events.on('routeChangeStart', () => {
      this.setState({ loading: true });
      NProgress.start();
    });
    Router.events.on('routeChangeComplete', () => {
      this.setState({ loading: false });
      NProgress.done();
    });
    Router.events.on('routeChangeError', () => {
      this.setState({ loading: false });
      NProgress.done();
    });
  }

  render() {
    const { Component, pageProps } = this.props;
    return (
      <>
        {this.state.loading && <div className="loader">Loading...</div>}
        <Component {...pageProps} />
      </>
    );
  }
}

export default MyApp;
```

在上面的例子中，我们设置了一个 `loading` 状态，并在路由事件中相应地更新这个状态。然后，我们可以在渲染方法中使用这个状态来决定是否显示加载指示器。此外，我们还引入了 `NProgress` 来显示一个平滑的进度条。

### 结论

通过监听 Next.js 的路由事件，我们可以在页面切换时轻松地添加加载指示器。你可以使用简单的状态和条件渲染来实现，也可以使用如 `NProgress` 这样的库来展示一个更为专业的加载效果。在任何情况下

使用新的 hook api，我就是这样做的。

    function Loading() {
        const router = useRouter();
    
        const [loading, setLoading] = useState(false);
    
        useEffect(() => {
            const handleStart = (url) => (url !== router.asPath) && setLoading(true);
            const handleComplete = (url) => (url === router.asPath) && setLoading(false);
    
            router.events.on('routeChangeStart', handleStart)
            router.events.on('routeChangeComplete', handleComplete)
            router.events.on('routeChangeError', handleComplete)
    
            return () => {
                router.events.off('routeChangeStart', handleStart)
                router.events.off('routeChangeComplete', handleComplete)
                router.events.off('routeChangeError', handleComplete)
            }
        })
        
        return loading && (<div>Loading....{/*I have an animation here*/}</div>);
    }
    

现在`<Loading/>`每当路线发生变化时就会显示...我使用react-spring为其设置动画，但您可以使用您喜欢的任何库来执行此操作。

您甚至可以更进一步，通过修改获取 的`handleStart`和方法来修改组件何时显示。`handleComplete``url`

[nextjs-progressbar](https://www.npmjs.com/package/nextjs-progressbar)包使这变得超级简单。在 Next.js `_app.js`（或 `.jsx`、`.tsx`等）中，只需在默认导出中的任意位置添加`，如下所示： 

```
import NextNProgress from 'nextjs-progressbar';

export default function App({ Component, pageProps }) {
  return (
    <>
      <NextNProgress />
      <Component {...pageProps} />;
    </>
  );
} 
```

为什么不使用`nprogress`如下`_app.js`

    import React from 'react';
    import Router from 'next/router';
    import App, { Container } from 'next/app';
    import NProgress from 'nprogress';
    
    NProgress.configure({ showSpinner: publicRuntimeConfig.NProgressShowSpinner });
    
    Router.onRouteChangeStart = () => {
      // console.log('onRouteChangeStart triggered');
      NProgress.start();
    };
    
    Router.onRouteChangeComplete = () => {
      // console.log('onRouteChangeComplete triggered');
      NProgress.done();
    };
    
    Router.onRouteChangeError = () => {
      // console.log('onRouteChangeError triggered');
      NProgress.done();
    };
    
    export default class MyApp extends App { ... }
    

链接到[nprogress](http://ricostacruz.com/nprogress)。

您还需要包含样式文件。如果将 css 文件放在`static`目录中，则可以按如下方式访问样式：

    <link rel="stylesheet" type="text/css" href="/static/css/nprogress.css" />
    

确保 CSS 在所有页面中都可用...

它将适用于您所有更改的路线。

**NProgress 的新更新：**

    import Router from 'next/router'
    import Link from 'next/link'
    import Head from 'next/head'
    import NProgress from 'nprogress'
    
    Router.events.on('routeChangeStart', (url) => {
      console.log(`Loading: ${url}`)
      NProgress.start()
    })
    Router.events.on('routeChangeComplete', () => NProgress.done())
    Router.events.on('routeChangeError', () => NProgress.done())
    
    export default function App({ Component, pageProps }) {
      return (
        <>
          <Head>
            {/* Import CSS for nprogress */}
            <link rel="stylesheet" type="text/css" href="/nprogress.css" />
          </Head>
          <Component {...pageProps} />
        </>
      )
    }
    

如果您使用 Tailwind CSS，请从此处复制代码： https: [//unpkg.com/nprogress@0.2.0/nprogress.css](https://unpkg.com/nprogress@0.2.0/nprogress.css)并将代码粘贴到全局 CSS 文件[中](https://unpkg.com/nprogress@0.2.0/nprogress.css)[。](https://unpkg.com/nprogress@0.2.0/nprogress.css)

如果您想禁用微调器，请在文件中添加以下代码`_app.tsx/jsx`并从 CSS 中删除微调器样式。

    NProgress.configure({ showSpinner: false });
    

来源链接：

*   [https://github.com/rstacruz/nprogress](https://github.com/rstacruz/nprogress)
*   [https://nextjs.org/docs/api-reference/next/router](https://nextjs.org/docs/api-reference/next/router)

像 NProgress 这样的进度条有 90 行代码（而 NProgress v0.2.0 是 470 行 .js + 70 行 .css）：

    import { useEffect, useReducer, useRef } from 'react';
    
    import { assert } from './assert';
    import { wait } from './wait';
    import { getRandomInt } from './getRandomNumber';
    
    let waitController: AbortController | undefined;
    
    // https://gist.github.com/tkrotoff/db8a8106cc93ae797ea968d78ea28047
    export function useProgressBar({
      trickleMaxWidth = 94,
      trickleIncrementMin = 1,
      trickleIncrementMax = 5,
      dropMinSpeed = 50,
      dropMaxSpeed = 150,
      transitionSpeed = 600
    } = {}) {
      // https://stackoverflow.com/a/66436476
      const [, forceUpdate] = useReducer(x => x + 1, 0);
    
      // https://github.com/facebook/react/issues/14010#issuecomment-433788147
      const widthRef = useRef(0);
    
      function setWidth(value: number) {
        widthRef.current = value;
        forceUpdate();
      }
    
      async function trickle() {
        if (widthRef.current < trickleMaxWidth) {
          const inc =
            widthRef.current +
            getRandomInt(trickleIncrementMin, trickleIncrementMax); // ~3
          setWidth(inc);
          try {
            await wait(getRandomInt(dropMinSpeed, dropMaxSpeed) /* ~100 ms */, {
              signal: waitController!.signal
            });
            await trickle();
          } catch {
            // Current loop aborted: a new route has been started
          }
        }
      }
    
      async function start() {
        // Abort current loops if any: a new route has been started
        waitController?.abort();
        waitController = new AbortController();
    
        // Force the show the JSX
        setWidth(1);
        await wait(0);
    
        await trickle();
      }
    
      async function complete() {
        assert(
          waitController !== undefined,
          'Make sure start() is called before calling complete()'
        );
        setWidth(100);
        try {
          await wait(transitionSpeed, { signal: waitController.signal });
          setWidth(0);
        } catch {
          // Current loop aborted: a new route has been started
        }
      }
    
      function reset() {
        // Abort current loops if any
        waitController?.abort();
        setWidth(0);
      }
    
      useEffect(() => {
        return () => {
          // Abort current loops if any
          waitController?.abort();
        };
        // eslint-disable-next-line react-hooks/exhaustive-deps
      }, []);
    
      return {
        start,
        complete,
        reset,
        width: widthRef.current
      };
    }
    

    import { useRouter } from 'next/router';
    import { useEffect } from 'react';
    
    import { useProgressBar } from './useProgressBar';
    
    const transitionSpeed = 600;
    
    // https://gist.github.com/tkrotoff/db8a8106cc93ae797ea968d78ea28047
    export function RouterProgressBar(
      props?: Parameters<typeof useProgressBar>[0]
    ) {
      const { events } = useRouter();
    
      const { width, start, complete, reset } = useProgressBar({
        transitionSpeed,
        ...props
      });
    
      useEffect(() => {
        events.on('routeChangeStart', start);
        events.on('routeChangeComplete', complete);
        events.on('routeChangeError', reset); // Typical case: "Route Cancelled"
    
        return () => {
          events.off('routeChangeStart', start);
          events.off('routeChangeComplete', complete);
          events.off('routeChangeError', reset);
        };
        // eslint-disable-next-line react-hooks/exhaustive-deps
      }, []);
    
      return width > 0 ? (
        // Use Bootstrap, Material UI, Tailwind CSS... to style the progress bar
        <div
          className="progress fixed-top bg-transparent rounded-0"
          style={{
            height: 3, // GitHub turbo-progress-bar height is 3px
            zIndex: 1091 // $zindex-toast + 1 => always visible
          }}
        >
          <div
            className="progress-bar"
            style={{
              width: `${width}%`,
              //transition: 'none',
              transition: `width ${width > 1 ? transitionSpeed : 0}ms ease`
            }}
          />
        </div>
      ) : null;
    }
    

如何使用：

    // pages/_app.tsx
    
    import { AppProps } from 'next/app';
    import Head from 'next/head';
    
    import { RouterProgressBar } from './RouterProgressBar';
    
    export default function App({ Component, pageProps }: AppProps) {
      return (
        <>
          <Head>
            <title>My title</title>
            <meta name="description" content="My description" />
          </Head>
    
          <RouterProgressBar />
    
          <Component {...pageProps} />
        </>
      );
    }
    

更多信息：[https://gist.github.com/tkrotoff/db8a8106cc93ae797ea968d78ea28047](https://gist.github.com/tkrotoff/db8a8106cc93ae797ea968d78ea28047)

Nextjs 如何在加载页面时添加 loading ？

`componentWillMount` 和 `getInitialProps` 是两个不同阶段的函数，它们在Next.js中分别用于不同的目的，下面我会详细解释它们的区别：

### componentWillMount

请注意，`componentWillMount` 是 React 生命周期中的一个过时（deprecated）方法，原本它在组件的挂载（mounting）阶段被调用，即在组件被渲染到DOM之前。在这个生命周期方法中，开发者有时候会尝试执行状态的初始化或者执行一些预准备的操作。

然而，由于该方法可能会导致一些性能问题和逻辑混乱（例如，如果在服务器端渲染中使用它，会导致内存泄漏等问题），React 团队决定在未来的版本中将其完全废弃，并推荐开发者使用其他生命周期方法（如 `componentDidMount`）或功能钩子（hooks，如 `useEffect`）来代替。

### getInitialProps

`getInitialProps` 是 Next.js 提供的一个静态异步方法，它允许你在服务器渲染（Server-Side Rendering, SSR）或在页面渲染之前执行数据获取等异步操作。`getInitialProps` 将在页面级组件中被调用，无论是服务器渲染还是客户端路由跳转，都会被执行。该方法的返回值将作为props传递给组件。

**主要区别：**

- **生命周期和使用场景**：`componentWillMount` 是 React 组件的生命周期方法，而 `getInitialProps` 是 Next.js 的一个特有方法，用于数据获取和初始化。
- **执行环境**：`componentWillMount` 仅在客户端环境下工作，而 `getInitialProps` 可以在服务器端和客户端都执行。
- **异步操作**：`componentWillMount` 不支持异步操作，而 `getInitialProps` 设计之初就是为了处理异步数据获取。

**例子**：

假设有一个用户信息页面，需要根据用户ID从服务器获取用户数据。

```jsx
import React from 'react';
import axios from 'axios';

class UserProfile extends React.Component {
  static async getInitialProps(context) {
    // 从 context 参数中获取用户ID
    const { userId } = context.query;
    // 异步获取用户数据
    const response = await axios.get(`https://api.example.com/users/${userId}`);
    // 将获取到的数据作为 props 返回
    return { user: response.data };
  }

  render() {
    // 通过 getInitialProps 获取用户数据，并渲染到页面中
    const { user } = this.props;
    return (
      <div>
        <h1>{user.name}</h1>
        <p>Email: {user.email}</p>
      </div>
    );
  }
}

export default UserProfile;
```

在这个例子中，我们使用 `getInitialProps` 来在页面组件渲染之前获取用户数据。`getInitialProps` 将数据返回，然后作为 props 传递给 `UserProfile` 组件，从而能够实现服务器端渲染，也支持客户端路由跳转时的数据获取。

总结来说，`componentWillMount` 已经在 React 中被弃用，而 `getInitialProps` 是 Next.js 特有的一个功能强大的数据获取方法，它在 SSR 场景下特别有用。在实际开发中，建议使用在 Next.js 9.3 之后引入的 `getStaticProps` 或 `getServerSideProps` 来代替 `getInitialProps`，因为这两种方法提供了更为细粒度的控制，并优化了性能。

Nextjs 组件中 componentwillmount 与 getinitialrops 的区别是什么？

在使用 Next.js 开发应用程序时，跨源资源共享（CORS）是一个常见的问题，因为浏览器出于安全考虑限制了跨域 HTTP 请求。Next.js 可以通过几种方式来解决 CORS 跨域问题：

### 1. 后端代理

Next.js 支持创建 API 路由，这意味着我们可以在 Next.js 应用程序中创建一个代理路由，将请求从前端发送到这个代理路由，然后由这个路由将请求转发到目标服务器。这种方式可以避免直接从前端向目标服务器发送跨域请求。例如：

```jsx
// pages/api/proxy.js
export default async (req, res) => {
  const { query } = req;
  // 目标服务器的URL
  const targetUrl = 'https://example.com/api/data';

  try {
    const apiResponse = await fetch(targetUrl, {
      headers: {
        // 设置必要的头信息
        'Content-Type': 'application/json',
        // 如有需要，这里可以添加认证等其他头信息
      },
    });

    const data = await apiResponse.json();
    res.status(200).json(data);
  } catch (error) {
    res.status(500).json({ message: 'Error fetching data' });
  }
};
```

### 2. 配置CORS策略

如果你控制着目标服务器，你可以在服务器上设置 CORS 策略以允许来自你的 Next.js 应用程序的请求。这通常涉及到在服务器的响应头中设置 `Access-Control-Allow-Origin` 和其他相关的 CORS 头。例如，如果你的服务器是用 Express.js 构建的，你可以使用 `cors` 中间件来简化这个过程：

```javascript
// 在你的 Express 应用中
const cors = require('cors');

app.use(cors({
  origin: 'https://your-nextjs-app.com' // 允许你的 Next.js 应用域名的请求
}));
```

### 3. 使用第三方服务

如果无法控制服务器的 CORS 策略，并且你需要某种快速的解决方案，你也可以利用一些第三方的服务或代理，例如 `https://cors-anywhere.herokuapp.com/`，这些服务可以作为代理转发你的请求，并附加正确的 CORS 头信息。但是，这应该只作为临时解决方案，因为它可能引入额外的延迟，并且可能不安全。

### 4. Next.js 中间件（Next.js 12+ 版本）

从 Next.js 12 开始，Next.js 引入了中间件功能，这允许你在请求到达页面或 API 路由之前执行服务器端代码。你可以在中间件中添加 CORS 头，从而处理跨域请求：

```jsx
// pages/_middleware.js
import { NextResponse } from 'next/server';

export function middleware(req) {
  const res = NextResponse.next();

  res.headers.set('Access-Control-Allow-Origin', '*');
  res.headers.set('Access-Control-Allow-Methods', 'GET,POST,PUT,PATCH,DELETE,OPTIONS');
  res.headers.set('Access-Control-Allow-Headers', 'Content-Type,Authorization');

  return res;
}
```

以上是处理 Next.js 应用中 CORS 问题的几种方法。选择哪一种方法取决于你的应用需求、安全性要求以及你是否能控制服务器端。

我[在这里](https://nextjs.org/docs/api-reference/next.config.js/rewrites)找到了一个解决方案：

基本上，我只需要在根目录中添加一个 next.config.js 文件并添加以下内容：

    // next.config.js
    module.exports = {
        async rewrites() {
            return [
              {
                source: '/api/:path*',
                destination: 'https://api.example.com/:path*',
              },
            ]
          },
      };

如果你想使用 `cors`中的库 `nextjs`，可以考虑使用[`nextjs-cors`](https://www.npmjs.com/nextjs-cors)。

[https://www.npmjs.com/nextjs-cors](https://www.npmjs.com/nextjs-cors)

[https://github.com/yonycalsin/nextjs-cors](https://github.com/yonycalsin/nextjs-cors)

> 页面/api/whoami.{ts,js}

```
import NextCors from 'nextjs-cors';

async function handler(req, res) {
   // Run the cors middleware
   // nextjs-cors uses the cors package, so we invite you to check the documentation https://github.com/expressjs/cors
   await NextCors(req, res, {
      // Options
      methods: ['GET', 'HEAD', 'PUT', 'PATCH', 'POST', 'DELETE'],
      origin: '*',
      optionsSuccessStatus: 200, // some legacy browsers (IE11, various SmartTVs) choke on 204
   });

   // Rest of the API logic
   res.json({ message: 'Hello NextJs Cors!' });
}
```

我遇到了类似的问题，我是从这个页面拨打电话的：

**页面/page1.js**

      export default async function page1() {
           const data = await axios.post('https://www.dominio.com/xxx' , {param: 1}, headers)
    }
    

但解决方案是对“pages/api”目录中的本地 API 文件进行 axios 调用，该本地 API 文件将处理对外部 Web 服务器的请求。这避免了 CORS 问题。

**页面/page1.js**

    export default async function page1() {
            const data = await axios.post('/api/get_page1_data', {param: 1} )
    }
    

**页面/api/get\_page1\_data.js**

    export default async function handler(req, res) {
    try{
       const data = await axios.post('https://www.dominio.com/xxx' , {param: req.body.param}, headers)
        res.status(200).json(data)
     } catch (error) {
        console.error(error)
        return res.status(error.status || 500).end(error.message)
      }

这是服务器不接受 OPTIONS 请求的问题，因为路由被声明为 GET::something 或 POST::something，所以预检无法通过并且 POST 请求被拒绝，希望这将帮助其他人避免几个小时谷歌搜索，所以在我的例子中（Node.js + Express.js）我必须将其添加到我的 server.js 中

      app.use((req, res, next) => {
        res.header("Access-Control-Allow-Origin", "*");
        res.header(
          "Access-Control-Allow-Headers",
          "Origin, X-Requested-With, Content-Type, Accept, Authorization"
        );
      if (req.method == "OPTIONS") {
        res.header("Access-Control-Allow-Methods", "PUT, POST, PATCH, DELETE, GET");
        return res.status(200).json({});
      }
    
      next();
    });

额外检查一下您的基本网址是否正确，这是我的问题

Nextjs 如何解决 cors 问题？

在 Next.js 项目中，您可以通过几种不同的方式获取当前页面的 URL 或 host。以下是一些通用方法：

### 在服务器端（getServerSideProps 或 API 路径中）

在 Next.js 的服务器端代码中，例如在 `getServerSideProps` 或 API 路径中，您可以直接从请求对象中获取 host 和完整 URL。

```jsx
export async function getServerSideProps(context) {
  const { req } = context;
  const host = req.headers.host; // 获取 host
  const protocol = req.headers['x-forwarded-proto'] || 'http';

  // 注意：在 Vercel 或其他云服务上部署时，使用 'x-forwarded-proto' 头来确定协议可能更为准确。
  const fullUrl = `${protocol}://${host}${req.url}`; // 获取完整 URL

  return {
    props: {}, // 将所需数据作为 props 传递给页面
  };
}
```

注意：`req.url` 仅包含 URL 的路径和查询字符串，而不包含协议和主机名。

### 在客户端（使用 useRouter 或 window 对象）

在客户端，您可以使用 Next.js 的 `useRouter` 钩子或浏览器的 `window` 对象来获取当前页面的 URL。

使用 `useRouter` 钩子：

```jsx
import { useRouter } from 'next/router';

const MyComponent = () => {
  const router = useRouter();
  const currentPath = router.asPath; // 获取路由的路径和查询字符串

  // 在客户端，可以使用 window 对象获取当前页面的完整 URL
  const fullUrl = window.location.href;

  return (
    // ...
  );
};

export default MyComponent;
```

直接使用 `window.location` 对象：

```jsx
const MyComponent = () => {
  // 确保在组件加载到浏览器后才使用 window 对象
  React.useEffect(() => {
    const fullUrl = window.location.href;
    // 使用 fullUrl
  }, []);

  return (
    // ...
  );
};

export default MyComponent;
```

确保在使用 `window` 对象时，代码被包裹在 `useEffect` 钩子或任何确保代码在客户端执行的逻辑中，以避免在构建时出现引用错误。

### 使用 Next.js 的 Head 组件动态设置元信息

如果您想要在页面的 `<head>` 标签中使用 URL 或 host，您可以使用 Next.js 的 `Head` 组件在服务器端渲染时动态添加元信息。

```jsx
import Head from 'next/head';
import { useRouter } from 'next/router';

const MyPage = () => {
  const router = useRouter();
  const currentPath = router.asPath;

  return (
    <>
      <Head>
        <link rel="canonical" href={`https://yourdomain.com${currentPath}`} />
      </Head>
      {/* 页面内容 */}
    </>
  );
};

export default MyPage;
```

在这个示例中，`<link rel="canonical">` 标签被设置为当前页面的完整 URL，假设您已知您的域名。如果域名未知或变化，您可能需要将其作为配置参数传递或从服务器端代码中获取。

### 获取动态路由参数

如果您的页面路径包含动态路由参数，如 `[id].js`，您可以使用 `useRouter` 钩子或 `getServerSideProps` 函数中的 `context` 对象来获取这些参数。

使用 `useRouter` 钩子：

```jsx
const MyComponent = () => {
  const router = useRouter();
  const { id } = router.query; // 获取动态路由参数
  // ...
};
```

在 `getServerSideProps` 中：

```jsx
export async function getServerSideProps(context) {
  const { params } = context;
  const { id } = params; // 获取动态路由参数
  // ...
}
```

使用这些参数，您可以构建相关联的 URL 或在页面中使用这些值。

总之，获取当前页面的 URL 或 host 可以根据运行上下文（服务器端或客户端）和您的特定需求采取不同的方式

如果您想要服务器端 getInitialProps 中的主机名，您仍然可以从 req 获取它

    Home.getInitialProps = async(context) => {
       const { req, query, res, asPath, pathname } = context;
       if (req) {
          let host = req.headers.host // will give you localhost:3000
         }
      }

通过服务器端渲染 ( `getServerSideProps`)，您可以使用`context.req.headers.host`：

    import type { GetServerSideProps, NextPage } from "next";
    
    type Props = { host: string | null };
    
    export const getServerSideProps: GetServerSideProps<Props> =
      async context => ({ props: { host: context.req.headers.host || null } });
    
    const Page: NextPage<Props> = ({ host }) => <p>Welcome to {host || "unknown host"}!</p>;
    
    export default Page;
    

但使用静态生成 ( `getStaticProps`) 时，主机名不可用，因为没有请求从中获取主机名。一般来说，服务器不知道自己的公共主机名，因此您需要告诉它。使用[Next.js 环境变量](https://nextjs.org/docs/basic-features/environment-variables)，将其放入`.env.local`：

    HOST=example.com
    

然后使用以下命令访问它`process.env['HOST']`：

    import type { GetStaticProps } from "next";
    
    export const getStaticProps: GetStaticProps<Props> = 
      async context => ({ props: { host: process.env['HOST'] || null }});

如果你想获取完整的 URL：

    import { useRouter } from 'next/router';
    

    const { asPath } = useRouter();
        const origin =
            typeof window !== 'undefined' && window.location.origin
                ? window.location.origin
                : '';
    
        const URL = `${origin}${asPath}`;
        console.log(URL);

您访问的位置请`window`确保添加检查，以便代码仅在浏览器上执行，而不会在 SSG 期间执行”

    if (typeof window !== 'undefined') {
       const hostname = window.location.hostname;
    }
    

**更新**：如果您已`basePath`指定`next.config.js`：

    module.exports = {
      basePath: 'https://www.example.com/docs',
    }
    

然后使用`useRouter`，您可以访问基本路径：

    import { useRouter } from 'next/router'
    
    function Component() {
       const router = useRouter();
       
       console.log({ basePath: router.basePath}); 
       // { basePath: 'https://www.example.com/docs' }
    
       ...
    }
    

但是如果您有相对基本路径，那么您可以使用第一种方法

根据[此处提到的答案](https://stackoverflow.com/a/76056858/6908282)，您可以使用以下代码使用新的应用程序目录（对于服务器端组件）获取 Next 13 中的主机名：

    import { headers } from 'next/headers';
    
    export default function Home() {
      const headersList = headers();
      
      headersList.get('host'); // to get domain
      headersList.get('next-url'); // to get url
    
      return <div>....</div>
    }
    

> 注意：请注意，[在布局或页面中使用它会在请求时选择一条进入动态渲染的路线](https://nextjs.org/docs/app/api-reference/functions/headers#:%7E:text=Using%20it%20in%20a%20layout%20or%20page%20will%20opt%20a%20route%20into%20dynamic%20rendering%20at%20request%20time)

Nextjs 项目如何获取页面 url 或 host ？

在 Next.js 中，导入并使用 SVG 文件有几种方法，以下是几种常见的做法：

### 1. 使用图片标签 `<img>`

这是最简单的方法，直接将 SVG 作为图片源引入：

```jsx
import React from 'react';

const MyComponent = () => (
  <div>
    <img src="/path/to/your-image.svg" alt="My SVG Image" />
  </div>
);

export default MyComponent;
```

在这个例子中，您只需要将 SVG 文件放到公共文件夹（通常是 `public` 文件夹）中，然后像引用常规图片一样引用 SVG 文件。

### 2. 使用 Next.js 的 Image 组件

Next.js 提供了一个内置的 `Image` 组件，用于优化图片加载：

```jsx
import Image from 'next/image';
import React from 'react';

const MyComponent = () => (
  <div>
    <Image src="/path/to/your-image.svg" alt="My SVG Image" width={500} height={500} />
  </div>
);

export default MyComponent;
```

和上述 `<img>` 标签方法类似，您需要把 SVG 图片放在 `public` 目录下。

### 3. 使用 SVG 作为组件

从 Next.js 9.5.4 开始，您可以通过 `next.config.js` 配置文件中的 `inline-react-svg` 插件，直接将 SVG 文件导入为 React 组件：

首先，您需要安装相应的插件：

```bash
npm install react-svg-loader --save-dev
```

接着在 `next.config.js` 中配置：

```js
const withReactSvg = require('next-react-svg');
const path = require('path');

module.exports = withReactSvg({
  include: path.resolve(__dirname, 'path/to/svgs'),
  webpack(config, options) {
    return config;
  }
});
```

然后您可以直接导入 SVG 文件并将其作为组件使用：

```jsx
import React from 'react';
import YourSvg from '/path/to/your-image.svg';

const MyComponent = () => (
  <div>
    <YourSvg />
  </div>
);

export default MyComponent;
```

这使得 SVG 的处理就像 React 组件一样简单，您可以轻松地给 SVG 添加 `className` 或其他属性。

### 4. 使用 `next-svg`

`next-svg` 是一个 Next.js 插件，允许您在 Next.js 项目中直接导入 SVG 文件作为 React 组件。使用方法类似于 `next-react-svg`，首先安装插件，然后在 `next.config.js` 中进行配置。

以上就是在 Next.js 中导入 SVG 文件的几种方法。您可以根据项目需求和个人喜好选择合适的方法。

您需要提供一个 webpack 加载器来处理 SVG 导入，其中著名的加载器之一是[svgr](https://github.com/smooth-code/svgr)。

为了将其配置为与下一个一起使用，您需要将`next.config.js`加载程序的用法添加到文件中，如下所示：

    // next.config.js
        
    module.exports = {
      webpack(config) {
        config.module.rules.push({
          test: /\.svg$/,
          issuer: {
            test: /\.(js|ts)x?$/,
           // for webpack 5 use
           // { and: [/\.(js|ts)x?$/] }
          },
          
          use: ['@svgr/webpack'],
        });
    
        return config;
      },
    };
    

有关更多配置信息，[请查看文档](https://www.smooth-code.com/open-source/svgr/docs/webpack/)。

**不要忘记**先安装[`@svgr/webpack`](https://npm.im/@svgr/webpack)：

    $ npm install --save-dev @svgr/webpack
    

**编辑**

我添加了一个`issuer`部分，将这些 svg 严格限制为仅适用于从文件导入的 svg `js / ts`。`svg`这允许您为从其他文件类型（例如`.css`）导入的 s配置其他行为

快速方法：`<img>`或者`<Image>`
-----------------------

[**不适合交互式 SVG 或者如果您打算通过外部 CSS/JS 操作 SVG**](https://developer.mozilla.org/en-US/docs/Learn/HTML/Multimedia_and_embedding/Adding_vector_graphics_to_the_Web#the_quick_way_img_element)

可以使用官方[`next/image`](https://nextjs.org/docs/api-reference/next/image)组件或标签（如本[答案](https://stackoverflow.com/a/63626899/11613622)`img`中所述）。[](https://stackoverflow.com/a/63626899/11613622)

您只需将`svg`文件移至[`public`](https://nextjs.org/docs/basic-features/static-file-serving)而不是`static`，然后执行如下操作：

    import Image from 'next/image';
    
    // ...
    
    <Image src="/Rolling-1s-200px.svg" width="2000" height="2000" />
    

但是使用这种方法，`svg`文件的内容不会直接出现在响应中；浏览器将获得一个[`<img src="..." ...></img>`](https://caniuse.com/svg-img)标签。

还需要指定`width`和`height`，但您可以根据[`viewbox`](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/viewBox)属性计算它。

在 Next.js v11 及更高版本上，您还可以执行以下操作：

    import Image from 'next/image';
    
    import Illustration from '../static/Rolling-1s-200px.svg';
    
    // ...
    
    <Image src={Illustration} />
    
    // one needs to use `Illustration.src` to get the source URL
    // <img src={Illustration.src} ... />
    

* * *

在 HTML 中包含 SVG（适用于 webpack-5、TS）
--------------------------------

接受[的答案](https://stackoverflow.com/a/55180310/11613622)已经显示了如何使用 执行此操作`webpack-4`，但由于`webpack-5`现在是默认值，因此我正在共享适当的配置。安装后即可使用[`@svgr/webpack`](https://react-svgr.com/docs/webpack/)（`yarn add -D @svgr/webpack`或`npm install @svgr/webpack --save-dev`）：

    // next.config.js
    // https://github.com/gregberge/svgr/issues/551#issuecomment-839772396
    
    module.exports = {
      // other configs...
    
      // future: { webpack5: true }, // -- not needed since Next.js v11.0.0
      webpack(config) {
        config.module.rules.push({
          test: /\.svg$/i,
          issuer: { and: [/\.(js|ts|md)x?$/] },
          use: [
            {
              loader: '@svgr/webpack',
              options: {
                prettier: false,
                svgo: true,
                svgoConfig: { plugins: [{ removeViewBox: false }] },
                titleProp: true,
              },
            },
          ],
        });
        return config;
      },
    };
    

如果您不使用`options`加载程序，那么您可以简单地编写以下内容：

    use: ['@svgr/webpack']
    

如果您使用的是 v6，`@svgr/webpack`则需要像这样指定 SVGO 配置：

    // ...
    
    plugins: [
      {
        name: 'preset-default',
        params: {
          overrides: { removeViewBox: false },
        },
      },
    ],
    
    // ...
    

如果使用打字稿，您需要定义适当的模块（在导入的目录中`svg`，或者可能将其添加到根目录中`<some-name>.d.ts`并包含它`tsconfig`）：

    // index.d.ts
    
    declare module '*.svg' {
      const ReactComponent: React.FC<React.SVGProps<SVGSVGElement>>;
      export default ReactComponent;
    }
    

然后你可以像这样使用它：

    import Illustration from '../static/Rolling-1s-200px.svg';
    
    // ...
    
    <Illustration />
    

**注意**：Next.js v11.0.1+ 已将 SVG 声明为导出模块`any`。您的自定义配置不会覆盖设置的类型，`next-env.d.ts`除非您排除后者。请参考[这个](https://stackoverflow.com/a/68129058/11613622)。

**\[_已过时（[已修复](https://github.com/vercel/next.js/pull/26281)）_ \]更新：**

如果您使用的是 Next.js v11.0.0，那么您在导入 SVG 时可能会遇到错误。请更新至`v11.0.1`或以上。[请遵循此评论](https://github.com/vercel/next.js/issues/26130#issuecomment-861731681)中提到的解决方法。[](https://github.com/vercel/next.js/issues/26130#issuecomment-861731681)

* * *

使用涡轮包装？
-------

`@svgr/webpack`你可以这样添加：

    // next.config.mjs
    
    export default {
      experimental: {
        turbo: {
          rules: {
            '*.svg': {
              loaders: ['@svgr/webpack'],
              as: '*.js'
            }
          }
        }
      }
    }
    

（摘自[https://x.com/leeerob/status/1755974197581603210](https://x.com/leeerob/status/1755974197581603210)）

安装[下一个图像](https://github.com/twopluszero/next-images)。

    yarn add -D next-images
    

在项目中创建 next.config.js

    // next.config.js
    const withImages = require('next-images')
    module.exports = withImages()

我个人更喜欢[next-react-svg](https://github.com/jeremybarbet/next-react-svg)插件，它允许将 SVG 图像视为 React 组件并自动内联它们，类似于 Create React App 的做法。

以下是如何使用它：

1.  安装`next-react-svg`：

    npm i next-react-svg
    

2.  添加必要的设置`next.config.js`：

    const withReactSvg = require('next-react-svg')
    const path = require('path')
    
    module.exports = withReactSvg({
      include: path.resolve(__dirname, 'src/assets/svg'),
      webpack(config, options) {
        return config
      }
    })
    

**该`include`参数是强制性的**，它指向您的 SVG 图像文件夹。

如果您已经为 Next.js 启用了任何插件，请考虑使用[next-compose-plugins](https://github.com/cyrilwanner/next-compose-plugins)来正确组合它们。

3.  将 SVG 作为普通 React 组件导入：

    import Logo from 'assets/svg/Logo.svg';
    
    export default () => (
      <Logo />
    );
    

就是这样。从现在开始，Next.js 将以这种方式导入的 SVG 图像作为 SVG 标签包含到渲染的标记中。

您可以使用[babel-plugin-inline-react-svg](https://github.com/airbnb/babel-plugin-inline-react-svg)

    import React from 'react';
    import CloseSVG from './close.svg';
    
    const MyComponent = () => <CloseSVG />;
    

    npm install --save-dev babel-plugin-inline-react-svg
    

    // .babelrc
    {
      "plugins": [
        "inline-react-svg"
      ]
    }
    

或者查看链接以获取更多说明。

如何将svg文件导入下一个js？

在Next.js中，管理不同环境（开发、测试、生产）的配置可以通过使用不同的`.env`文件实现。Next.js支持环境变量的加载，并且有一套特定的规则用于加载不同环境的`.env`文件。以下是如何使用不同的`.env`文件的步骤：

1. **创建`.env`文件**:
   在Next.js项目的根目录中，你可以创建以下`.env`文件来定义环境变量：

   - `.env.local`: 可以覆盖其他`.env`文件中的变量，不会被git版本控制系统跟踪，通常用于包含敏感信息。
   - `.env.development`: 只在`next dev`（即开发环境）中被加载。
   - `.env.production`: 只在`next start`（即生产环境）中被加载。
   - `.env.test`: 在执行自动化测试时使用，需要自己配置加载机制。
   - `.env`: 默认的环境变量文件，无论何种环境都会被加载，但会被以上特定环境的配置覆盖。

2. **设置环境变量**:
   在每个`.env`文件中，设置必要的环境变量，格式如下：

   ```plaintext
   # .env.local
   API_SECRET=local_secret

   # .env.development
   API_URL=https://dev.example.com/api

   # .env.production
   API_URL=https://prod.example.com/api
   ```

3. **加载环境变量**:
   Next.js会自动加载这些变量，无需额外的配置。你可以在代码中通过`process.env`来访问这些变量：

   ```javascript
   console.log(process.env.API_URL); // 输出将根据当前环境加载对应的.env文件中的变量值
   ```

4. **使用环境变量**:
   你可以在Next.js的页面、API路由、`getServerSideProps`或`getStaticProps`等服务器端代码中直接使用`process.env`来访问环境变量。

5. **公开环境变量到浏览器**:
   如果需要在浏览器中使用环境变量，你需要在环境变量名前加上`NEXT_PUBLIC_`前缀：

   ```plaintext
   NEXT_PUBLIC_ANALYTICS_ID=xyz123
   ```

   这样，你可以在客户端JavaScript中安全地使用这些变量：

   ```javascript
   console.log(process.env.NEXT_PUBLIC_ANALYTICS_ID); // 客户端也可访问
   ```

**示例**:

假设你有一个API的URL，在开发环境和生产环境中是不同的。你可以如下设置环境变量：

- 在`.env.development`文件中：

  ```plaintext
  API_URL=https://dev.api.example.com
  ```

- 在`.env.production`文件中：

  ```plaintext
  API_URL=https://api.example.com
  ```

当你在开发环境下运行`next dev`时，`process.env.API_URL`将会是`https://dev.api.example.com`。而当你在生产环境下运行`next start`时，环境变量将会是`https://api.example.com`。

通过这种方式，你可以根据当前的运行环境加载不同的环境变量，而不需要在代码中做任何改变，这有助于项目配置的管理和代码的可维护性。

Next 9.4 内置了对 .env 文件的支持：[https://nextjs.org/docs/basic-features/environment-variables](https://nextjs.org/docs/basic-features/environment-variables)

但是，如果您想要有多个 .env 文件，例如：

*   .env.development
*   .env.staging
*   .env.预演
*   .env.生产

使用内置环境变量支持是不可能的。目前官方只支持3种环境，分别是：“开发”、“测试”、“生产”。与`next dev`您使用“开发”环境，`next build && next start`使用“生产”环境。

如果您需要构建生产环境，但使用“.env.staging”为例，那么您需要添加[env-cmd](https://www.npmjs.com/package/env-cmd)包，并将此行添加到 package.json 中：

    "build:staging": "env-cmd -f .env.staging yarn build && yarn start"
    

接下来将使用“.env.staging”变量进行生产构建。

大多数这些答案的问题是它们违背了“构建一次，到处运行”的原则，实际上我们大多数人都使用这种技术构建并通过 Docker 容器运行。不可能有多个像这样的构建命令，这将是不好的做法。

最好让您的环境在运行时可用。我们创建了一个允许下一步静态优化的包，并且仍然具有运行时环境变量`window.__ENV`

[https://github.com/andrewmclagan/react-env](https://github.com/andrewmclagan/react-env)

这是通过在运行时从白名单环境变量生成环境配置对象来实现的：

    {
      ...
      "scripts": {
        "dev": "react-env -- next dev", // where .env.${APP_ENV}
        "start": "react-env --env APP_ENV -- next start" // where .env.${APP_ENV}
      }
      ...
    }

可以通过以下两种方式在 nextjs 中拥有不同的 .env 文件：

**1.使用env-cmd包**

在脚本中提供环境文件的路径，例如：

```
"scripts": {
    "start": "env-cmd path/to/prod/env/file next start",
    "start:dev": "env-cmd path/to/prod/env/file next dev",   
    "build:dev": "env-cmd path/to/dev/env/file next build",
    "build:test": "env-cmd path/to/test/env/file next build",
    "build:stage": "env-cmd path/to/stage/env/file next build",
    "build": "env-cmd path/to/stage/prod/file next build",      
},
```

**2.使用dotenv包**

在 next.config.js 文件中添加以下内容：

```
require("dotenv").config({ path: `${process.env.ENVIRONMENT}` });

module.exports = {
      // your configs
}
```

并在您的脚本中提供环境变量，例如：

```
"scripts": {
    "start": "ENVIRONMENT=path/to/prod/env/file next start",
    "start:dev": "ENVIRONMENT=path/to/dev/env/file next dev",
    "build:dev": "ENVIRONMENT=path/to/dev/env/file next build",
    "build:test": "ENVIRONMENT=path/to/test/env/file next build",
    "build:stage": "ENVIRONMENT=path/to/stage/env/file next build",
    "build": "ENVIRONMENT=path/to/stage/prod/file next build",      
},
```

**注意**：不要将您的 .env\* 文件放在根文件夹中，否则 NEXT 将从您的 .evn\* 文件中自动选择，并且它仅支持生产和开发阶段。所以它会忽略其他 .env.my-stage 文件。

如今，您不需要安装任何额外的东西来实现多环境配置！请参阅具有配置管理功能的 GitHub 存储库[NextJS 模板](https://github.com/piouson/nextjs-tailwindcss-template)

[Next.js v9.4 及更高版本有一种更直观、更符合人体工程学的方式来添加环境变量](https://nextjs.org/docs/api-reference/next.config.js/environment-variables)：

    {
      "name": "package.json",
      "scripts": {
        "dev": "next dev",
        "build": "next build && next export",
        "build-dev": "TARGET_ENV=development next build && next export",
        "build-staging": "TARGET_ENV=staging next build && next export",
        "test": "jest --watch"
      }
    }
    

    {
      "name": "env.json",
      "development": {
        "APP_ENV": "development"
      },
      "production": {
        "APP_ENV": "production"
      },
      "staging": {
        "APP_ENV": "staging"
      },
      "test": {
        "APP_ENV": "test"
      }
    }
    

    // next.config.js v9.4+
    const envConfig = require('./env.json')
    const environment = process.env.TARGET_ENV || process.env.NODE_ENV
    
    const nextConfig = {
      env: envConfig[environment], // getEnvConfig()
    }
    module.exports = nextConfig
    
    function getEnvConfig() { // for multi-file config
      try {
        return require(`./env-${environment}.json`)
      } catch (err) {
        return require('./env.json')
      }
    }
    

    npm run dev # process.env.APP_ENV=development
    npm run build # process.env.APP_ENV=production
    npm run build-dev # process.env.APP_ENV=development
    npm run build-staging # process.env.APP_ENV=staging
    npm run test # process.env.APP_ENV=test

对于任何有兴趣使用`.yml`文件来轻松管理环境变量的人，我是这样做的。

**`yenv`**在 中安装一个插件`devDependencies`。

**在next.config.js**中添加以下配置：

    const path = require("path");
    const yenv = require("yenv");
    const { PHASE_DEVELOPMENT_SERVER } = require("next/constants");
    
    module.exports = (phase) => {
      const isDev = phase === PHASE_DEVELOPMENT_SERVER;
      const NEXT_ENV = isDev ? "development" : process.env.APP_ENV;
      const rawEnv = yenv(path.resolve(".env.yml"), { raw: true, env: NEXT_ENV });
      
      return {
        ...some other config,
        env: getEnvVars(rawEnv, isDev).raw,
        compress: true,
      };
    };
    
    function getEnvVars(rawEnv, dev) {
      const NEXT_PUBLIC = /^NEXT_PUBLIC_/i;
      const raw = Object.keys(rawEnv)
        .filter((key) => NEXT_PUBLIC.test(key))
        .reduce((env, key) => {
          env[key] = rawEnv[key];
          return env;
        }, {});
      // Stringify all values so we can feed into Webpack DefinePlugin
      const stringified = {
        "process.env": Object.keys(raw).reduce((env, key) => {
          env[key] = JSON.stringify(raw[key]);
          return env;
        }, {}),
      };
      return { raw, stringified };
    }
    

现在只需根据**`package.json`**脚本中的环境添加不同的构建命令即可。

    "scripts": {
        "dev": "node server.js",
        "build:production": "APP_ENV=production next build",
        "build:staging": "APP_ENV=staging next build",
        "start": "NODE_ENV=production node server.js"
      },
    

现在您可以通过单个文件使用环境变量，**`.env.yml`**如下所示：

    base:
      NEXT_PUBLIC_SECRET_KEY : ""
      NEXT_PUBLIC_ANOTHER_SECRET: ""
    
    development:
      ~compose: base
      NEXT_PUBLIC_SECRET_KEY: "bnbnfjf"
    
    staging:
      ~compose: base
      NEXT_PUBLIC_SECRET_KEY: "absadsad"
    
    production:
      ~compose: base
      NEXT_PUBLIC_SECRET_KEY: "lasjdasodsdsad"
    
    

现在您可以调用`npm run build:production`加载生产环境变量和`npm run build:staging`暂存环境变量。

这提供了为您的用例提供任意数量的环境的好处。您只需要添加一个构建命令，并更新环境变量`.env.yml`就可以了。

Next.js相关问题