在 Swift 中，方法是与类、结构体、枚举等相关联的函数。方法允许我们在类、结构体、枚举等中定义某些行为。方法可以访问和修改实例属性，以及提供对实例的功能性访问。

Swift - 方法


<CanIUse tag="template-literals" />

## 语法

```js
// Basic literal string creation
;`In JavaScript '\n' is a line-feed.` // Multiline strings
`In JavaScript this is
 not legal.`

// String interpolation
var name = 'Bob',
  time = 'today'
;`Hello ${name}, how are you ${time}?`

// Construct an HTTP request prefix is used to interpret the replacements and construction
POST`http://foo.org/bar?a=${a}&b=${b}
     Content-Type: application/json
     X-Credentials: ${credentials}
     { "foo": ${foo},
       "bar": ${bar}}`(myOnReadyStateChangeHandler)
```

模板字符串使用反引号 (` `) 来代替普通字符串中的用双引号和单引号。模板字符串可以包含特定语法（$\{expression}）的占位符。占位符中的表达式和周围的文本会一起传递给一个默认函数，该函数负责将所有的部分连接起来，如果一个模板字符串由表达式开头，则该字符串被称为带标签的模板字符串，该表达式通常是一个函数，它会在模板字符串处理后被调用，在输出最终结果前，你都可以通过该函数来对模板字符串进行操作处理。在模版字符串内使用反引号（`）时，需要在它前面加转义符（\）。

## 原始字符串

在标签函数的第一个参数中，存在一个特殊的属性 raw ，我们可以通过它来访问模板字符串的原始字符串，而不经过特殊字符的替换。

```js
function quux(strings, ...values) {
  strings[0] === 'foo\n'
  strings[1] === 'bar'
  strings.raw[0] === 'foo\\n'
  strings.raw[1] === 'bar'
  values[0] === 42
}
quux`foo\n${42}bar`

String.raw`foo\n${42}bar` === 'foo\\n42bar'
```

## 对比

```js
// es5
var classes = 'header'
classes += isLargeScreen()
  ? ''
  : item.isCollapsed
  ? ' icon-expander'
  : ' icon-collapser'

// es2015
const classes = `header ${
  isLargeScreen() ? '' : item.isCollapsed ? 'icon-expander' : 'icon-collapser'
}`
```


传统的JavaScript语言中，输出模板经常使用的是字符串拼接的形式，这样写相当繁琐，在ES6中引入了模板字符串的概念来解决以上问题。

模板字符串


Swift 有三种条件判断：

- if else
- switch
- ternary `三元运算`

### if else

> if 语句 后可以有可选的 else 语句, else 语句在布尔表达式为 false 时执行。

![XxhyS1](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/XxhyS1.png)

```swift
let level = 9001
if level > 9000 {
  print("It's over 9000! You can proceed with your quest.")
} else {
  print("Bummer, you definitely need to go for a training arc")
}
```

### switch

> switch 语句允许测试一个变量等于多个值时的情况。

```swift
let level = 10000

switch level {
   case 7000 :
     print("Muda Muda Muda Muda Muda Muda")
   case 8000 :
     print("You are not strong enough")
   case 9000 :
     print("You are strong enough! You can proceed with your quest")
   case 10000:
     print("It's over 9000! You can proceed with your quest.")
   default :
     print("Please try again")
}
```

### ternary

> switch 语句允许测试一个变量等于多个值时的情况。 Swift 语言中  只要匹配到 case 语句，则整个 switch 语句执行完成。

```swift
let level = 9000
print( level > 9000 ? "It's over 9000! You can proceed with your quest." :  print("Bummer, you definitely need to go for a training arc")
```


Operators and conditions - 操作符、条件判断


实际上，大多数项目都将有一个或多个容器，这些容器需要相互通信。在这种情况下，Docker 提供了一些选项，以便容器可以相互通信。

假如现在有一个简单的应用程序，它由两个容器组成：一个 web 容器和一个数据库容器。web 容器需要与数据库容器通信，以便它可以从数据库中检索数据。

## 解决方案

- 使用暴露的端口访问数据库容器
- 使用 ip 和默认端口访问数据库容器

第一种方法设计从数据库容器中暴露端口，web 容器通过该端口连接，假设数据库容器的端口为 3306，那么 web 容器就可以通过 `http://localhost:3306` 访问数据库容器。

第二种方法使用 container inspect 命令来获取数据库容器的 IP 地址，然后使用该 IP 地址和默认端口访问数据库容器，假设数据库容器的 id 为 postgres，通过以下命令获得 IP 地址：

```bash
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' postgres
# 172.17.0.2
```

现在可以通过http://172.17.0.2:5432访问数据库容器。

两种方法都有缺点，因为它们都依赖于容器的 IP 地址，如果容器的 IP 地址发生变化，那么就需要更新 web 容器的配置。

正确的方式是放在一个网络中，这样就可以通过容器名称访问数据库容器，而不是通过 IP 地址。


Docker - 基本的网络操作


> 引用类型是把数据和功能组织在一起的结构

## 原始包装类型

### Boolean

Boolean 有两个值 true/false。

| 数据类型  | 转换为 true 的值 | 转换为 false 的值 |
| --------- | ---------------- | ----------------- |
| Boolean   | true             | false             |
| String    | 任意飞空字符串   | 空字符串          |
| Number    | 任何非零值       | 0 和 NaN          |
| Object    | 任何对象         | null              |
| Undefined |                  | undefined         |

### Number

```js
const age = 36
typeof age //number

const age = Number(36)
typeof age //number

//使用new声明的Number返回object类型，可使用valueOf获取原始值
const age = new Number(36)
typeof age //object
```

#### 属性

1. EPSILON - 两个数字之间的最小间隔
2. MAX_SAFE_INTEGER - 可表示的最大整数值
3. MAX_VALUE - 可表示的最大正值
4. MIN_SAFE_INTEGER - 可表示的最小整数值
5. MIN_VALUE - 可表示的最小正值
6. NAN - not a number
7. NEGATIVE_INFINITY - 正向无穷大
8. POSITIVE_INFINITY - 负向无穷大

```js
Number.EPSILON //2.220446049250313e-16
Number.MAX_SAFE_INTEGER //9007199254740991
Number.MAX_VALUE //1.7976931348623157e+308
Number.MIN_SAFE_INTEGER //-9007199254740991
Number.MIN_VALUE //5e-324
Number.NAN //NaN
Number.NEGATIVE_INFINITY //-Infinity
Number.POSITIVE_INFINITY //Infinity
```

#### 方法

- Number.isNaN(value) //当 value 为非 number 时返回 true
- Number.isFinite(value) //当 value 是有穷值返回 true
- Number.isInteger(value) //当 value 是整型值返回 true
- Number.isSafeInteger(value) //当 value 是安全整型值返回 true
- Number.parseFloat(value) //将值转换成浮点类型并返回
- Number.parseInt(value) //将值转换成整形并返回

#### 实例方法

当使用 new 关键词声明一个数值，将会返回 object，并且提供如下方法。

```js
const age = new Number(36)
typeof age //object
```

- .toExponential() //将值转换成指数计数法
- .toFixed() //返回小数点后 N 位
- .toLocaleString() //将值转换成字符类型
- .toPrecision() //返回指定的精度
- .toString() //将值转换成字符类型
- .valueOf() //返回原始值

### String

- String.fromCharCode() //通过一串 Unicode 创建字符串。
- String.fromCodePoint() //通过一串 码点 创建字符串。
- String.raw() //通过模板字符串创建字符串。

#### 实例方法

- charAt(i)
- charCodeAt(i)
- codePointAt(i)
- concat(str)
- endsWith(str)
- includes(str)
- indexOf(str)
- lastIndexOf(str)
- localeCompare()
- match(regex)
- normalize()
- padEnd()
- padStart()
- repeat()
- replace(str1, str2)
- search(str)
- slice(begin, end)
- split(separator)
- startsWith(str)
- substring()
- toLocaleLowerCase()
- toLocaleUpperCase()
- toLowerCase()
- toString()
- toUpperCase()
- trim()
- trimEnd()
- trimStart()
- valueOf()

#### charAt

> 返回指定位置的字符,且返回的字符长度为 1，**_js 没有一种有别于字符串类型的字符数据类型_**

```js
string.charAt(index)

'porhub'.charAt(0) //'p'
'porhub'.charAt(1) //'o'
'porhub'.charAt(2) //'r'
```

#### charCodeAt

> 返回在指定的位置的字符的 Unicode 编码

**字符串中第一个字符的下标是 0。如果 index 是负数，或大于等于字符串的长度，则 charCodeAt() 返回 NaN。**

```js
string.charCodeAt(index)

'porhub'.charCodeAt(0) //112
'porhub'.charCodeAt(1) //111
'porhub'.charCodeAt(2) //114
```

#### codePointAt

> ES2015 引入的，用于处理 2 UTF-16 字符的，比如中文，在 ES2015 之前 charCodeAt 只能处理单个字符，处理双字符必须一个个处理然后拼接。

```js
string.codePointAt(index)

//ES2015之前
'𠮷'.charCodeAt(0).toString(16) //d842
'𠮷'.charCodeAt(1).toString(16) //dfb7
;('\ud842\udfb7') //𠮷

//ES2015
'𠮷'.codePointAt(0) //20bb7
;('\u{20bb7}') //𠮷
```

#### concat

> 类似 Array 的 concat

```js
stringObject.concat(stringX,stringX,...,stringX)

"browser".concat("porhub");
```

通常使用 + 拼接来得更方便，或者使用 ES2015 的``字符扩展。

#### endWith

> 用来判断当前字符串是否是以另外一个给定的子字符串“结尾”的，根据判断结果返回 true 或 false。

```js
str.endsWith(searchString, position)

'JavaScript'.endsWith('Script') //true
'JavaScript'.endsWith('script') //false
'JavaScript'.endsWith('Script', 5) //false
'JavaScript'.endsWith('as', 5) //true
```

#### includes

> 用于判断一个字符串是否包含在另一个字符串中，根据情况返回 true 或 false

```js
str.includes(searchString, position)

'JavaScript'.includes('Script') //true
'JavaScript'.includes('script') //false
'JavaScript'.includes('nice') //true
'JavaScript'.includes('nice', 3) //false
```

#### indexOf

> 用于返回字符串中出现某个字符的初始位置，如果没有找到，返回-1.

```js
str.indexOf(searchString, startPosition)

'JavaScript'.indexOf('a') //1
'JavaScript'.indexOf('a', 2) //3
```

#### lastIndexOf

> 用于返回某个字符最后出现的位置，如果没有，返回-1

```js
str.lastIndexOf(searchString, startPosition)

'JavaScript'.lastIndexOf('a') //3
'JavaScript'.lastIndexOf('a', 1) //1
```

#### padEnd

> 用一个字符串填充当前字符串（如果需要的话则重复填充），返回填充后达到指定长度的字符串。从当前字符串的末尾（右侧）开始填充。

```js
str.padEnd(targetLength, string)

'abc'.padEnd(10) // "abc       "
'abc'.padEnd(10, 'foo') // "abcfoofoof"
'abc'.padEnd(6, '123456') // "abc123"
'abc'.padEnd(1) // "abc"
```

#### padStart

> 用另一个字符串填充当前字符串(重复，如果需要的话)，以便产生的字符串达到给定的长度。填充从当前字符串的开始(左侧)应用的

```js
str.padStart(targetLength, string)

'abc'.padStart(10) // "       abc"
'abc'.padStart(10, 'foo') // "foofoofabc"
'abc'.padStart(6, '123465') // "123abc"
'abc'.padStart(8, '0') // "00000abc"
'abc'.padStart(1) // "abc"
```

#### repeat

> 构造并返回一个包含被连接在一起的指定数量的新字符串。

```js
str.repeat(count)

'abc'.repeat(-1) // RangeError: repeat count must be positive and less than inifinity
'abc'.repeat(0) // ""
'abc'.repeat(1) // "abc"
'abc'.repeat(2) // "abcabc"
'abc'.repeat(3.5) // "abcabcabc" 参数count将会被自动转换成整数.
'abc'.repeat(1 / 0) // RangeError: repeat count must be positive and less than inifinity
```

#### slice

> 截取字符串的一部分，并返回一个新的字符串

```js
str.slice(startPosition, endPosition)

'abc'.slice(0, 1) //a
'abc'.slice(0, -1) //ab
```

#### split

> 将字符串切割成数组

```js
str.split(separator, limit)

'abc'.split() //"[a,b,c]";
'a,b,c'.split(',', 1) //[a]
```

#### startWith

> 判断字符串是否以给定的字符串开始，返回 true/false

```js
str.startsWith(searchString, poistion)

'abc'.startsWith('a') //true
'abc'.startsWith('a', 1) //false
```

#### substring

> 根据开始索引到结束索引截取字符串

```js
str.substring(startPosition, endPosition)

'abc'.substring(0, 1) //a
'abc'.substring(-1) //abc
```

1. 如果 startPosition 等于 indexEnd，substring 返回一个空字符串。
2. 如果省略 indexEnd，substring 提取字符一直到字符串末尾。
3. 如果任一参数小于 0 或为 NaN，则被当作 0。
4. 如果任一参数大于 stringName.length，则被当作 stringName.length。
5. 如果 startPosition 大于 indexEnd，则 substring 的执行效果就像两个参数调换了一样。见下面的例子。

### toLocaleLowerCase/toLocaleUpperCase/toUpperCase/toLowerCase

> 将字符串转换成小写/大写

```js
str.toLocaleLowerCase() /
  str.toLocaleUpperCase() /
  str.toUpperCase() /
  str.toLowerCase()

'ABC'.toLocaleLowerCase() //abc
'abc'.toLocaleUpperCase() //ABC
```

#### toString

> 将\*转换成字符串

```js
var x = new String('Hello world')

alert(x.toString()) // 输出 "Hello world"
```

#### trim/trimStart/trimEnd

> 移除空白字符/起始位置空白字符/结尾位置空白字符

```js
str.trim() / str.trimStart() / str.trimEnd()

'Testing'.trim() //'Testing'
' Testing'.trim() //'Testing'
' Testing '.trim() //'Testing'
'Testing '.trim() //'Testing'
```

#### valueOf

> 返回 str 的原始值，等同于 String.prototype.toString

```js
str.valueOf()

x = new String('Hello world')
alert(x.valueOf()) // Displays "Hello world"
```

#### 扩展学习

```js
1 +
  '5'[(1, 3, 5)] + //"15"
  1 //"1,3,51"
10 + true // 11
15 + {} // "15[object Object]"
8 + null // 8
'queen' + null // "queennull"
12 + undefined // NaN
```

[See examples in jsbin](http://jsbin.com/fiwemir/2/edit?js,console)

## 单例内置对象

### global

在全局作用域中定义的变量和函数都会成为`global`对象的属性。

常见的 global 对象属性和方法：

- 基本类型和引用类型等
- isNaN
- Infinity
- isFinate
- parseInt
- parseFloat
- encodeURI
- encodeURIComponent
- decodeURI
- decodeURIComponent
- eval

也可以通过`console.log(window)`来查看

### Math

除 global 之外，`Math`也是单例内置对象，提供了一组用于执行常见数学运算的方法。例如，可以使用 Math.max()方法来计算一组数值中的最大值，使用 Math.round()方法来对数值进行四舍五入等。

- Math.max(val1, val2, ...)：计算一组数值的最大值。
- Math.min(val1, val2, ...)：计算一组数值的最小值。
- Math.round(val)：对数值进行四舍五入。
- Math.ceil(val)：向上取整。
- Math.floor(val)：向下取整。
- Math.random()：生成一个 0 到 1 之间的随机数。

例如，下面的代码计算了一组数值的最大值、最小值、平均值：

```js
var values = [3, 5, 8, 10, 12]

// 计算最大值
var max = Math.max.apply(null, values)
console.log(max) // 12

// 计算最小值
var min = Math.min.apply(null, values)
console.log(min) // 3

// 计算平均值
var sum = 0
for (var i = 0; i < values.length; i++) {
  sum += values[i]
}
var avg = sum / values.length
console.log(avg) // 7.4
```

上面的代码中，首先使用 Math.max.apply(null, values)计算了一组数值的最大值，其中 apply 方法用于指定 Math.max 方法的作用对象为 null，并将 values 数组作为参数传入该方法。接着，使用类似的方法计算了一组数值的最小值。最后，通过遍历数组计算所有数值的和，然后除以数值的个数，得平均值。

## Date

JavaScript 的 Date 对象用于处理日期和时间。它可以获取当前日期和时间，也可以处理其他日期和时间。

要在 JavaScript 中使用 Date 对象，需要使用 Date 构造函数创建一个日期对象。语法如下：

```js
var date = new Date(
  [year],
  [month],
  [day],
  [hours],
  [minutes],
  [seconds],
  [milliseconds]
)
```

其中，参数 year、month、day、hours、minutes、seconds、milliseconds 表示年份、月份、日、小时、分钟、秒、毫秒，可以省略。如果省略，则表示使用当前日期和时间。

例如，下面的代码创建了一个日期对象，表示当前日期和时间：

```js
var date = new Date()
```

JavaScript 的 Date 对象提供了很多方法，用于处理日期和时间。例如，可以使用 getFullYear 方法来获取年份，使用 getMonth 方法来获取月份，使用 getDate 方法来获取日期等。

例如，下面的代码获取了当前日期对象的年份、月份、日期：

```js
var date = new Date()
var year = date.getFullYear()
var month = date.getMonth()
var day = date.getDate()
```

此外，JavaScript 的 Date 对象还提供了一些静态方法，可以用于创建特定日期和时间的日期对象。例如，可以使用 Date.parse 方法来解析日期字符串

Date 对象提供了许多方法来处理日期和时间信息，下面列出一些常用的方法：

- getFullYear()：获取当前日期所在年份。
- getMonth()：获取当前日期所在月份（0-11）。
- getDate()：获取当前日期所在月份的日期（1-31）。
- getDay()：获取当前日期所在周的星期（0-6，0 表示星期天，1 表示星期一，以此类推）。
- getHours()：获取当前时间的小时数（0-23）。
- getMinutes()：获取当前时间

![6hlbYR](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/6hlbYR.png)

## Regexp

正则表达式（Regular Expression，简称 regexp 或 regex）是用来描述、匹配文本模式的一种工具。在 JavaScript 中，可以使用正则表达式来搜索、替换、提取字符串中的指定文本，从而实现对文本的高级操作。

要在 JavaScript 中使用正则表达式，需要使用 RegExp 构造函数来创建一个正则表达式对象。语法如下：

```js
var regexp = new RegExp(pattern[, flags]);
```

其中，pattern 是正则表达式的模式字符串，flags 是可选的标志字符串，用来指定正则表达式的匹配方式。

例如，下面的代码创建了一个正则表达式对象，该对象可以匹配字符串"hello"：

```js
var regexp = new RegExp('hello')
```

JavaScript 的正则表达式有两种匹配方式：全局匹配和非全局匹配。

在全局匹配模式下，正则表达式会尝试匹配整个字符串，并返回所有匹配结果。要在正则表达式中使用全局匹配，需要在模式字符串中加入一个"g"标志，如下所示：

```js
var regexp = new RegExp('hello', 'g')
```

在非全局匹配模式下，正则表达式会尝试匹配字符串的一部分


Javascript - 基本引用类型


Next.js 已经成为 React 应用程序最重要的框架之一。它可以帮助开发人员在没有模板的情况下构建更好的服务器端渲染 React 应用程序。

Next.js 之所以能成为目前最好的 React 框架之一，与其很多特性离不开，比如打包构建、路由预取、TypeScript、SEO 等。

对于那些想要拥有一个简单但功能强大的博客的人来说，使用 Next.js 创建博客是当今的最佳选择。

SEO（搜索引擎优化）是改进应用程序在搜索引擎排名的过程。对于任何想要在搜索引擎上获得更好排名并带来更多流量的博客来说，这都是非常重要的。

我们将在本文中使用 Next.js 来构建博客。我们将介绍 SSG（静态站点生成）的工作原理，并完成 SEO 友好的博客。

## 入门

使用官方推荐的`Create Next App`创建项目

```bash
npx create-next-app@latest --typescript
# or
yarn create next-app --typescript
# or
pnpm create next-app --typescript
```

为什么要使用`Create Next App`

- 交互式体验：不带任何参数运行`npx create-next-app@latest`，将会开启交互模式，引导创建项目
- 零依赖：`Create Next App`没有依赖，毫秒级创建项目
- 离线支持：`Create Next App`侦测网络状态，无网状态将使用本地依赖缓存
- 支持模板：通过加入`--example`参数，可以拉取官方仓库任何模板
- 集成测试：集成测试功能

创建完成后项目目录构造如下：

```bash
.
├── README.md
├── next-env.d.ts
├── next.config.js
├── node_modules
├── package.json
├── pages
├── pnpm-lock.yaml
├── public
├── styles
└── tsconfig.json
```

## 安装依赖

```bash
pnpm install globby gray-matter dayjs @chakra-ui/react prismjs @emotion/react @emotion/styled framer-motion next-mdx-remote remark-gfm
```

## 创建文章

根目录新增`_posts`目录，在`_posts`目录下创建两个`mdx`文件(\_posts/js/helloWorld.mdx,\_posts/demo.mdx)，为什么是`mdx`文件呢？`mdx`支持渲染组件，支持引入导出组件，详细文档参考[MDX](https://mdxjs.com/)

## 创建公共函数目录

根目录新增`utils`目录，在`utils`目录下创建`getAllPosts.js`并写入如下函数

```js
import fs from 'fs'
import {globby} from 'globby'
import matter from 'gray-matter'
const dayjs = require('dayjs')
const relativeTime = require('dayjs/plugin/relativeTime')

dayjs.extend(relativeTime)

//获取所有文章
const GetAllPosts = async () => {
  const posts = await globby(['_posts'])
  return posts
    .reduce((prev, next) => {
      const fileContents = fs.readFileSync(next, 'utf8')
      const {data, content} = matter(fileContents)
      const postData = {
        ...data,
        group: dayjs(data.date).format('MMM/YYYY'),
        date: dayjs(data.date).format('MMM DD, YYYY'),
        fromNow: dayjs(data.date).fromNow(),
        modified: dayjs(data.modified).format('MMM DD, YYYY'),
        content,
        slug: next.replace(/^_posts\//, '').replace(/\.mdx$/, '')
      }
      !data.draft && prev.push(postData)
      return prev
    }, [])
    .sort((a, b) => dayjs(b.date) - dayjs(a.date))
}

// 根据slug导出文章
const GetPostBySlug = (slug) => {
  // eslint-disable-next-line no-undef
  return new Promise((resolve, reject) => {
    GetAllPosts()
      .then((posts) => {
        const post = posts.find((post) =>
          post.slug.includes(`${slug.join('/')}`)
        )
        resolve(post)
      })
      .catch(() => {
        reject({})
      })
  })
}

export {GetAllPosts, GetPostBySlug}
```

## 创建组件

根目录新增`components`目录

1. 创建`PostPage.tsx`组件，内容如下：

```tsx
import React, {useEffect} from 'react'
import Prism from 'prismjs'
import {Box} from '@chakra-ui/react'

// 以下按需引入
require('prismjs/components/prism-go')
require('prismjs/components/prism-python')
require('prismjs/components/prism-javascript')
require('prismjs/components/prism-css')
require('prismjs/components/prism-bash')
require('prismjs/components/prism-swift')
require('prismjs/components/prism-tsx')
require('prismjs/components/prism-jsx')
require('prismjs/components/prism-typescript')
require('prismjs/components/prism-sql')
require('prismjs/themes/prism-okaidia.min.css')

const PostPage = ({children}) => {
  useEffect(() => {
    const highlight = async () => {
      await Prism.highlightAll()
    }
    highlight().then(() => {})
  }, [children])
  return (
    <Box position="relative" w="2/3" fontSize="text.sm">
      {children}
    </Box>
  )
}
export default PostPage
```

2. 创建`pages/index.tsx`

```tsx
import NextLink from 'next/link'
import {Fragment} from 'react'
import {
  List,
  LinkOverlay,
  ListItem,
  Container,
  Heading,
  Image
} from '@chakra-ui/react'

const IndexPage = ({groupByMonthPosts}) => {
  return (
    <Container>
      {Object.keys(groupByMonthPosts).map((group) => {
        return (
          <Fragment key={group}>
            <Heading as="h3" mt={12} mb={4}>
              {group}
            </Heading>
            <List spacing={3}>
              {groupByMonthPosts[group].map((post) => {
                return (
                  <ListItem
                    position="relative"
                    display="flex"
                    gap={2}
                    alignItems="center"
                    key={post.title}
                  >
                    <NextLink legacyBehavior href={`/${post.slug}`} passHref>
                      <LinkOverlay>{post.title}</LinkOverlay>
                    </NextLink>
                    {post.tags.map((tag) => {
                      return (
                        <Image
                          key={tag}
                          boxSize={4}
                          objectFit="cover"
                          alt={tag}
                          src={`https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/icons/${tag}.svg`}
                        />
                      )
                    })}
                  </ListItem>
                )
              })}
            </List>
          </Fragment>
        )
      })}
    </Container>
  )
}

export default IndexPage

export async function getStaticProps() {
  const {GetAllPosts} = await import('utils/getAllPosts')
  const posts = await GetAllPosts()
  const groupByMonthPosts = posts.reduce((prev, next) => {
    if (Array.isArray(prev[next.group])) {
      prev[next.group].push(next)
    } else {
      prev[next.group] = []
      prev[next.group].push(next)
    }
    return prev
  }, {})
  return {
    props: {
      groupByMonthPosts
    }
  }
}
```

3. 创建`pages/[...slug].tsx`

```tsx
import {MDXRemote} from 'next-mdx-remote'
import {serialize} from 'next-mdx-remote/serialize'
import dynamic from 'next/dynamic'
import ErrorPage from 'next/error'
import NextLink from 'next/link'
import {useRouter} from 'next/router'
import React from 'react'
import remarkGfm from 'remark-gfm'
import components from 'utils/components'
import {
  Container,
  Box,
  Heading,
  Text,
  Link,
  Image,
  Center
} from '@chakra-ui/react'

const PostPage = dynamic(() => import('components/PostPage'), {ssr: false})

const Post = ({title, description, date, originalUrl, mdxSource, cover}) => {
  const router = useRouter()
  if (!router.isFallback && !mdxSource) {
    return <ErrorPage statusCode={404} />
  }
  return (
    <Container
      mt={20}
      maxW={{
        sm: 'container.sm',
        md: 'container.md',
        lg: 'container.2xl',
        xl: 'container.xl'
      }}
      className="post"
    >
      <NextSeo
        title={title}
        description={description}
        openGraph={{title, description}}
      />
      <Box as="hgroup">
        <Text textAlign="center" color="gray.500" fontSize="xs" as="p">
          Published {date}
        </Text>
        <Heading textAlign="center" as="h1" mt={4} mb={2}>
          {title}
        </Heading>
        {originalUrl && (
          <Center color="gray.500" fontSize="sm" mb={8}>
            本文翻译自：
            <NextLink legacyBehavior href={originalUrl} passHref>
              <Link>{originalUrl}</Link>
            </NextLink>
          </Center>
        )}
      </Box>
      <Image
        boxSize="100%"
        src={
          cover ??
          'https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/NhSU3O.jpg'
        }
        alt={title}
      />

      <PostPage>
        <MDXRemote {...mdxSource} components={components} />
      </PostPage>
    </Container>
  )
}

export const getStaticPaths = async () => {
  const {GetAllPosts} = await import('utils/getAllPosts')
  const allPosts = await GetAllPosts()
  const paths = allPosts.map((post) => ({
    params: {
      slug: post.slug.split('/')
    }
  }))

  return {
    paths,
    fallback: false
  }
}

export const getStaticProps = async ({params}) => {
  const {GetPostBySlug} = await import('utils/getAllPosts')
  const {content, ...data} = await GetPostBySlug(params.slug)
  const mdxSource = await serialize(content, {
    mdxOptions: {
      remarkPlugins: [[remarkGfm]],
      rehypePlugins: []
    },
    scope: data
  })
  return {
    props: {
      ...data,
      mdxSource
    }
  }
}

export default Post
```

至此，基本框架搭建完成，接下来调整样式及组件的引入，以及 mdx 渲染修正。

4. 调整样式

**可选**

引入`tailwind.css`，执行`pnpm install -D tailwindcss postcss autoprefixer && npx tailwindcss init -p`

修改`tailwind.config.js`,如下：

```js
/** @type {import('tailwindcss').Config} */
module.exports = {
  content: [
    './pages/**/*.{js,ts,jsx,tsx}',
    './components/**/*.{js,ts,jsx,tsx}'
  ],
  theme: {
    extend: {}
  },
  plugins: []
}
```

修改全局样式`styles/globals.scss`

```scss
@tailwind base;
@tailwind components;
@tailwind utilities;
```

**必须**

修改`pages/_app.tsx`，引入`chakra-ui`的配置

```tsx
// pages/_app.js
import {ChakraProvider} from '@chakra-ui/react'

function MyApp({Component, pageProps}) {
  return (
    <ChakraProvider>
      <Component {...pageProps} />
    </ChakraProvider>
  )
}

export default MyApp
```

到这里，不出意外，你的界面应该是长这样

![QeISvi](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/QeISvi.png)

点击链接，应该会报错，未引入`utils/components`，这个是配置 mdx 内元素渲染的组件，参考[MDX Components](https://mdxjs.com/table-of-components/)，mdx 提供默认的渲染组件，所以，这个是非必须的，不需要删除即可

个人比较喜欢 chakra-ui，所以将组件都转成了 chakra-ui 提供的组件，配置如下：

```js
import CanIUse from 'components/CanIUse'
import {Heading, Link, Box} from '@chakra-ui/react'
import {FiExternalLink} from 'react-icons/fi'

const components = {
  CanIUse,
  h2: (props) => (
    <Heading as="h2" mb={4}>
      {props.children}
    </Heading>
  ),
  h3: (props) => (
    <Heading as="h3" mb={4}>
      {props.children}
    </Heading>
  ),
  h4: (props) => (
    <Heading as="h4" mb={4}>
      {props.children}
    </Heading>
  ),
  h5: (props) => (
    <Heading as="h5" mb={4}>
      {props.children}
    </Heading>
  ),
  p: (props) => (
    <Box as="div" mb={4}>
      {props.children}
    </Box>
  ),
  div: (props) => <Box mb={4}>{props.children}</Box>,
  a: (props) => {
    return (
      <Link
        display="inline-flex"
        alignItems="center"
        href={props.href}
        gap={2}
        isExternal
      >
        {props.children}
        <FiExternalLink />
      </Link>
    )
  }
}

export default components
```

好了，到这里基本完成了基于 Next.js 的博客搭建。

## 部署到 Vercel

Next.js 部署到 Vercel 无需更改和配置，无缝衔接。

![LKxyVc](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/LKxyVc.png)

![lwjB1p](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/lwjB1p.png)

![XR6YO0](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/XR6YO0.png)

![aUOfQO](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/aUOfQO.png)

[【Source Code】](https://github.com/Manonicu/blog-demo)

也可以参考我的个人网站[Manon.icu](https://manon.icu/)[Github Source Code](https://github.com/Manonicu/site)


从性能、打包大小、SEO来看，Next.js可能是最适合写blog的React框架。

Next.js - Building a blog


在 Swift 中，继承(Inheritance)是一种定义新类的方法，使其从现有类继承属性和方法。新类称为子类(Subclass)，被继承的类称为父类(Superclass)。

子类可以重写(override)父类的属性和方法，也可以添加新的属性和方法。子类还可以继续被其他类继承，从而形成类的层次结构。

在 Swift 中，继承可以通过在类的定义中使用冒号(:)来实现。例如：

```swift
class Animal {
var name: String = ""

    func makeSound() {
        // 产生动物叫声
    }
}

class Dog: Animal {
var breed: String = ""

    override func makeSound() {
        // 产生狗叫声
    }
}
```

在上面的示例中，我们定义了两个类 Animal 和 Dog。Dog 继承自 Animal，并添加了一个名为 breed 的属性。Dog 还重写了 Animal 的 makeSound() 方法。

通过继承，Dog 类获得了 Animal 类中的所有属性和方法。这意味着，我们可以在 Dog 类中使用 Animal 类中定义的属性和方法，而不必重复编写相同的代码。此外，通过重写 makeSound() 方法，我们可以根据需要修改 Dog 类的行为。

在 Swift 中，我们还可以使用关键字 final 来防止子类重写父类的属性或方法。例如：

```swift
class Animal {
final var name: String = ""

    final func makeSound() {
        // 产生动物叫声
    }
}

class Dog: Animal {
// 无法重写 name 或 makeSound 方法
}
```

在上面的示例中，我们使用关键字 final 来标记 name 和 makeSound() 方法，从而防止子类重写这些属性和方法。

继承是 Swift 语言中强大而灵活的功能之一。通过继承，我们可以轻松地扩展现有类的功能，从而构建出更复杂和强大的程序。同时，继承也需要谨慎使用，以避免出现代码的复杂性和耦合度过高等问题。


在 Swift 中，继承(Inheritance)是一种定义新类的方法，使其从现有类继承属性和方法。新类称为子类(Subclass)，被继承的类称为父类(Superclass)。