强制类型转换


`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 预渲染支持两种方式：

- SSG 预渲染
- SSR 预渲染

## SSG 预渲染

SSG 预渲染是指在构建时生成 HTML，可以在没有数据的情况下完成，在这种情况下，HTML 页面将准备就绪，而无需预先获取数据，然后开始渲染。

数据可以稍后或应要求提供。

优点：这种方式可以解决白屏问题、SEO 问题
缺点：所有用户看到的都是同一个页面，无法生成用户相关内容

```js
import Link from 'next/link'
import Head from 'next/head'
import Container from '../../components/container'

export default function FirstPost(props) {
  return (
    <>
      <Container>
        <Head>
          <title>My First Post</title>
        </Head>
        <h1>My First Post</h1>
        <h2>
          <Link href="/">
            <a>Home</a>
          </Link>
          <div>Next stars: {props.stars}</div>
        </h2>
      </Container>
    </>
  )
}

export async function getStaticProps() {
  const res = await fetch('https://api.github.com/repos/vercel/next.js')
  const json = await res.json()
  return {
    props: {stars: json.stargazers_count}
  }
}
```

## SSR 预渲染

后端将页面渲染，返回 HTML String 格式，传递到前端，前端进行 hydrate() ,会保留 HTML 并附上时间监听，也就是说后端渲染 HTML，前端添加监听。

前端也会渲染一次，用以确保前后端渲染结果一致

每个组件都有一个特殊的方法`getStaticProps`，可用于获取数据并作为页面的属性传递数据。

## 使用 getServerSideProps

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

function HomePage(props) {
  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 />
      <div>Next stars: {props.stars}</div>
      <img src="/logo.png" alt="TutorialsPoint Logo" />
    </>
  )
}

export async function getServerSideProps(context) {
  const res = await fetch('https://api.github.com/repos/vercel/next.js')
  const json = await res.json()
  return {
    props: {stars: json.stargazers_count}
  }
}

export default HomePage
```

启动服务

```bash
npm run dev
```


Next.js - Pre-Rendering


## typeof

使用`typeof`可以判断一个变量的类型，返回值为`string`，可以使用`instanceof`来判断一个对象是否是某个类的实例。

我们使用运算符 typeof 检查 getMonth 方法是否是一个函数，看看它是否返回`function`

```js
const date = new Date(2021, 1, 1)
console.log(typeof date.getMonth === 'function')
```

如果返回`true`，说明 getMonth 是一个函数，`date`可能是`Date`实例，如果返回`false`，说明 getMonth 是一个字符串。

## instanceof

instanceof 可以用来判断一个对象是否是某个类的实例，返回值为`boolean`。

```js
const date = new Date(2021, 1, 1)
console.log(date instanceof Date)
```

如果返回`true`，说明 date 是一个`Date`实例，如果返回`false`，说明 date 不是一个`Date`实例。

## Object.prototype.toString

Object.prototype.toString 方法可以返回一个对象的字符串表示，返回值为`string`。

```js
const date = new Date(2021, 1, 1)
console.log(date instanceof Date)
```

## isValid Date

判断一个对象是否是一个有效的日期对象，返回值为`boolean`。

```js
Object.prototype.toString
```


如何判断是否是日期对象？


## 实现 instanceof

> 核心考察点 [getPrototypeOf](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/GetPrototypeOf)

```js
function _instanceof(left, right) {
  if (left !== 'object' || left === null) return false
  const proto = Object.getPrototypeOf(left)
  while (true) {
    if (proto === null) return false
    if (proto === right.prototype) return true
    proto = Object.getPrototypeOf(proto)
  }
}
_instanceof(111, Number) //true
_instanceof(new String('11'), String) //true
```


面试题-手写instanceof


## 如何运行容器

在[Hello world](/blog/docker/hello-world)中我们已经介绍了如何运行一个容器，这里我们再来详细介绍一下如何运行一个容器。

运行 docker 容器基本命令

```bash
docker run <image name>
```

详细命令

```bash
docker <object> <command> <options>
```

- object: 对象，可以是容器、镜像、网络、卷等
- command: 命令，可以是运行、创建、删除、停止等
- options: 选项，可以是镜像名、容器名、网络名等

```bash
docker container run <image name>
```

image name 可以是镜像 ID、镜像名、镜像名:tag，例如：

```bash
docker container run --publish 8080:80 nginx
```

## 如何发布端口

容器是独立的环境。您的主机系统对容器内发生的事情一无所知。因此，在容器内运行的应用程序仍然不能从外部访问。

要允许从容器外部访问，必须将容器内的适当端口发布到本地网络上的端口。`--publish`或`-p` 选项的常用语法如下:

```bash
docker container run --publish <host port>:<container port>
```

host port: 主机端口，可以是任意端口，例如 8080

container port: 容器端口，可以是容器内部的任意端口，例如 80

通过上面的命令，我们可以将容器内的 80 端口发布到主机的 8080 端口，这样我们就可以通过主机的 8080 端口访问容器内的 80 端口了。

默认情况下，`docker container run` 命令会在前台运行容器。这意味着，您的终端会被占用，直到您按下 Ctrl+C 停止容器。

## 如何使用分离模式

docker 分离模式可以让我们在后台运行容器，这样我们就可以在终端执行其他命令了。

```bash
docker container run --publish 8080:80 --detach nginx
```

## 如何列出容器

`container ls` 命令可以列出所有正在运行的容器。

```bash
docker container ls

# CONTAINER ID        IMAGE                 COMMAND                  CREATED             STATUS              PORTS                  NAMES
# 9f21cb777058        fhsinchy/hello-dock   "/docker-entrypoint.…"   5 seconds ago       Up 5 seconds        0.0.0.0:8080->80/tcp   gifted_sammet
```

名称为 gifted_sammet 的容器正在运行，创建于 5 秒前，状态是`Up 5 seconds`。CONTAINER ID 是 9f21cb777058，镜像是 fhsinchy/hello-dock，端口是 8080:80。

## 如何命名或重命名容器

`--name` 选项可以为容器命名。

```bash
docker container run --publish 8080:80 --detach --name webhost nginx
```

CONTAINER ID 是随机的 64 位字符串，如果您想要为容器命名，可以使用`--name`选项。

```bash
docker container run --detach --publish 8888:80 --name hello-dock-container fhsinchy/hello-dock

# b1db06e400c4c5e81a93a64d30acc1bf821bed63af36cab5cdb95d25e114f5fb
```

使用`container rename`重命名已经存在的容器。

```bash
docker container rename hello-dock-container hello-dock
```

## 如何停止或终止正在运行的容器

使用`docker stop`命令终止正在运行的容器。比如：

```bash
docker stop container_name_or_ID
```

如果容器未终止，可以使用`docker kill <container name or container id>`杀掉容器。

```bash
docker kill <container_name_or_ID>
```

停止或终止容器可能会丢失任何未保存的数据或状态。

## 如何重启容器

使用`docker restart`重启容器，例如：

```bash
docker restart container_name_or_id
```

这将停止容器，然后使用与前面相同的配置重新启动它。适用于对容器的环境变量、网络设置应用更改时，或者当容器由于错误而停止时。

## 如何在不运行的情况下创建容器

- container create 命令创建容器，但不启动它。

```bash
docker container create --publish 80:80 --name webhost nginx
```

- container start 命令启动容器，需要先创建容器。

```bash
docker container start webhost
```

## 如何删除容器

删除已经停止的容器，使用`docker container rm`命令。

```bash
docker container rm container_name_or_id
```

通过 container ls --all 命令可以列出所有容器，其中 status 为 exited 的容器是已经停止的容器。

```bash
docker container ls --all
```

## 如何以交互模式运行容器

要以交互模式运行容器，可以使用 docker run 命令并在命令末尾加上 -it 选项。例如：

```bash
docker run -it image_name /bin/bash
```

这将启动一个新的容器，并以交互模式运行 /bin/bash。这对于进入容器内部并执行命令非常有用。

## 如何在容器内执行命令

使用 docker exec 命令在容器内执行命令。语法如下：

```bash
docker exec [OPTIONS] CONTAINER COMMAND [ARG...]
```

例如，要在容器内部运行 ls 命令，可以使用以下命令：

```bash
docker exec container_name_or_id ls
```

## 如何使用可执行镜像

可执行映像是包含可执行二进制文件或脚本的映像，它被设计为作为独立进程运行。要处理可执行映像，需要使用`docker run`命令。基本语法是:

```bash
docker run [OPTIONS] IMAGE[:TAG|@DIGEST] [COMMAND] [ARG...]
```

例如：运行名称为 hello-dock 的可执行镜像，可以使用以下命令：

```bash
docker run hello-dock
```

如果在 Dockerfile 中指定了 默认命令，可以使用以下命令：

```bash
docker run hello-dock
```

否则，可以使用以下命令：

```bash
docker run hello-dock /bin/bash
```

同样，可以使用命令传递参数：

```bash
docker run hello-dock /bin/bash -c "echo hello world"
```

## 如何忽略不必要的文件

在 Dockerfile 中，可以使用 .dockerignore 文件来忽略不必要的文件。例如，如果 Dockerfile 位于项目根目录中，可以使用以下命令忽略所有 .git 文件：

```bash
echo ".git" >> .dockerignore
```


Docker 容器基本操作


在 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)。