结构体和类是 Swift 中两种重要的数据类型，它们都可以用于定义自定义的复合数据类型。结构体和类非常相似，但它们也有一些重要的区别。

Swift - 结构体和类


在 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


## Go 介绍

Go 也称为 Golang，是 Google 开发的一种开源，编译和静态类型的编程语言。Go 创作背后的关键人物是 Rob Pike， Ken Thompson 和 Robert Griesemer。Go 于 2009 年 11 月公开发布。

Go 是一种通用的编程语言，具有简单的语法，并具有强大的标准库作为后盾。Go 大放异彩的关键领域之一是创建高可用性和可伸缩性的 Web 应用程序。Go 还可以用于创建命令行应用程序，桌面应用程序甚至移动应用程序。

## Go 优点

当大量其他语言（例如 python，ruby，nodejs ...）执行相同的工作时，为什么选择 Go 作为服务器端编程语言。

这是我选择 Go 时发现的一些优点。

### 简单语法

语法简单明了，并且该语言不会因不必要的功能而肿。这使得编写可读性和可维护性的代码变得容易。

### 易于编写并发程序

并发是语言的固有部分。结果，编写多线程程序简直是小菜一碟。这是通过 Goroutines 和渠道实现的，我们将在接下来的教程中对其进行讨论。

### 编译语言

Go 是一种编译语言。源代码被编译为本地二进制文件。解释语言（例如，nodejs 中使用的 JavaScript）缺少此功能。

### 快速编译

Go 编译器非常神奇，并且从一开始就被设计为快速的。

### 静态链接

Go 编译器支持静态链接。整个 Go 项目可以静态链接到一个大的二进制文件中，并且可以轻松部署在云服务器中，而不必担心依赖关系。

### Go 工具

工具在 Go 中值得特别提及。Go 附带了功能强大的工具，可帮助开发人员编写更好的代码。很少有常用的工具是

- gofmt- gofmt 用于自动格式化 go 源代码。它使用制表符进行缩进，并使用空格进行对齐。
- vet- vet 分析 go 源代码并报告可能的可疑代码。vet 报告的所有内容都不是真正的问题，但是具有捕获编译器未报告的错误的能力，例如使用 Printf 时格式不正确的说明符。
- golint- golint 用于识别代码中的样式问题。

### 垃圾收集

Go 使用垃圾回收，因此内存管理几乎会自动执行，开发人员无需担心内存管理问题。这也有助于轻松地编写并发程序。

### 简单语言规范

语言规范非常简单。在整个规范在页面千篇一律，你甚至可以用它来写你自己的编译器:)

### 开源的

最后但并非最不重要的一点是，Go 是一个开源项目。您可以参与 Go 项目并为该项目做出贡献。

## 使用 Go 构建的热门产品

以下是一些使用 Go 构建的流行产品。

- Google 使用 Go 开发了 Kubernetes。
- Docker 是世界著名的容器化平台，是使用 Go 开发的。
- Dropbox 已将其性能关键组件从 Python 迁移到 Go。
- Infoblox 的下一代网络产品是使用 Go 开发的。

## 安装

Go 可以安装在 Mac，Windows 和 Linux 这三个平台上。您可以从https://golang.org/dl/下载对应平台的二进制文件

### Mac

从https://golang.org/dl/下载Mac OS 安装程序。双击开始安装。按照提示进行操作，这会将 Golang 安装在/usr/local/go 中，并且还将文件夹/usr/local/go/bin 添加到 PATH 环境变量中。

```bash
# if you don't have git install it like so:
brew install git

# then install go
brew install go

# add GOBIN path to your PATH in ~/.bash_profile
export PATH=${HOME}/go/bin:$PATH
```

### Windows

从https://golang.org/dl/下载MSI安装程序。双击开始安装，然后按照提示进行操作。这会将Go安装在位置c:\Go，还将目录c:\Go\ bin 添加到您的路径环境变量中。

### Linux

从https://golang.org/dl/下载tar文件并将其解压缩到/usr/local。

将/usr/local/go/bin 添加到 PATH 环境变量中。

## 验证安装

要验证 Go 安装是否成功，请 go version 在终端中键入命令，它将输出已安装的 Go 版本。这是我终端的输出。

```bash
$ go version
go version go1.13.6 darwin/amd64
```


第1部分：介绍和安装


## 关于 404

[http status](https://manon.icu/http-status)
[404](https://www.abstractapi.com/http-status-codes/404)

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

## 自定义 404 页面

创建`404.js`文件，并在其中定义自定义 404 页面。

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

const MyCustom404Page = (props) => {
  return (
    <div
      style={{
        marginTop: 100,
        display: 'flex',
        flexDirection: 'column',
        justifyContent: 'center',
        alignItems: 'center'
      }}
    >
      <h1>404</h1>
      <h2>
        <Link href="/" style={{color: 'blue', textDecoration: 'underline'}}>
          Go To Home Page
        </Link>
      </h2>
      <p>Sorry, the content you are looking for cuould not be found.</p>
    </div>
  )
}

export default MyCustom404Page
```

检查结果

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

## 动态渲染 404 页面

next.js 允许通过`getStaticProps`或`getServerSideProps`请求数据并自定义 404 页面。

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

const MyCustom404Page = (props) => {
  return (
    <div
      style={{
        marginTop: 100,
        display: 'flex',
        flexDirection: 'column',
        justifyContent: 'center',
        alignItems: 'center'
      }}
    >
      <h1>404 - Page Not Found</h1>
      <h2>
        <Link href="/" style={{color: 'blue', textDecoration: 'underline'}}>
          Go To Home Page
        </Link>
      </h2>
      <p>Or check out our latest news:</p>
      <hr />
      <ul>
        {posts.map((articles) => (
          <li>{/* article title and href here */}</li>
        ))}
      </ul>
    </div>
  )
}

export async function getStaticProps() {
  // Call an external API endpoint to get posts.
  const res = await fetch('YOUR_API_URL')
  const posts = await res.json()

  return {
    props: {
      posts
    },
    // Next.js will attempt to re-generate the page:
    // - When a request comes in
    // - At most once every second
    revalidate: 60
  }
}

export default MyCustom404Page
```


Next.js - Custom 404


Swift 有三种循环：

- for
- while
- repeat

## for 循环

> 用来重复执行一系列语句直到达成特定条件，如下图：

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

```swift
// 语法
for init; condition; increment{
   // do something
}

// example
let albums = ["Red", "1989", "Reputation"]
for album in albums {
    print("\(album) is on Apple Music")
}
```

## while 循环

> while 循环从计算单一条件开始。如果条件为 true，会重复运行一系列语句，直到条件变为 false。

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

```swift
// 语法
while condition{
   // do something
}
// example
var number = 1

while number <= 20 {
    print(number)
    number += 1
}

print("Ready or not, here I come!")
```

## repeat 循环

> repeat...while 循环不像 for 和 while 循环在循环体开始执行前先判断条件语句，而是在循环执行结束时判断条件是否符合。 `repeat...while无论条件是否符合，循环会执行至少一次`

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

```swift
// 语法
repeat{
   statement(s);
}while( condition );

// example
var number = 1

repeat {
    print(number)
    number += 1
} while number <= 20

print("Ready or not, here I come!")
```

## 退出循环

使用`break`退出循环语句，比如在 while 循环中：

```swift
while countDown >= 0 {
    print(countDown)

    if countDown == 4 {
        print("I'm bored. Let's go now!")
		// 当countDown等于4的时候会退出循环
        break
    }

    countDown -= 1
}
```

## 退出多重循环

在嵌套循环中，想要同时打破内循环和外循环是很常见的。举个例子，我们可以编写一些代码来计算从 1 到 10 的乘法表，如下所示:

```swift
for i in 1...10 {
    for j in 1...10 {
        let product = i * j
        print ("\(i) * \(j) is \(product)")
    }
}
```

如果需要退出这个双重循环，需要做两步，首先，给外循环加上 label:`outerLoop`

```swift
outerLoop: for i in 1...10 {
    for j in 1...10 {
        let product = i * j
        print ("\(i) * \(j) is \(product)")
    }
}
```

第二步，在内循环执行`break outerLoop`

```swift
outerLoop: for i in 1...10 {
    for j in 1...10 {
        let product = i * j
        print ("\(i) * \(j) is \(product)")

        if product == 50 {
            print("It's a bullseye!")
            break outerLoop
        }
    }
}
```

## 跳过条件 - continue

> `break`退出循环。但是，如果只想跳过当前条件，继续下一个条件，应该使用`continue`。比如如下跳过奇数：

```swift
for i in 1...10 {
    if i % 2 == 1 {
        continue
    }

    print(i)
}
```


Looping - 循环


## 创建列表

```python
names = ['Michael', 'Bob', 'Tracy']
nums = [1, 2, 3]
```

也可以使用其他方法`split()`创建

```python
line = 'Hello World!'
row = line.split(' ')
row # ['Hello', 'World!']
```

## 列表操作

```python
names.append('Adam') # 在末尾添加元素
names.insert(1, 'Jack') # 在指定位置添加元素
```

使用`+`连接两个列表

```python
s=[1,2,3]
t=[4,5,6]
s+t # [1,2,3,4,5,6]
```

列表索引从 0 开始

```python
names = ['Michael', 'Bob', 'Tracy']
names[0] # Michael
names[1] # Bob
names[-1] # Tracy
```

使用索引覆盖元素

```python
names[0] = 'Adam' # 修改第一个元素
names # ['Adam', 'Bob', 'Tracy']
```

使用`len`获取列表长度

```python
len(names) # 3
```

使用`in`判断元素是否在列表中

```python
'Adam' in names # True
'manon' in names # False
```

## 列表的循环

使用`for`循环遍历列表

```python
for name in names:
    print(name)
```

查找索引值

```python
names.index('Bob') # 1
```

## 移除元素

使用`del`或`remove`删除元素

```python
names.remove('Bob') # 删除第一个 Bob
del names[0] # 删除第一个元素
```

## 列表的排序

使用`sort`对列表进行排序

```python
s = [10, 1, 7, 3]
s.sort()                    # [1, 3, 7, 10]

# Reverse order
s = [10, 1, 7, 3]
s.sort(reverse=True)        # [10, 7, 3, 1]

# It works with any ordered data
s = ['foo', 'bar', 'spam']
s.sort()                    # ['bar', 'foo', 'spam']
```

使用`sorted`创建新的列表，不会修改原列表

```python
t = sorted(s)
```


列表（List）是 python 的基本类型

Lists - 列表


## 如何运行容器

在[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
```
