可选是一个枚举类型，它可以是一个值或者空。类似于js的optional chaining

Optionals - 可选


**traceroute**命令用于显示数据包到主机之间的路径。

> raceroute 命令 用于追踪数据包在网络上的传输时的全部路径，它默认发送的数据包大小是 40 字节。
>
> 通过 traceroute 我们可以知道信息从你的计算机到互联网另一端的主机是走的什么路径。当然每次数据包由某一同样的出发点（source）到达某一同样的目的地(destination)走的路径可能会不一样，但基本上来说大部分时候所走的路由是相同的。
>
> traceroute 通过发送小的数据包到目的设备直到其返回，来测量其需要多长时间。一条路径上的每个设备 traceroute 要测 3 次。输出结果中包括每次测试的时间(ms)和设备的名称（如有的话）及其 ip 地址。

## 使用方法

```bash
traceroute <host>
```

## 案例

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

## 参数

- `-d` 使用 Socket 层级的排错功能。
- `-f` 存活数值 设置第一个检测数据包的存活数值 TTL 的大小。
- `-F` 设置勿离断位。
- `-g` 网关 设置来源路由网关，最多可设置 8 个。
- `-i` 网络界面 使用指定的网络界面送出数据包。
- `-I` 使用 ICMP 回应取代 UDP 资料信息。
- `-m` 存活数值 设置检测数据包的最大存活数值 TTL 的大小。
- `-n` 直接使用 IP 地址而非主机名称。
- `-p` 通信端口 设置 UDP 传输协议的通信端口。
- `-r` 忽略普通的 Routing Table，直接将数据包送到远端主机上。
- `-s` 来源地址 设置本地主机送出数据包的 IP 地址。
- `-t` 服务类型 设置检测数据包的 TOS 数值。
- `-v` 详细显示指令的执行过程。
- `-w` 超时秒数 设置等待远端主机回报的时间。
- `-x` 开启或关闭数据包的正确性检验。

**traceroute**命令可在 Linux、macOS、WSL 和任何 UNIX 环境下运行


traceroute命令用于显示数据包到主机之间的路径

Linux命令traceroute


`LIMIT`限制`SELECT`返回数据行数。

## 语法

```sql
SELECT select_list
FROM table_name
ORDER BY sort_expression
LIMIT row_count
```

`row_count`为返回行数，当为 0 时，返回空。

如果需要忽略或偏移某些行数，使用`OFFSET`。

```sql
SELECT select_list
FROM table_name
LIMIT row_count OFFSET row_to_skip;
```

## 示例

使用示例数据库中`film`表进行`LIMIT`示例查询

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

#### 显示返回特定行数

```sql
SELECT
	film_id,
	title,
	release_year
FROM
	film
ORDER BY
	film_id
LIMIT 5;
```

限定返回 5 行，结果如下：

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

#### 偏移行数

查询并返回 4 行，从第四行开始

```sql
SELECT
	film_id,
	title,
	release_year
FROM
	film
ORDER BY
	film_id
LIMIT 4 OFFSET 3;
```

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

#### 使用`LIMIT`、`OFFSET`获取顶部、底部特定行

比如，获取前 10 部最昂贵的电影，按照租金率降序排序

```sql
SELECT
	film_id,
	title,
	rental_rate
FROM
	film
ORDER BY
	rental_rate DESC
LIMIT 10;
```

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


Postgresql - LIMIT


## 创建类

`Class`和`Struct`类似，但是类可以继承其他类，并且类可以定义属性和方法。

```swift
class Dog {
    var name: String
    var breed: String

    init(name: String, breed: String) {
        self.name = name
        self.breed = breed
    }

    func bark() {
        print("Woof!")
    }
}

#创建实例
let poppy = Dog(name: "Poppy", breed: "Poodle")
```

## 类继承

和`Struct`不同的是，`Class`可以继承其他类。

```swift
class Poodle: Dog {
    init(name: String) {
        super.init(name: name, breed: "Poodle")
    }
}

super.init(name: name, breed: "Poodle") // 调用父类的构造器
```

## 方法重写

类创建的实例可以重写父类的方法。

```swift
class Dog {
    func bark() {
        print("Woof!")
    }
}

let poppy = Dog()
poppy.bark()

# 类继承重写方法
class Poodle: Dog {
    override func bark() {
        print("Yip!")
    }
}
```

## final 类

`Swift`提供关键词`final`来防止类被继承。

```swift
fina class Dog {
    func bark() {
        print("Woof!")
    }
}
```

## 复制 objects

与`Struct`不同的是，`Class`可以被复制。

```swift
class Dog {
    var name: String
    var breed: String

    init(name: String, breed: String) {
        self.name = name
        self.breed = breed
    }

    func bark() {
        print("Woof!")
    }
}
var poppy = Dog(name: "Poppy", breed: "Poodle")
var poppyCopy = poppy
poppyCopy.name = "Poppy Copy"
```

## 反初始化

与`Struct`不同的是，`Class`可以被反初始化。

```swift
class Person {
    var name: String

    init(name: String) {
        self.name = name
    }

    func sayHello() {
        print("Hello, \(name)!")
    }
}
```

在循环中创建实例，可以使用`deinit`来定义反初始化方法。

```swift
for _ in 1...10 {
    let person = Person(name: "John")
    person.sayHello()
}

deinit {
    print("Goodbye, \(name)!")
}
```

## 可变性

类与结构在常量的处理方式上有所不同。如果一个类或结构体的实例被声明为常量，则该实例的所有属性也必须是常量。

```swift
class Person {
    var name = "Taylor Swift"
}
let person = Person()
person.name = "Justin Bieber"
print(person.name) // Justin Bieber

# 如果将类或结构体实例设置为常量，则不能修改实例的属性。
class Person {
    let name = "Taylor Swift"
}
```

## 总结

- `Class`和`Struct`是相似的，都可以使用属性和方法创建。
- 类可以继承其他类，并获得父类的所有属性和方法。
- 使用`final`来防止类被继承。
- 可以重写父类的方法。
- 当不同变量指向同一个类实例，它们指向的是同一块内存，改变一个会改变另一个
- 可以被反初始化。
- 类的属性可以被声明为可变的，但是不能被声明为常量。


Swift 类是构建代码所用的一种通用且灵活的构造体。

Classes - 类


[//]: # (https://www.freecodecamp.org/news/set-and-map-in-javascript/)
## Sets

`Sets`对象是值的集合，它不允许重复的值，并且是无序的。

```js
// 创建 Set 对象
const emptySet = new Set()
// 添加元素到 Set 对象
emptySet.add('red').add('green').add('blue')
// 移除元素
emptySet.delete('red')
// 检查是否包含某个值
emptySet.has('green') // true
// 清除所有元素
emptySet.clear()
// 迭代 Set 对象
for (let item of emptySet) {
  console.log(item) // 'green', 'blue'
}
// 将 Set 对象转换为数组
;[...emptySet] // ['green', 'blue']
Array.from(emptySet) // ['green', 'blue']
```

去重

```js
Array.from(new Set(['red', 'green', 'blue', 'red', 'green', 'blue'])) // ['red', 'green', 'blue']
```

创建一组 Unicode 字符

```js
new Set('abc')
new Set(['a', 'b', 'c'])
assert.deepEqual(new Set('abc'), new Set(['a', 'b', 'c'])) // true
```

与映射键一样，`Set`元素与===进行比较，唯一不同的是`NaN`等于自身，但是`object`不等于自身。

```js
const set = new Set([NaN, NaN, NaN]) // Set { NaN }
set.size // 1
set.has(NaN) // true

const set2 = new Set()
set2.add({})
set2.size === 1 // true
set2.add({})
set2.size === 2 // true
```

合并两个 Set

> 计算两个集合 a 和 b 的并集意味着创建一个包含 a 和 b 元素的集合。

```js
const a = new Set([1, 2, 3]) // Set { 1, 2, 3 }
const b = new Set([4, 3, 2]) // Set { 2, 3, 4 }
const union = new Set([...a, ...b]) // Set { 1, 2, 3, 4 }
```

Set 的交集

> 计算两个集合 a 和 b 的交集意味着创建一个集合，其中包含 a 中也在 b 中的元素。

```js
const a = new Set([1, 2, 3]) // Set { 1, 2, 3 }
const b = new Set([4, 3, 2]) // Set { 2, 3, 4 }
const intersection = new Set(Array.from(a).filter((x) => b.has(x))) // Set { 2, 3 }
```

Set 的差集

> 计算两个集合 a 和 b 之间的差意味着创建一个集合，其中包含不在 b 中的 a 元素。此操作有时也称为减号(−).

```js
const a = new Set([1, 2, 3]) // Set { 1, 2, 3 }
const b = new Set([4, 3, 2]) // Set { 2, 3, 4 }
const difference = new Set(Array.from(a).filter((x) => !b.has(x))) // Set { 1 }
```

遍历 Set

> Set 没有 map 方法

```js
const set = new Set([1, 2, 3]) // Set { 1, 2, 3 }
const mappedSet = new Set(Array.from(set).map((x) => x * 2)) // Set { 2, 4, 6 }
```

过滤 Set

> Set 没有 filter 方法

```js
const set = new Set([1, 2, 3, 4, 5]) // Set { 1, 2, 3, 4, 5 }
const filteredSet = new Set(
  Array.from(set).filter((x) => x % 2 === 0) // Set { 2, 4 }
)
```

## Maps

`Map` 对象保存键值对，并且能够记住键的原始插入顺序。任何值(对象或者原始值) 都可以作为一个键或一个值。

一个 `Map` 对象在迭代时会根据对象中元素的插入顺序来进行 — 一个 `for...of` 循环在每次迭代后会返回一个形式为`[key，value]`的数组。

创建 `Map` 对象

```js
const emptyMap = new Map() // Map {}
emptyMap.size === 0 // true

// 添加键值对
emptyMap.set('foo', 'bar') // Map { 'foo' => 'bar' }

// 复制一个 Map 对象
const copy = new Map(emptyMap) // Map { 'foo' => 'bar' }

//获取键值对
emptyMap.get('foo') // 'bar'

//判断是否存在某个键
emptyMap.has('foo') // true

// 删除键值对
emptyMap.delete('foo') // true
emptyMap.has('foo') // false

// 获取Map对象大小
emptyMap.size // 0

// 删除所有键值对
emptyMap.clear() // Map {}
```

遍历 `Map`

```js
const map = new Map().set(false, 'no').set(true, 'yes') // Map { false => 'no', true => 'yes' }
for (const key of map.keys()) {
  console.log(key) // false, true
}
```

`entries()` 方法返回一个新的包含 `[key, value]` 对的 Iterator 对象，返回的迭代器的迭代顺序与 `Map` 对象的插入顺序相同。

```js
const map = new Map().set(false, 'no').set(true, 'yes') // Map { false => 'no', true => 'yes' }
for (const entry of map.entries()) {
  console.log(entry) // [false, 'no'], [true, 'yes']
}
```

`keys()` 返回一个引用的 `Iterator` 对象。它包含按照顺序插入 `Map` 对象中每个元素的 key 值。

```js
const map = new Map([
  ['a', 1],
  ['b', 2]
])
map.keys() // MapIterator { 'a', 'b' }
```

`values()` 方法返回一个新的 `Iterator` 对象。它包含按顺序插入 `Map` 对象中每个元素的 `value` 值。

```js
const map = new Map([
  ['a', 1],
  ['b', 2]
])
map.values() // MapIterator { 1, 2 }
```

合并两个 `Map` 对象

```js
const map1 = new Map().set(1, '1a').set(2, '1b').set(3, '1c') // Map { 1 => '1a', 2 => '1b', 3 => '1c' }
const map2 = new Map().set(2, '2b').set(3, '2c').set(4, '2d') // Map { 2 => '2b', 3 => '2c', 4 => '2d' }
const map3 = new Map(map1).set(4, '2d') // Map { 1 => '1a', 2 => '2b', 3 => '2c', 4 => '2d' }
```


Sets对象允许存储唯一的值，而Map对象允许存储键值对。

Sets & Maps


react 使用`.map`遍历并显示列表组件。

```jsx
function SoccerPlayers() {
  const players = ['Messi', 'Ronaldo', 'Laspada']

  return (
    <div>
      {players.map((playerName) => (
        <SoccerPlayer key={playerName} name={playerName} />
      ))}
    </div>
  )
}
```

遍历输出的组件中`key`是必需的，因为它是用来唯一标识组件的。


React是一个JavaScript库，致力于使UI开发变得简单

React Lists


`pages/api` 目录下的任何文件都将作为 `API` 端点映射到 `/api/*`，而不是 `page`。这些文件只会增加服务端文件包的体积，而不会增加客户端文件包的大小。

`Next.js`中创建 rest api 的方式如下：

```jsx
export default (req, res) => {
  console.log(req, res)
  return {}
}
```

- req: 请求对象，http.IncomingMessage 实例
- res: 响应对象，http.ServerResponse 实例

## 响应

- `res.status(code)`：设置响应状态码
- `res.json(data)`：设置响应数据
- `res.send(data)`：设置响应数据
- `res.redirect(url)`：重定向

创建一个响应：

```jsx
export default function handler(req, res) {
  res.status(200).json({message: 'Hello from Next.js!'})
}
```

## 创建路由

创建一个简单的 rest api

```jsx
export default (req, res) => {
  res.statusCode = 200
  res.setHeader('Content-Type', 'application/json')
  res.json({
    message: 'Hello World'
  })
}
```

创建动态 API 路由：`pages/api/post/[pid].js`

```jsx
export default function handler(req, res) {
  const {pid} = req.query
  res.end(`Post: ${pid}`)
}
```

创建匹配所有路由：`pages/api/post/[...slug].js`

```jsx
export default function handler(req, res) {
  const {slug} = req.query
  res.end(`Post: ${slug.join(', ')}`)
}
```

启动服务：

```bash
npm run dev
```

验证结果：

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