协议规定了用来实现某一特定功能所必需的方法和属性。

Protocols - 协议


`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


在`Next.js`中支持全局样式，并且仅可在`_app.js`中引入。

创建全局样式

```css
html,
body {
  padding: 0;
  margin: 0;
  line-height: 1.6;
  font-size: 18px;
  background-color: lime;
}

* {
  box-sizing: border-box;
}

a {
  color: #0070f3;
  text-decoration: none;
}

a:hover {
  text-decoration: underline;
}

img {
  max-width: 100%;
  display: block;
}
```

在`_app.js`中引入全局样式

```js
import '../styles/styles.css'

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

启动服务

```bash
npm run dev
```

检查结果

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


Next.js - Global CSS Support


查询结果是无序的或者按照 id 排序的，如果需要按照某个字段排序，可以使用 order by 语句。

## 语法

```sql
SELECT
	select_list
FROM
	table_name
ORDER BY
	sort_expression1 [ASC | DESC],
        ...
	sort_expressionN [ASC | DESC];
```

- 首先需要在`ORDER BY`后面指定排序的字段和排序表达式，每个字段之间用逗号分隔。
- 如果没有指定排序的字段，则默认按照 id 排序。
- `ASC`表示升序，`DESC`表示降序。

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

## 示例

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

#### 查询所有的用户，并按照 first_name 升序排序。

```sql
SELECT
	first_name,
	last_name
FROM
	customer
ORDER BY
	first_name ASC;
```

`ASC`是默认排序选项，可以省略。

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

#### 查询所有的用户，并按照 last_name 降序排序。

```sql
SELECT
       first_name,
       last_name
FROM
       customer
ORDER BY
       last_name DESC;
```

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

#### 对多列排序

```sql
SELECT
	first_name,
	last_name
FROM
	customer
ORDER BY
	first_name ASC,
	last_name DESC;
```

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

#### 表达式排序

```sql
SELECT
	first_name,
	LENGTH(first_name) len
FROM
	customer
ORDER BY
	len DESC;
```

选择名字，并按照名字的长度进行降序排序。

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

## NULL

`NULL`是一个标记，表示丢失的数据或记录时数据未知。

对包含`NULL`行进行排序时，可以使用指定的排序表达式进行排序，比如：

```sql
ORDER BY sort_expresssion [ASC | DESC] [NULLS FIRST | NULLS LAST]
```

`NULL FIRST`表示 NULL 值优先，`NULL LAST`表示 NULL 值后来优先。

首先创建个表

```sql
-- create a new table
CREATE TABLE sort_demo(
	num INT
);

-- insert some data
INSERT INTO sort_demo(num)
VALUES(1),(2),(3),(null);
```

查询并返回数据

```sql
SELECT num
FROM sort_demo
ORDER BY num;
```

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

可以看到默认返回排序将 null 值放到最后，如果想改变这种默认的排序，可以使用`NULLS FIRST`或`NULLS LAST`。

```sql
SELECT num
FROM sort_demo
ORDER BY num NULLS FIRST;
```

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

翻转顺序

```sql
SELECT num
FROM sort_demo
ORDER BY num DESC NULLS LAST;
```

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

## 总结

- 排序的字段可以是一个表的列，也可以是一个表达式。
- 使用`ASC`或`DESC`指定排序顺序。
- 使用`NULLS FIRST`或`NULLS LAST`指定排序的 NULL 值优先级。


Postgresql - Order by


在 `Next.js` 中，我们可以通过 Head 组件修改每个`react`页面的头信息。

修改`index.js`

```js
import Link from 'next/link'
import Head from 'next/head'

function HomePage() {
  return (
    <>
      <Head>
        <title>Welcome to Next.js!</title>
      </Head>
      <div>Welcome to Next.js!</div>
      <Link href="/posts/first">
        <a>First Post</a>
      </Link>
      <br />
      <img src="/logo.png" alt="TutorialsPoint Logo" />
    </>
  )
}

export default HomePage
```

修改`first.js`

```js
import Link from 'next/link'
import Head from 'next/head'

export default function FirstPost() {
  return (
    <>
      <Head>
        <title>My First Post</title>
      </Head>
      <h1>My First Post</h1>
      <h2>
        <Link href="/">
          <a>Home</a>
        </Link>
      </h2>
    </>
  )
}
```

启动服务

```bash
npm run dev
```

检查页面

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

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


在 Next.js 中，我们可以通过Head组件修改每个react页面的头信息。

Next.js - Meta Data


Context 提供了一个无需为每层组件手动添加 props，就能在组件树间进行数据传递的方法。

> 在一个典型的 React 应用中，数据是通过 props 属性自上而下（由父及子）进行传递的，但此种用法对于某些类型的属性而言是极其繁琐的（例如：地区偏好，UI 主题），这些属性是应用程序中许多组件都需要的。Context 提供了一种在组件之间共享此类值的方式，而不必显式地通过组件树的逐层传递 props。

例如如下代码：props 的传递需要层层传递，使用`context`则可以简化数据传递。

```jsx
function App() {
  return <Body name="John Doe" />
}

function Body({name}) {
  return <Greeting name={name} />
}

function Greeting({name}) {
  return <h1>Welcome, {name}</h1>
}
```

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

const NameContext = createContext('');

function App() {
  return (
    <NameContext.Provider value="John Doe">
      <Body />
    <NameContext.Provider>
  );
}

function Body() {
  return <Greeting />;
}

function Greeting() {
  return (
    <NameContext.Consumer>
      {name => <h1>Welcome, {name}</h1>}
    </NameContext.Consumer>
  );
}
```

`context`的设计目的是为了共享那些对于一个组件树而言是“全局”的数据。


Context 提供了一个无需为每层组件手动添加 props，就能在组件树间进行数据传递的方法。

React Context


Go 是一种编程语言，它提供了一种简单而有效的错误处理机制。 Go 的错误处理主要基于两个概念：错误类型和错误值。

在 Go 中，错误类型是一个接口类型，定义了一个名为 `error` 的预定义接口。该接口只有一个方法 `Error()`，它返回一个字符串，表示错误的描述信息。任何实现了 `error` 接口的类型都可以被视为一个错误类型。

错误值则是实现了 `error` 接口的具体实例。当出现错误时，通常会返回一个错误值来表示错误的发生。在函数调用中，通常会将错误作为函数的最后一个返回值返回。如果没有错误发生，错误值为 `nil`。

下面是一个简单的示例，展示了如何在 Go 中处理错误：

```go
package main

import (
	"errors"
	"fmt"
)

func divide(x, y int) (int, error) {
	if y == 0 {
		return 0, errors.New("division by zero")
	}
	return x / y, nil
}

func main() {
	result, err := divide(10, 2)
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Result:", result)
	}
}
```

在上面的示例中，`divide` 函数用于执行整数除法运算。如果除数为零，则返回一个错误值，表示发生了除以零的错误。在 `main` 函数中，我们调用 `divide` 函数，并使用错误值进行错误检查。如果错误值不为 `nil`，则打印错误信息；否则，打印计算结果。

Go 还提供了一种更简便的错误处理方式，即使用 `errors` 包中的 `Errorf` 函数。该函数类似于 `fmt.Printf`，可以通过格式化字符串和参数创建一个新的错误值。例如：

```go
return nil, fmt.Errorf("error occurred: %v", someValue)
```

这样可以更方便地生成自定义的错误信息。

此外，Go 还支持自定义错误类型。开发人员可以通过定义满足 `error` 接口的自定义类型来表示特定的错误。这样可以提供更丰富的错误信息和错误处理逻辑。

Go 的错误处理机制基于错误类型和错误值。通过返回错误值，并使用条件语句进行错误检查，开发人员可以有效地处理和传播错误信息。

除了使用错误值进行错误检查外，Go 还提供了另外两种错误处理方式：错误恢复（Error Recovery）和错误日志记录（Error Logging）。

## 错误恢复

在某些情况下，当程序遇到错误时，我们可能希望程序能够继续执行而不是立即终止。为了实现这种错误恢复的能力，Go 提供了 recover 函数和 panic 机制。panic 用于引发一个错误，并立即停止当前函数的执行，然后程序会开始回溯执行调用栈，直到遇到包含 recover 函数的延迟函数调用。recover 用于捕获 panic 引发的错误，并允许程序进行一些处理。通过使用 defer 关键字和 recover 函数，我们可以在一些关键的代码段中设置恢复机制，以确保程序在遇到错误时能够继续执行，并进行一些必要的清理操作。

```go
func process() {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println("Recovered from error:", err)
		}
	}()

	// 执行可能引发错误的代码
	// 当遇到错误时，使用 panic 引发错误
	panic("something went wrong")
}
```

process 函数中的 panic 语句会引发一个错误，并立即停止函数的执行。但由于设置了延迟函数调用和 recover 函数，程序会继续执行 defer 块中的代码，捕获错误并进行处理。

## 错误日志记录

除了简单地检查错误和恢复错误外，有时我们还需要记录错误信息以进行故障排查和日志记录。在 Go 中，通常使用标准库中的 log 包或第三方日志库（如 logrus、zap 等）来记录错误日志。这些库提供了各种级别的日志记录功能，可以将错误信息和其他相关信息写入日志文件或其他输出目标。

```go
package main

import (
	"errors"
	"log"
)

func main() {
	err := someFunction()
	if err != nil {
		log.Println("Error:", err)
	}
}

func someFunction() error {
	return errors.New("something went wrong")
}
```

使用标准库中的 log 包将错误信息记录到日志中。可以使用不同的日志级别（如 Println、Printf、Error 等）根据需要进行日志记录。

如果在错误恢复机制中没有设置延迟函数调用和 recover 函数，那么在 panic 引发错误后，程序将会立即终止并打印出错误信息。这种情况下，错误将无法被捕获和处理，程序会退出。

例如，考虑以下代码：

```go
func process() {
	// 执行可能引发错误的代码
	// 当遇到错误时，使用 panic 引发错误
	panic("something went wrong")
}

func main() {
	process()
	fmt.Println("After process")
}
```

在上述示例中，当 process 函数执行到 panic 语句时，程序会立即终止，并输出以下错误信息：

```shell
panic: something went wrong

goroutine 1 [running]:
main.process()
	/Users/user/main.go:5 +0x39
main.main()
	/Users/user/main.go:10 +0x20
exit status 2
```

可以看到，错误信息指示发生了 panic，并显示了调用栈的信息。然后，程序会退出，并不会继续执行 fmt.Println("After process") 这行代码。

因此，在错误恢复机制中，如果没有设置延迟函数调用和 recover 函数，panic 引发的错误将会导致程序的立即终止。为了能够恢复错误并继续执行程序，必须使用 defer 关键字和 recover 函数来捕获和处理错误。


Go 的错误处理主要基于两个概念：错误类型和错误值。