在React中使用TailwindCSS动态设置背景图像通常涉及到几个步骤。但是，TailwindCSS默认情况下并不直接支持将动态URL用作背景图像，因为它使用PurgeCSS来删除未使用的样式，并且希望在构建时能知道所有可能的类名。要解决这个问题，我们可以使用内联样式或通过修改Tailwind配置来生成必要的背景图像类。下面我将介绍两种方法。

### 方法一：使用内联样式

这是设置动态背景图像的最简单方法，因为它不需要修改TailwindCSS的配置。你可以直接在React组件中使用内联样式来设置背景图像：

```jsx
function MyComponent({ imageUrl }) {
  // 使用内联样式直接设置背景图像
  const style = {
    backgroundImage: `url(${imageUrl})`,
    // 其它你想要添加的TailwindCSS样式
  };

  return <div style={style} className="bg-no-repeat bg-center bg-cover ...">...</div>;
}
```

### 方法二：通过TailwindCSS配置

如果你想使用Tailwind的工具类而不是内联样式，那么你需要在你的`tailwind.config.js`文件中动态地生成背景图像类：

```js
// tailwind.config.js
module.exports = {
  // 其它配置...
  theme: {
    extend: {
      backgroundImage: theme => ({
        'dynamic-pattern': "url('/path/to/image.jpg')", // 用实际的图像路径替换这里
        // 你可以根据需要添加更多背景图像
      }),
    },
  },
  // 其它配置...
}
```

然后在你的React组件中使用这个自定义的背景图像类：

```jsx
function MyComponent() {
  // 假设你已经在tailwind.config.js中添加了名为'dynamic-pattern'的背景图像
  return <div className="bg-dynamic-pattern bg-no-repeat bg-center bg-cover ...">...</div>;
}
```

要使这个方法更加动态，你可以编写一个小的函数，它根据图像URL生成一个唯一的类名，并在构建过程中将此类名和URL添加到配置文件中。然而，这种方法可能会导致配置文件的大小显著增加，并且需要一些自定义逻辑来处理图像URL的插入和类名的生成。

### 注意

两种方法都有其优缺点。使用内联样式是最直接的方法，但它不会利用到Tailwind的PurgeCSS能力，可能会导致样式文件体积增加。通过TailwindCSS配置可能会更符合Tailwind的工作流程，但它可能需要额外的设置，并且在构建时需要知道所有可能的背景图像URL，这可能在某些动态场景下不实际。

选择哪种方法取决于你的具体需求和项目设置。如果背景图像是用户动态生成的内容，方法一可能更合适。如果背景图像可以预先知道，或者是有限的选择集，方法二可能是一个更好的选择。

I think I have found a solution other than simply using a style attribute.

    <div
      style={{'--image-url': `url(${fetchedUrl})`}} 
      className='bg-[image:var(--image-url)]'>
        
    </div>
    

This works perfectly fine.

Although it looks a bit tedious, it can be used to enable the background image on hover, focus, etc. In which the style attribute is incapable of.

    className='hover:bg-[image:var(--image-url)] focus:bg-[image:var(--image-url)] ...'
    

This application of custom properties can be used for implementing dynamic values with tailwind like colors fetched from an API.

    <div
      style={{'--color': fetchedColor}} 
      className='text-[color:var(--color)]'>
        
    </div>

I think the best solution is to do what you suggested and use a style attribute. Tailwind CSS doesn't really deal with dynamic data, but rather with class names to add predefined styles to your element. The best you could without using the style attribute is to conditionally add/remove classNames from an element, but that would require you to know the image URL ahead of time, which defeats the purpose of getting it from an API.

I would do:

    style={{backgroundImage: `url(${fetchedImgSrc})`}}
    

Edit: It looks like you can actually use Tailwind to do something similar to the code above as per [https://tailwindcss.com/docs/background-image](https://tailwindcss.com/docs/background-image). The code looks like:

    <div class="bg-[url('/img/hero-pattern.svg')]">
      
    </div>

you can just use backgroundImage in Style

    const bag2 = "https://via.placeholder.com/500"
    
    <div 
        className = "someting"
        style={{backgroundImage: `url(${bag2})`}}
    
    </div>

Even with the latest implementation of the arbitrary-values - it seems like it's not working for Dynamic URLs. In my case image was coming from an API. If it is the case, stick to style attribute.

In the solution below - bgImage is a prop.

    <div className={`justify-center  bg-no-repeat bg-cover bg-center rounded-lg`} 
    style={{ backgroundImage: `url(${bgImage})`}} >
    
    </div>

TailwindCSS 如何在 Reactjs 中使用动态 url 设置 background image 配置？

在Tailwind CSS中，您可以通过使用预定义的宽度实用类或创建自定义宽度实用类来设置一个元素的宽度为600像素。

1. **使用预定义的宽度实用类（如果存在）：**
   Tailwind CSS 为常用的宽度设置提供了一套预定义的宽度类。但是，在默认配置中，并没有直接对应于600px的宽度类。您可以查看文档或配置文件中的 `theme.width` 部分来确定是否存在适合的预定义宽度。

2. **创建自定义宽度实用类：**
   如果没有预定义宽度匹配600px，您可以在Tailwind的配置文件（`tailwind.config.js`）中扩展默认的宽度设置来添加一个自定义宽度。

```javascript
// tailwind.config.js
module.exports = {
  theme: {
    extend: {
      width: {
        '600': '600px',
      },
    },
  },
  plugins: [],
}
```

这样配置之后，你就可以在HTML中使用 `w-600` 类来将一个元素的宽度设置为600像素了。

```html
<div class="w-600">...</div>
```

当你运行Tailwind CLI工具或者通过构建过程整合Tailwind CSS时，它会生成相应的CSS规则。

请注意，使用自定义值将使您的CSS文件的大小略有增加，因为它会添加额外的类定义。这样做是完全可以接受的，尤其是在项目中确实需要特定像素值的宽度时。

如果您将 Tailwind 安装配置为以即时模式运行，并且运行的是 tailwind 2.1+，则可以使用其任意值支持。[https://tailwindcss.com/docs/just-in-time-mode](https://tailwindcss.com/docs/just-in-time-mode)

例如，我需要 600px 的宽度，我是这样指定的：

`w-[600px]`

您能检查一下下面的代码吗？希望它对你有用。

#1 您需要在 tailwind.config.js 中添加以下代码

    module.exports = {
      theme: {
         extend: {
           width: {
            '600': '600px',
           }
        }
      }
    }
    

#2 之后您可以`w-600`在 HTML 文件中使用，如下所示。

    <div class="w-600">...</div>

您只是缺少括号 \[ \]。尝试这个：

    w-[600px]

看一下大多数 Tailwind 类都有的“任意值”部分。在那里您可以看到如何设置您想要的任何值。

任意值[https://tailwindcss.com/docs/width# Arbitration-values](https://tailwindcss.com/docs/width#arbitrary-values)

> 如果您需要使用一次性宽度值，而该值在主题中包含没有意义，请使用方括号使用任意值动态生成属性。

    <div class="w-[600px]">
      
    </div>

How can I specify exactly 600px width in tailwind CSS

Python 中的三元条件运算可以使用一种简洁的语法结构来实现一个简单的 `if-else` 条件表达式。具体的格式如下：

```python
value_if_true if condition else value_if_false
```

这里的 `condition` 是一个布尔表达式，根据其真假，整个三元表达式将返回 `value_if_true` 或 `value_if_false`。

例如，我们需要根据一个人的年龄来判断他们是否成年，并返回相应的字符串：

```python
age = 20
result = "成年" if age >= 18 else "未成年"
print(result)  # 输出：成年
```

在这个例子中，条件 `age >= 18` 被评估。由于 `age` 的值是 20，这个条件为真，因此变量 `result` 被赋值为字符串 `"成年"`。

这种三元运算的形式在编写简洁的代码时非常有用，尤其是在赋值操作或者函数返回时需要基于条件来选择不同的值。

Python 如何进行三元条件运算？

在 Go 语言中，将 `int` 值转换为 `string` 可以通过多种方式实现。最常用的方式是使用标准库的 `strconv` 包中的 `Itoa` 函数（这是整数到 ASCII 的简写）以及 `FormatInt` 函数。这里有一些例子说明如何进行这种转换：

### 使用 `strconv.Itoa`：

`strconv.Itoa` 函数接受一个 `int` 类型的参数，并将其转换为 `string` 类型。

```go
package main

import (
    "fmt"
    "strconv"
)

func main() {
    intValue := 123
    stringValue := strconv.Itoa(intValue)
    fmt.Println(stringValue) // 输出: "123"
}
```

### 使用 `strconv.FormatInt`：

`strconv.FormatInt` 函数更加灵活，它接受一个 `int64` 类型的值并且允许你指定数字的进制。如果你需要将 `int` 转换为十进制字符串，可以像这样使用：

```go
package main

import (
    "fmt"
    "strconv"
)

func main() {
    intValue := 123
    stringValue := strconv.FormatInt(int64(intValue), 10) // 第二个参数10表示十进制
    fmt.Println(stringValue) // 输出: "123"
}
```

需要注意的是 `strconv.FormatInt` 需要一个 `int64` 类型的值。如果你的整数是 `int` 类型，你需要先将其转换为 `int64`。

### 使用 `fmt.Sprintf`：

`fmt.Sprintf` 函数可以用于格式化字符串，其中包括 int 到 string 的转换。这个方法适用于各种类型的格式化操作，不仅限于整数的转换。

```go
package main

import (
    "fmt"
)

func main() {
    intValue := 123
    stringValue := fmt.Sprintf("%d", intValue)
    fmt.Println(stringValue) // 输出: "123"
}
```

在这个例子中，`%d` 是一个格式说明符，表示将一个整数格式化为十进制数的字符串。

这些是 Go 语言中将整数转换为字符串的常见方法。你可以根据你的具体需求选择合适的方法。

使用[`strconv`](http://golang.org/pkg/strconv/#Itoa)包的`Itoa`功能。

例如：

    package main
    
    import (
        "strconv"
        "fmt"
    )
    
    func main() {
        t := strconv.Itoa(123)
        fmt.Println(t)
    }
    

您可以简单地通过`+`'ing 或使用包`Join`的函数来连接字符串[`strings`](http://golang.org/pkg/strings/#Join)。

fmt.Sprintf("%v",value);
    

如果您知道值的具体类型，请使用相应的格式化程序，`%d`例如`int`

更多信息[\-fmt](http://golang.org/pkg/fmt/)

Golang 如何将 int 值转换为字符串？

在 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`就可以了。

Nextjs 项目如何同时使用不同的 env 文件配置？

Next.js 是一个基于 React 的框架，专为服务端渲染和生成静态网站优化。它处理 HTTP 请求的方式主要通过两种方式：

1. **API 路由**: Next.js 允许你在 `/pages/api` 目录中创建 API 路由，这些路由可以处理 HTTP 请求，包括 `POST` 请求。API 路由文件是服务器端运行的，你可以在这里编写接收和处理 `POST` 请求的逻辑。

   例如，如果你想创建一个处理用户注册的 `POST` 请求，你可以在 `/pages/api` 目录下创建一个名为 `register.js` 的文件：

   ```javascript
   // pages/api/register.js

   export default function handler(req, res) {
     if (req.method === 'POST') {
       // 获取请求体中的数据
       const { username, password } = req.body;

       // 这里可以添加注册逻辑，例如验证、保存到数据库等
       // ...

       // 返回一个成功的响应
       res.status(200).json({ message: 'User registered successfully!' });
     } else {
       // 如果不是 POST 请求，返回 405 Method Not Allowed
       res.setHeader('Allow', 'POST');
       res.status(405).end(`Method ${req.method} Not Allowed`);
     }
   }
   ```

   当客户端发送 POST 请求到 `/api/register` 时，Next.js 会自动调用这个处理函数。

2. **getServerSideProps 或 getInitialProps**: 这些函数可以在页面加载之前在服务器上运行代码，但它们通常用于服务端渲染页面的数据获取，而不是直接处理 `POST` 请求。然而，你仍然可以通过检查传入的 `context` 或 `req` 对象来查看是否有 POST 请求，并据此执行逻辑，但这并不是它们的主要用途。

处理 `POST` 请求的推荐方法是使用 API 路由。这样可以将业务逻辑分离到专门的 API 端点，使得前端和后端逻辑更加清晰，并可使你的前端页面保持简洁，因为它们不需要处理 HTTP 请求的具体细节。

要让 POST 请求在 Next.js API 路由中工作，您可能需要做 3 件事。

*   将方法限制为`POST`
*   用于`JSON.parse()`解析路由中的 JSON（NextJS v12+ 中不需要）
*   向后端发送请求

[https://nextjs.org/docs/api-routes/api-middlewares](https://nextjs.org/docs/api-routes/api-middlewares)

API路线
-----

Next.js 中的 API 路由默认支持所有类型的请求，包括 GET、POST、DELETE 等。因此，虽然不是必需的，但最好将路由限制为您想要支持的方法。

就您而言，如果您只想支持`POST`特定路由上的请求，则可以使用`req.method`过滤掉非发布请求。

    if (req.method !== 'POST') {
      res.status(405).send({ message: 'Only POST requests allowed' })
      return
    }
    

要解析 JSON，您可以使用`JSON.parse()`. 如果您使用 NextJS v12+，只要您没有设置`bodyParser: false`.

    const body = JSON.parse(req.body)
    

将它们放在一起，您的 API 路由应该如下所示：

    // pages/route-name.js
    
    export default function handler(req, res) {
      if (req.method !== 'POST') {
        res.status(405).send({ message: 'Only POST requests allowed' })
        return
      }
    
    
      // not needed in NextJS v12+
      const body = JSON.parse(req.body)
    
      // the rest of your code
    }
    

发送请求
----

最后，您需要从前端代码向后端发送 POST 请求。您可能已经知道如何执行此操作，但为了完整性而提及这一点。

    fetch('/api/route-name', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(objectWithData),
    })
    

顺便说一句，您无需担心`fetch`Next.js 的跨浏览器兼容性。Next.js[在需要时自动添加一个polyfill](https://nextjs.org/docs/basic-features/supported-browsers-features#polyfills)。

与所有事情一样，这取决于情况。在 Next.js v12 中，`JSON.parse(req.body)`只要您没有在 API 路由的**导出**配置中显式设置，就不需要`bodyParser: false`在 API 路由中设置（请参阅[https://nextjs.org/docs/api-routes/api-middlewares](https://nextjs.org/docs/api-routes/api-middlewares)） 。`req.body`例如，如果`content-type`请求的 是 ，则会自动将 解析为对象`application/json`。在这种情况下，由于内容已预先解析为对象，因此尝试`JSON.parse(req.body)`在 API 中运行可能会引发错误。

在 Nextjs 13.4 中，您可以使用[路由处理程序](https://nextjs.org/docs/app/building-your-application/routing/router-handlers)

    import { NextResponse } from 'next/server'
     
    export async function POST() {
      const res = await fetch('https://data.mongodb-api.com/...', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'API-Key': process.env.DATA_API_KEY,
        },
        body: JSON.stringify({ time: new Date().toISOString() }),
      })
     
      const data = await res.json()
     
      return NextResponse.json(data)
    }
    

_有关路由处理程序的最新和现成模板以及更多内容，请使用_ [**Next.js 13+ Power Snippets | TypeScript/Javascript**](https://marketplace.visualstudio.com/items?itemName=krishnaacharyaa.nextjs-13-power-snippets)

NextJS 如何处理 post 请求？

在Next.js中，`_app.js` 和 `_document.js` 文件是对Next.js应用程序的默认结构和行为进行自定义的两个特殊文件。

### _app.js

`_app.js` 文件用于初始化所有页面。你可以使用这个文件来保持页面布局，或者保持页面的状态（如登录状态）时跨页面保持一致。还可以用来添加全局CSS样式。

当你创建自定义的`_app.js`，你需要导出一个React组件来接收一些特定的props，比如`Component`和`pageProps`。`Component` prop是你的页面内容，而`pageProps`是一个对象，包含了你能用来初始化页面的props。

例如，如果你想要所有页面都包含同一导航栏和页脚，你可以这样做：

```jsx
import React from 'react';
import Navbar from '../components/Navbar';
import Footer from '../components/Footer';

// 这里的Component是当前页面
function MyApp({ Component, pageProps }) {
  return (
    <>
      <Navbar />
      <main>
        <Component {...pageProps} />
      </main>
      <Footer />
    </>
  );
}

export default MyApp;
```

### _document.js

而`_document.js` 文件允许你自定义`<html>`和`<body>`标签以及文档的结构。这个文件只会在服务器端渲染时运行，因此不要在这里添加应用程序逻辑。

`_document.js` 用于更改服务端渲染的文档内容。这通常是需要添加服务端渲染的代码片段（比如自定义字体或者`<meta>`标签），或者当你需要为`<html>`和`<body>`标签添加额外的属性时。

一个自定义的`_document.js`看起来是这样的：

```jsx
import Document, { Html, Head, Main, NextScript } from 'next/document';

class MyDocument extends Document {
  render() {
    return (
      <Html lang="en">
        <Head>
          {/* 这里放置 `<link>` 或 `<meta>` 标签 */}
        </Head>
        <body>
          {/* 这里可以添加额外的元素到body中，但通常你只需要 */}
          <Main /> {/* <-- 这里渲染应用内容 */}
          <NextScript /> {/* <-- 这里渲染Next.js脚本 */}
        </body>
      </Html>
    );
  }
}

export default MyDocument;
```

在`_document.js`中，`<Main />`组件会被替换为你的应用页面内容，而`<NextScript />`是用于Next.js的核心脚本，是必须包含的。

### 总结

- 使用`_app.js`来添加布局组件或全局状态管理（如Redux或Context API）。
- 使用`_document.js`来定制服务端渲染的文档结构和标签，例如添加自定义字体、统计代码或对`<html>`和`<body>`标签的附加属性。

请注意，这两个文件都是可选的，如果你的应用不需要对默认行为作出任何修改，你完全可以不添加它们。

Short answer: Yes, You can use both. They serve different purpose and can be used in the same application.

According to [NextJS docs](https://nextjs.org/docs/advanced-features/custom-app):

> Next.js uses the App component to initialize pages.
> 
> To override, create the `./pages/_app.js` file and override the App class

and

> Pages in Next.js skip the definition of the surrounding document's markup. For example, you never include `<html>`, `<body>`, etc. To override that default behavior, you must create a file at `./pages/_document.js`, where you can extend the Document class.

**Note**: `_document.js` is only rendered on the server side and not on the client side. so event handlers like `onClick` is not going to work.

Nextjs 项目中如何使用 _app.js 和 _document.js ？

在Next.js中，当你希望在路由匹配时改变链接的样式，可以使用 Next.js 提供的 `Link` 组件与 `useRouter` 钩子来实现。下面是一个具体的步骤和代码示例：

1. **导入必要的模块** - 从 `next/link` 导入 `Link` 组件，从 `next/router` 导入 `useRouter` 钩子。
2. **使用 `useRouter`** - 在你的组件内部，使用 `useRouter` 钩子得到当前的路由对象。
3. **比对路由** - 使用路由对象的 `pathname` 属性来判断当前路由是否与链接的目标路由匹配。
4. **设置样式** - 根据路由是否匹配，动态地应用不同的样式类或样式对象到你的链接元素上。

下面是一个简化的代码示例，展示了如何实现这一过程：

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

export default function NavLink({ href, children }) {
  // 使用 useRouter 钩子获取当前路由信息
  const router = useRouter();

  // 检查此链接是否为当前路由，如果是，则设置一个特殊的样式类
  const isActive = router.pathname === href;

  // 根据是否激活来决定样式
  const linkStyle = {
    fontWeight: isActive ? 'bold' : 'normal',
    color: isActive ? 'green' : 'blue',
  };

  return (
    <Link href={href}>
      <a style={linkStyle}>{children}</a>
    </Link>
  );
}
```

这个 `NavLink` 组件可以这样使用：

```jsx
function NavigationBar() {
  return (
    <nav>
      <NavLink href="/">Home</NavLink>
      <NavLink href="/about">About</NavLink>
      <NavLink href="/contact">Contact</NavLink>
    </nav>
  );
}
```

在这个例子中，当用户导航到与 `NavLink` `href` 属性相匹配的路由时，链接的样式将变成粗体和绿色。如果不匹配，链接的样式将是普通字体和蓝色。这样可以很直观地向用户展示他们当前所处的页面。

这只是一个简单的样式设置方法。你也可以根据需要将样式类与元素类一起使用，进一步提升样式的复杂度和灵活性。

A simple solution based on the `useRouter` hook:

    import Link from "next/link";
    import { useRouter } from "next/router";
    
    
    export const MyNav = () => {
    
      const router = useRouter();
    
      return (
        <ul>
          <li className={router.pathname == "/" ? "active" : ""}>
            <Link href="/">home</Link>
          </li>
          <li className={router.pathname == "/about" ? "active" : ""}>
            <Link href="/about">about</Link>
          </li>
        </ul>
      );
    };
    
    

You could also use `router.asPath` instead of `router.pathname` if you want to include the url query parameters. This can be useful if you want to handle anchor tags such as `/#about`.

First, you need to have a component called Link, with temporary attribute activeClassName

    import { useRouter } from 'next/router'
    import PropTypes from 'prop-types'
    import Link from 'next/link'
    import React, { Children } from 'react'
    
    const ActiveLink = ({ children, activeClassName, ...props }) => {
      const { asPath } = useRouter()
      const child = Children.only(children)
      const childClassName = child.props.className || ''
    
      // pages/index.js will be matched via props.href
      // pages/about.js will be matched via props.href
      // pages/[slug].js will be matched via props.as
      const className =
        asPath === props.href || asPath === props.as
          ? `${childClassName} ${activeClassName}`.trim()
          : childClassName
    
      return (
        <Link {...props}>
          {React.cloneElement(child, {
            className: className || null,
          })}
        </Link>
      )
    }
    
    ActiveLink.propTypes = {
      activeClassName: PropTypes.string.isRequired,
    }
    
    export default ActiveLink
    

Then have a navigation bar with created component Link and css selector `:active` to differentiate between active and inactive link.

    import ActiveLink from './ActiveLink'
    
    const Nav = () => (
      <nav>
        <style jsx>{`
          .nav-link {
            text-decoration: none;
          }
          .active:after {
            content: ' (current page)';
          }
        `}</style>
        <ul className="nav">
          <li>
            <ActiveLink activeClassName="active" href="/">
              <a className="nav-link">Home</a>
            </ActiveLink>
          </li>
          <li>
            <ActiveLink activeClassName="active" href="/about">
              <a className="nav-link">About</a>
            </ActiveLink>
          </li>
          <li>
            <ActiveLink activeClassName="active" href="/[slug]" as="/dynamic-route">
              <a className="nav-link">Dynamic Route</a>
            </ActiveLink>
          </li>
        </ul>
      </nav>
    )
    
    export default Nav
    

After that, you can implement the navigation bar to your page:

    import Nav from '../components/Nav'
    
    export default () => (
      <div>
        <Nav />
        <p>Hello, I'm the home page</p>
      </div>
    )
    

The key of how does this work is located inside component Link, we compare the value of `router.pathname` with attribute `href` from the Link, if the value match the other then put specific className to make the link looks activated.

Reference: [here](https://github.com/zeit/next.js/tree/canary/examples/active-class-name)

If you're using Next 13 you can now do the following using the `usePathname()` [hook](https://beta.nextjs.org/docs/upgrade-guide#migrating-routing-hooks):

    
    import { usePathname} from 'next/navigation';
    
    export default function Example() {
        
        const pathname = usePathname();
    
        return(
            <div>
                <a
                    href="/welcome"
                    className={pathname == "/welcome" ? 
                    "active" : 
                    ""
                    }
                >
            </div>
        )
    }

If you want to use an anchor Link try this version of @Rotareti 's code:

    import Link from "next/link";
    import { useRouter } from "next/router";
    
    
    export const MyNav = () => {
    
      const router = useRouter();
    
      return (
        <ul>
          <li className={router.asPath == "/#about" ? "active" : ""}>
            <Link href="#about">about</Link>
          </li>
        </ul>
      );
    };

Another minimal version which supports `as` prop:

    import Link from "next/link";
    import {withRouter} from "next/router";
    import {Children} from "react";
    import React from "react";
    
    export default withRouter(({router, children, as, href, ...rest}) => (
       <Link {...rest} href={href} as={as}>
          {React.cloneElement(Children.only(children), {
             className: (router.asPath === href || router.asPath === as) ? `active` : null
          })}
       </Link>
    ));

NextJS 如何当路由匹配时设置链接样式？

当我们在使用 `Axios` 进行API调用时，可能需要向服务器发送数组类型的参数。正确处理数组类型的参数依赖于服务器端如何解析参数。一般来说，有几种方式可以提交数组类型的参数：

### 1. 通过查询字符串传递数组
你可以将数组转换为查询字符串的形式，例如：
```
GET /endpoint?param[]=value1&param[]=value2
```
在 Axios 中，你可以简单地将数组直接作为参数传递，Axios 会自动将其序列化为查询字符串：
```javascript
axios.get('/endpoint', {
    params: {
        param: ['value1', 'value2']
    }
});
```
Axios 会将请求转换为 `/endpoint?param=value1&param=value2`。

### 2. 使用 `paramsSerializer` 自定义序列化
如果你需要自定义数组转为查询字符串的方式，可以使用 `paramsSerializer` 函数。例如，你可能想要使用逗号分隔数组：
```javascript
import qs from 'qs'; // 使用 qs 库进行查询字符串的序列化

axios.get('/endpoint', {
    params: {
        param: ['value1', 'value2']
    },
    paramsSerializer: params => {
        return qs.stringify(params, { arrayFormat: 'comma' })
    }
});
```
这会将请求转换为 `/endpoint?param=value1,value2`。

### 3. 在 POST 请求中发送数组作为 JSON
如果你是在发送 `POST` 请求，并且需要在请求体中发送数组，你可以将数组作为 JSON 对象发送：
```javascript
axios.post('/endpoint', {
    arrayParam: ['value1', 'value2']
});
```
这样，数组会作为 JSON 的一部分发送到服务器。

### 例子
假设有一个API端点 `/search` 需要接收一个数组类型的参数 `tags` 来过滤搜索结果。按照查询字符串的方式，我们可以这样调用 API：

```javascript
axios.get('/search', {
    params: {
        tags: ['frontend', 'javascript', 'react']
    }
});
```
如果服务器期望的是逗号分隔的字符串而不是多个相同的键，我们可以用 `paramsSerializer` 自定义序列化方法：
```javascript
import qs from 'qs';

axios.get('/search', {
    params: {
        tags: ['frontend', 'javascript', 'react']
    },
    paramsSerializer: params => {
        return qs.stringify(params, { arrayFormat: 'comma' });
    }
});
```

上述方法都是处理发送数组类型参数时的常见方式，具体使用哪种方法取决于后端API的预期格式，所以在实际应用中，应当根据服务器端的要求来选择合适的数组序列化方式。

You can use `paramsSerializer` and serialize parameters with [https://www.npmjs.com/package/qs](https://www.npmjs.com/package/qs)

    axios.get('/myController/myAction', {
      params: {
        storeIds: [1,2,3]
      },
      paramsSerializer: params => {
        return qs.stringify(params)
      }
    })

Without having to add more libraries and using ES6 you could write:

    axios.get(`/myController/myAction?${[1,2,3].map((n, index) => `storeIds[${index}]=${n}`).join('&')}`);

Thanks so much the answer from **Nicu Criste**, for my case, the API requires params like this:

    params: {
      f: {
        key: 'abc',
        categories: ['a','b','c']
       },
      per_page: 10
    }
    

Method is GET and this API requires the format is: `API?f[key]=abc&f[categories][]=a&f[categories][]=b...` So I assigned the paramsSerializer of axios like this:

    config.paramsSerializer = p => {
          return qs.stringify(p, {arrayFormat: 'brackets'})
        }
    

*   Install `qs` please go to [this link](https://www.npmjs.com/package/qs)  
    
*   Read more about paramsSerializer in [axios document](https://github.com/axios/axios#request-config)
*   Edit format of params: Read more at [qs stringifying document](https://www.npmjs.com/package/qs#stringifying)

This behaviour has been added to `axios` starting with version `1.0.0`. See `paramsSerializer.indexes` at [https://github.com/axios/axios/tree/v1.0.0#request-config](https://github.com/axios/axios/tree/v1.0.0#request-config)

Here's an example using your sample code:

    axios.get('/myController/myAction', {
      params: { storeIds: [1,2,3] },
      paramsSerializer: {
        indexes: true, // use brackets with indexes
      }
    )
    

The resulting query params will have indexes inside the brackets:

    /myController/myAction?storeIds[0]=1&storeIds[1]=2&storeIds[2]=3
    

Other `paramsSerializer.indexes` values are `null` (no brackets):

    axios.get('/myController/myAction', {
      params: { storeIds: [1,2,3] },
      paramsSerializer: {
        indexes: null, // no brackets at all
      }
    )
    // /myController/myAction?storeIds=1&storeIds=2&storeIds=3
    

And the default `false` (brackets without indexes):

    axios.get('/myController/myAction', {
      params: { storeIds: [1,2,3] },
      paramsSerializer: {
        indexes: false, // brackets but no indexes
      }
    )
    // /myController/myAction?storeIds[]=1&storeIds[]=2&storeIds[]=3

In my case, I use ES6 array function. array element make querystring use reduce function. Object array also works.

    const storeIds = [1,2,3]
    axios.get('some url', {
      params: {
        storeIds: storeIds.reduce((f, s) => `${f},${s}`)
      }
    })

Axios 如何正确处理数组类型的参数？

在 Next.js 中，当您在静态模式下部署应用程序时，添加 favicon 图标是一项简单的任务。您可以通过以下步骤来实现：

1. **准备 Favicon 文件：**首先，您需要准备好一个或多个 favicon 文件，通常是 `.ico`、`.png` 或 `.svg` 格式。`favicon.ico` 是最常见的格式，因为它兼容所有浏览器。但现在很多现代浏览器也支持其他格式，如 PNG 和 SVG。

2. **将 Favicon 文件放置在 public 目录：**在 Next.js 项目的根目录下有一个名为 `public` 的目录。您需要将 favicon 文件放到这个目录下。Next.js 会自动将 `public` 目录下的资源映射到应用程序的根 URL。

3. **更新 `<Head>` 组件：**在您的页面组件或是 `_app.js` 文件中，使用 Next.js 的内置 `<Head>` 组件来添加指向 favicon 的链接标签。通常，这是在 `pages/_app.js` 中全局设置，也可以在特定页面的 `pages/your-page.js` 中设置。

下面是一个如何在 `pages/_app.js` 中添加 favicon 的例子：

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

function MyApp({ Component, pageProps }) {
  return (
    <>
      <Head>
        {/* 添加 favicon */}
        <link rel="shortcut icon" href="/favicon.ico" type="image/x-icon" />
        <link rel="icon" href="/favicon.ico" type="image/x-icon" />
        
        {/* 支持其他尺寸的图标 */}
        <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png" />
        <link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png" />
        <link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png" />
        <link rel="manifest" href="/site.webmanifest" />
        
        {/* ...其他可能需要的元素（例如标题，描述等）... */}
      </Head>
      <Component {...pageProps} />
    </>
  );
}

export default MyApp;
```

在上面的代码示例中，我们添加了几个 `<link>` 标签来定义不同情况下的图标。现代浏览器会根据需要选择合适的图标。

4. **构建和部署：**完成上述步骤后，当您构建并部署您的 Next.js 应用程序时，favicon 会自动被包括在内，并在浏览器的标签页上显示。

请注意，如果您正在开发环境中进行这些更改，您可能需要重启开发服务器才能看到新的 favicon。

1.  Create a `/static` folder in project root. This will be added to the static export folder.
2.  Add favicon file in `/static` folder.
3.  Add `_document.js` to `/pages/` folder according to [documentation (nextjs.org)](https://nextjs.org/docs/advanced-features/custom-document) or [documentation (github.com)](https://github.com/zeit/next.js/#custom-document).
4.  Add `<link rel="shortcut icon" href="/static/favicon.ico" />` to head.
5.  `npm run build && npm run export`

P.S. Thanks to the [previous answer](https://i.stack.imgur.com/oEKzt.png) that was deleted. It works!

* * *

Edit: Another way is to do this is to _import Head_ into your root layout and add the link there. Anything added to _Head_ gets inserted into the document head tag.

    import Head from 'next/head';
    
    const Page = (props) => (
      <div>
        <Head>
          <link rel="shortcut icon" href="/static/favicon.ico" />
        </Head>
        // Other layout/components
      </div>
    );
    
    export default Page;
    

**Update :**

The static directory has been deprecated in favor of the public directory. [Doc](https://err.sh/zeit/next.js/static-dir-deprecated)

So, the code would now look like

    import Head from 'next/head';
    
    const Page = (props) => (
      <div>
        <Head>
          <link rel="shortcut icon" href="/favicon.ico" />
        </Head>
        // Other layout/components
      </div>
    );

Simply add your favicon.ico in public folder, Next js will automatically take that favicon for all pages.

No need to add any favicon link to any pages or in tag no need to add link for favicon.

[https://github.com/zeit/next.js/blob/master/errors/static-dir-deprecated.md](https://github.com/zeit/next.js/blob/master/errors/static-dir-deprecated.md)

The accepted answer is nice, but might be worth pointing out that you _don't have_ to modify `_document.js` for adding a favicon (nor for adding any tags to `head`).

I found out for myself that placing favicon in `_app.js` makes more sense. This file is most likely to exist already for setting up a layout for the pages or something like this. And you can add `Head` tag _literally anywhere_ (see [the docs](https://nextjs.org/docs#populating-head))

So I ended up with `_app.js`

    class MyApp extends App {
      render() {
        const { Component, pageProps } = this.props;
    
        return (
          <Layout>
            <Head>
              <link rel="shortcut icon" href="/favicon.ico" />
            </Head>
            <Component {...pageProps} />
          </Layout>
        );
      }
    }

As of June 2020, you don't have to add/edit the `document.js` or `_head.js` files. All you need do to is place the `favicon.ico` file inside the `public` directory and that's it.

**Only adding .ico file is not enough.**

It is not enough as the default.ico file will be used only by desktop browsers. You need to support different devices like tables, smartphones, etc. By adding different sizes the app could be stored on smartphone desktop.

Add link tags to `<Head>` section in `_document.jsx` or `_document.tsx` The question is only about .ico file, but I would recommend to add different dimensions and formats for better support.

    import React from 'react';
    import Document, { Html, Head, Main, NextScript, DocumentContext, DocumentInitialProps } from 'next/document';
    
    class MyDocument extends Document {
      static async getInitialProps(ctx: DocumentContext): Promise<DocumentInitialProps> {
        const initialProps = await Document.getInitialProps(ctx);
        return { ...initialProps };
      }
    
      render(): React.ReactElement {
        return (
          <Html>
            <Head>
              <link rel="apple-touch-icon" sizes="180x180" href="/favicons/apple-touch-icon.png" />
              <link rel="icon" type="image/png" sizes="32x32" href="/favicons/favicon-32x32.png" />
              <link rel="icon" type="image/png" sizes="16x16" href="/favicons/favicon-16x16.png" />
              <link rel="manifest" href="/favicons/site.webmanifest" />
              <link rel="mask-icon" href="/favicons/safari-pinned-tab.svg" color="#5bbad5" />
              <meta name="msapplication-TileColor" content="#ffc40d" />
              <meta name="theme-color" content="#ffffff" />
            </Head>
            <body>
              <Main />
              <NextScript />
            </body>
          </Html>
        );
      }
    }
    
    export default MyDocument;
    

You can generate different icons using [RealFaviconGenerator](https://realfavicongenerator.net/) and upload results to `/public/favicons/` folder. This folder can be referenced by `/favicons/` due to nature of [public directory](https://nextjs.org/docs/basic-features/static-file-serving).

所有问题