Go - 控制流


在 JavaScript 中，Symbol 是一种原始数据类型，表示唯一、不可变的值。Symbols 用于创建唯一的对象键，并提供创建私有对象成员的方法。

你可以使用 Symbol() 函数创建一个 symbol：

```js
let sym = Symbol()
```

在创建 symbol 时，你还可以为它提供一个描述，这对调试很有帮助：

```js
let sym = Symbol('debug symbol')
```

Symbols 是唯一的，不能使用 == 或 === 运算符进行比较。你可以使用 Object.is() 方法来比较 symbols：

```js
let sym1 = Symbol('debug symbol')
let sym2 = Symbol('debug symbol')
console.log(sym1 === sym2) // false
console.log(Object.is(sym1, sym2)) // false
```

要将 symbol 用作对象键，需要将它放在方括号中：

```js
let sym = Symbol('debug symbol')
let obj = {
  [sym]: 'value'
}
console.log(obj[sym]) // "value"
```

Symbols 不可枚举，这意味着它们不包含在 Object.keys() 或 Object.getOwnPropertyNames() 返回的对象键列表中。你可以使用 Object.getOwnPropertySymbols() 方法获取对象中的 symbol 列表：

```js
let sym = Symbol('debug symbol')
let obj = {
  [sym]: 'value'
}
console.log(Object.keys(obj)) // []
console.log(Object.getOwnPropertyNames(obj)) // []
console.log(Object.getOwnPropertySymbols(obj)) // [Symbol(debug symbol)]
```

Symbols 可用于创建私有对象成员。由于 symbols 是唯一的且不可枚举的，所以可以将它们用作对象属性的键


Symbol


`path` 模块提供了许多非常实用的函数来访问文件系统并与文件系统进行交互

```js
const path = require('path);
```

## 方法

- `baseName(p, ext)`: 返回路径中的文件名，不包括扩展名
- `dirName(p)`: 返回路径中的目录名
- `extname(p)`: 返回路径中的扩展名
- `isAbsolute(p)`: 判断路径是否是绝对路径
- `join(...paths)`: 将多个路径连接成一个路径
- `normalize(p)`: 将路径规范化
- `parse(pathString)`: 解析路径字符串
- `relative(from, to)`: 返回路径 `from` 和路径 `to` 相对于当前工作目录的相对路径
- `resolve(...pathSegments)`: 解析路径字符串

## 属性

- `sep`: 路径分隔符
- `posix`: posix 路径
- `win32`: win32 路径
- `delimiter`: 路径分隔符

```js
const path = require('path')

// Normalization
console.log(
  'normalization : ' + path.normalize('/test/test1//2slashes/1slash/tab/..')
) //normalization : /test/test1/2slashes/1slash

// Join
console.log(
  'joint path : ' + path.join('/test', 'test1', '2slashes/1slash', 'tab', '..')
) //joint path : /test/test1/2slashes/1slash

// Resolve
console.log('resolve : ' + path.resolve('main.js')) // resolve : /web/com/1427176256_27423/main.js

// extName
console.log('ext name : ' + path.extname('main.js')) //ext name : .js
```


path 模块提供了许多非常实用的函数来访问文件系统并与文件系统进行交互

Node.js - Path


在 Postgresql 中，FULL OUTER JOIN 是一种结合左外连接和右外连接结果的连接类型。它返回左表中的所有行和右表中的所有行，包括在 ON 子句中不匹配的行。FULL OUTER JOIN 在想要在最终结果集中包含两个表中不匹配的行时非常有用。

以下查询使用`INNER JOIN`表连接到自身的查询

```sql
SELECT select_list
FROM table_name t1
INNER JOIN table_name t2 ON join_predicate;
```

此外还可以使用`LEFT JOIN`或`RIGHT JOIN`将表连接到自身：

```sql
SELECT select_list
FROM table_name t1
LEFT JOIN table_name t2 ON join_predicate;
```

## 示例

### 查询分层数据

假设有以下组织结构

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

创建`employee`表并将一些数据插入表中

```sql
CREATE TABLE employee (
	employee_id INT PRIMARY KEY,
	first_name VARCHAR (255) NOT NULL,
	last_name VARCHAR (255) NOT NULL,
	manager_id INT,
	FOREIGN KEY (manager_id)
	REFERENCES employee (employee_id)
	ON DELETE CASCADE
);
INSERT INTO employee (
	employee_id,
	first_name,
	last_name,
	manager_id
)
VALUES
	(1, 'Windy', 'Hays', NULL),
	(2, 'Ava', 'Christensen', 1),
	(3, 'Hassan', 'Conner', 1),
	(4, 'Anna', 'Reeves', 2),
	(5, 'Sau', 'Norman', 2),
	(6, 'Kelsie', 'Hays', 3),
	(7, 'Tory', 'Goff', 3),
	(8, 'Salley', 'Lester', 3);
```

使用自连接查询谁向谁报告

```sql
SELECT
    e.first_name || ' ' || e.last_name employee,
    m .first_name || ' ' || m .last_name manager
FROM
    employee e
INNER JOIN employee m ON m .employee_id = e.manager_id
ORDER BY manager;
```

![1zBzNp](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/1zBzNp.jpg)

以上查询两次引用`employee`表，一次作为雇员，另一次作为经理，通过匹配`employee_id`和`manager_id`查找雇员/经理对

使用`LEFT JOIN`instead of`INNER JOIN`查询结果集中包含最高管理者

```sql
SELECT
    e.first_name || ' ' || e.last_name employee,
    m .first_name || ' ' || m .last_name manager
FROM
    employee e
LEFT JOIN employee m ON m .employee_id = e.manager_id
ORDER BY manager;
```

![7eG9pZ](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/7eG9pZ.jpg)

### 比较同表的行

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

查询所有长度相同的电影

```sql
SELECT
    f1.title,
    f2.title,
    f1.length
FROM
    film f1
INNER JOIN film f2
    ON f1.film_id <> f2.film_id AND
       f1.length = f2.length;
```

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


在 Postgresql 中，FULL OUTER JOIN 是一种结合左外连接和右外连接结果的连接类型

Postgresql - FULL OUTER JOIN


`crypto`模块提供了加密功能，其中包括了用于 OpenSSL 散列、HMAC、加密、解密、签名、以及验证的函数的一整套封装。

几种常见的加密、解密算法：

- hash HMAC
- cipher
- decipher
- sign
- verify

## 什么是 hash

hash 是一种散列函数，用于生成一个唯一的值，用于比较两个值是否相同。

## 什么是 HMAC

HMAC 是一种基于 hash 的密钥的认证算法，它可以用于验证数据的完整性，以及防止被篡改。

```js
const {createHmac} = require('crypto')

const secret = 'abcdefg'
const hash = createHmac('sha256', secret)
  .update('I love cupcakes')
  .digest('hex')
console.log(hash)
// c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
```

使用`cipher`加密

```js
const crypto = require('crypto')
const cipher = crypto.createCipher('aes192', 'a password')

var encrypted = cipher.update('some clear text data', 'utf8', 'hex')
encrypted += cipher.final('hex')

console.log(encrypted)
```

使用`decipher`解密

```js
const crypto = require('crypto')
const decipher = crypto.createDecipher('aes192', 'a password')

var encrypted =
  'c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e'
var decrypted = decipher.update(encrypted, 'hex', 'utf8')
decrypted += decipher.final('utf8')
console.log(decipher)
```

使用`sign`签名

```js
const crypto = require('crypto')
const buffer = require('buffer')

const {privateKey, publicKey} = crypto.generateKeyPairSync('rsa', {
  modulusLength: 2048
})

const data = Buffer.from('I Love GeeksForGeeks')

const sign = crypto.sign('SHA256', data, privateKey)

const signature = sign.toString('base64')

console.log(`Signature:\n\n ${signature}`)
```

使用`verify`验证

```js
const crypto = require('crypto')
const buffer = require('buffer')

const {privateKey, publicKey} = crypto.generateKeyPairSync('rsa', {
  modulusLength: 2048
})
const algorithm = 'SHA256'

const data = Buffer.from('I Love GeeksForGeeks')

const signature = crypto.sign(algorithm, data, privateKey)

const isVerified = crypto.verify(algorithm, data, publicKey, signature)

console.log(`Is signature verified:${isVerified}`)
```


Node.js - Crypto


`child_process` 模块使我们在一个运行良好的子进程内运行一些能够进入操作系统的命令

## spawn

`spawn`创建一个子进程

语法：`spawn(command, [args], [options])`

```js
const {spawn} = require('child_process')
const fs = require('fs')

for (var i = 0; i < 3; i++) {
  var workerProcess = spawn('node', ['support.js', i])
  workerProcess.stdout.on('data', function (data) {
    console.log('stdout: ' + data)
  })
  workerProcess.stderr.on('data', function (data) {
    console.log('stderr: ' + data)
  })
  workerProcess.on('close', function (code) {
    console.log('child process exited with code ' + code)
  })
}
```

## exec

`exec`使用子进程执行命令，不缓存子进程的输出，并将子进程的输出以回调函数参数的形式返回

语法：`exec(command, [options], callback)`

```js support.js
console.log('进程 ' + process.argv[2] + ' 执行。')
```

```js master.js
const fs = require('fs')
const child_process = require('child_process')

for (var i = 0; i < 3; i++) {
  var workerProcess = child_process.exec(
    'node support.js ' + i,
    function (error, stdout, stderr) {
      if (error) {
        console.log(error.stack)
        console.log('Error code: ' + error.code)
        console.log('Signal received: ' + error.signal)
      }
      console.log('stdout: ' + stdout)
      console.log('stderr: ' + stderr)
    }
  )

  workerProcess.on('exit', function (code) {
    console.log('子进程已退出，退出码 ' + code)
  })
}
```

## fork

`fork`创建一个子进程，并在父进程中继续执行

语法：`fork(modulePath, [args], [options])`

```js support.js
console.log('进程 ' + process.argv[2] + ' 执行。')
```

```js master.js
const fs = require('fs')
const child_process = require('child_process')

for (var i = 0; i < 3; i++) {
  var worker_process = child_process.fork('support.js', [i])

  worker_process.on('close', function (code) {
    console.log('子进程已退出，退出码 ' + code)
  })
}
```

[Node.js 文档](http://nodejs.cn/api/child_process.html)


child_process 模块使我们在一个运行良好的子进程内运行一些能够进入操作系统的命令

Node.js - Child Process


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框架。