Next.js - Pre-Rendering


使用 `Postgresql IN` 检索查询是否与列表中的任何值相匹配。

## 语法

```sql
value IN (value1, value2, ...)
```

如果匹配，则返回 `TRUE`，否则返回 `FALSE`。

```sql
value IN (SELECT column_name FROM table_name)
```

## 示例

```sql
SELECT customer_id,
	rental_id,
	return_date
FROM
	rental
WHERE
	customer_id IN (1, 2)
ORDER BY
	return_date DESC;
```

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

以上代码用`=`和`OR`可以这样写

```sql
SELECT customer_id,
  rental_id,
  return_date
FROM
  rental
WHERE
  customer_id = 1 OR customer_id = 2
ORDER BY
  return_date DESC;
```

使用`IN`运算符的查询比使用`=`和`OR`运算符的查询更快，更具可读性。

## NOT IN

查询返回的结果不包含列表中的任何值。

```sql
SELECT customer_id,
  rental_id,
  return_date
FROM
  rental
WHERE
  customer_id NOT IN (1, 2)
```

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

同样以上代码可以使用`<>`和`AND`运算符

```sql
SELECT customer_id
FROM rental
WHERE CAST (return_date AS DATE) = '2005-05-27'
ORDER BY customer_id;
```

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

```sql
SELECT
	customer_id,
	first_name,
	last_name
FROM
	customer
WHERE
	customer_id IN (
		SELECT customer_id
		FROM rental
		WHERE CAST (return_date AS DATE) = '2005-05-27'
	)
ORDER BY customer_id;
```

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


使用 Postgresql IN 检索查询是否与列表中的任何值相匹配。

Postgresql - IN


> 作用域是管理变量可用性的一个重要概念。作用域在基本闭包处，定义了全局变量和局部变量的概念。

## 作用域 - The Scope

在深入理解作用域之前，先通过一个简单的例子看看是如何工作的。

```js
const message = 'hello'
console.log(message) // hello
```

你可以轻松访问`message`变量。

如果将`message`变量放在`if`语句内，比如：

```js
if (true) {
  const message = 'hello'
}
console.log(message) // ReferenceError: message is not defined
```

为什么？

`if` 代码块为消息变量创建一个作用域，而消息变量只能在这个作用域内访问。

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

在更高的级别上，变量的可访问性受到它们被创建的作用域的限制。您可以自由访问在其作用域内定义的变量。但是在它的作用域之外，变量是不可访问的。

## 块级作用域 - Block Scope

```js
if (true) {
  // if 块级作用域
  const message = 'hello'
  console.log(message) // hello
}
console.log(message) // ReferenceError: message is not defined
```

第一个`console.log`输出`hello`，因为`message`变量在`if`块级作用域内。

第二个`console.log`输出`ReferenceError: message is not defined`，因为`message`变量在`if`块级作用域之外。

`if`、`for`、`while`、`do`、`switch`、`with`、`function` 以及`catch`创建块级作用域。比如：

```js
for (const color of ['green', 'red', 'blue']) {
  // "for" block scope
  const message = 'Hi';
  console.log(color);   // 'green', 'red', 'blue'
  console.log(message); // 'Hi', 'Hi', 'Hi'
}
console.log(color);   // throws ReferenceError
console.log(message); // throws ReferenceError

while (/* condition */) {
  // "while" block scope
  const message = 'Hi';
  console.log(message); // 'Hi'
}
console.log(message); // => throws ReferenceError
```

### `var` 不是块级作用域

`var` 关键字不是块级作用域。比如：

```js
if (true) {
  // "if" block scope
  var count = 0
  console.log(count) // 0
}
console.log(count) // 0
```

使用`var`定义的变量，会产生变量提升，即变量会在它们被访问之前被创建。在除`function`外的所有块级作用域中，`var` 关键字都是不可访问的。

## 函数作用域 - Function Scope

```js
function run() {
  // "run" function scope
  var message = 'Run Forrest, run!'
  console.log(message) // Run Forrest, run!
}
run()
console.log(message) // ReferenceError: message is not defined
```

`run()`函数定义了一个块级作用域，它包含了`message`变量，`message`变量可以在`run()`函数内访问，但是不能在`run()`函数之外访问。

同样`let`和`const`也是块级作用域。可以在`run()`函数内访问， 但是不能在`run()`函数之外访问。

```js
function run() {
  // "run" function scope
  const two = 2
  let count = 0
  function run2() {}
  console.log(two) // 2
  console.log(count) // 0
  console.log(run2) // function
}
run()
console.log(two) // throws ReferenceError
console.log(count) // throws ReferenceError
console.log(run2) // throws ReferenceError
```

## 模块作用域 - Module Scope

ES2015 同样支持模块作用域。模块作用域是一个特殊的块级作用域，它可以在模块内部访问，但是不能在模块之外访问。

```js
// circle.js
const PI = 3.14
console.log(pi) // 3.14
```

`circle.js`模块定义了一个块级作用域，它包含了`PI`变量。但是未导出`PI`变量，因此不能在模块之外访问。

```js
import './circle'
consoel.log(pi) // throws ReferenceError
```

## 嵌套作用域 - Scopes can be nested

作用域可以嵌套。比如：

```js
function run() {
  // "run" function scope
  const message = 'Run, Forrest, Run!'
  if (true) {
    // "if" code block scope
    const friend = 'Bubba'
    console.log(message) // 'Run, Forrest, Run!'
  }
  console.log(friend) // throws ReferenceError
}
run()
```

`if`代码块作用域嵌套在`run()`函数作用域内。`if`代码块作用域内部可以访问`message`变量，但是不能`if`外部访问`friend`变量。

![Scopes can be nested](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/yE2fSE.jpg)

## 全局作用域 - Global Scope

全局作用域是一个特殊的作用域，它可以在整个程序的所有位置访问。`<script>`标签内的代码块是全局作用域。

```js
;<script src="myScript.js"></script>

// myScript.js
// 全局作用域
let counter = 1
```

在前面的代码片段中，`counter` 是一个全局变量。这个变量可以从网页的 JavaScript 的任何地方访问。

全局作用域是一种机制，它允许 JavaScript 的主机(浏览器、节点)为应用程序提供特定于主机的函数作为全局变量。

例如，`window` 和 `document` 是浏览器提供的全局变量。在 `Node` 环境中，可以将进程对象作为全局变量访问。

## 词法作用域 - Lexical Scope

定义两个函数，将函数`innerFunc`嵌套在函数`outerFunc`内部。

```js
function outerFunc() {
  // the outer scope
  let outerVar = 'I am from outside!'
  function innerFunc() {
    // the inner scope
    console.log(outerVar) // 'I am from outside!'
  }
  return innerFunc
}
const inner = outerFunc()
inner()
```

`inner()`函数执行时，`innerFunc()`函数定义了一个块级作用域，它包含了`outerVar`变量。

实际上是执行了`outerFunc`函数内的`innerFunc()`函数。`outerFunc`函数返回函数，形成了一个闭包。

所以`outerFunc`外部可以访问`innerFunc()`内部的`outerVar`变量。

## 变量隔离 - Variables isolation

您可以在不同的作用域中重用公共变量名(`count`、`index`、`current`、`value`、etc) ，而不会发生冲突。

`foo()`和`bar()`函数作用域有它们自己的。

```js
function foo() {
  // "foo" function scope
  let count = 0
  console.log(count) // 0
}
function bar() {
  // "bar" function scope
  let count = 1
  console.log(count) // 1
}
foo()
bar()
```


作用域


**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


内存安全是编程语言中的一个重要概念，它指的是在程序执行过程中，确保所有内存访问都是合法的、有效的，不会导致内存泄漏、访问未初始化的内存或非法访问其他应用程序的内存等问题。Swift 是一种内存安全的语言，它通过一系列的机制来确保内存访问的安全性。

Swift 中的内存安全机制主要包括以下几个方面：

- ARC（Automatic Reference Counting，自动引用计数）：ARC 是一种自动内存管理机制，它通过对对象引用计数的跟踪来管理内存。当一个对象没有任何引用时，ARC 会自动释放这个对象所占用的内存。
- 可选类型：Swift 中的可选类型可以表示一个值存在或者不存在的状态，它可以避免空指针异常等问题。在 Swift 中，如果一个可选类型没有明确赋值，那么它的值默认为 nil。
- 访问控制：Swift 提供了访问控制机制，可以限制对某些代码的访问权限，从而防止未经授权的访问。
- 内存访问检查：Swift 对数组、字典、字符串等常用类型的访问进行了检查，避免了越界访问等问题。
- copy-on-write 语义：Swift 中的某些类型，比如数组和字典，采用了 copy-on-write 语义。当这些类型的值被复制时，实际上并不会立即进行复制，而是共享同一块内存空间。只有在其中一个值被修改时，才会进行实际的复制操作，从而避免了不必要的内存开销。

通过以上这些机制，Swift 可以保证程序在运行过程中不会出现内存泄漏、空指针异常等问题，从而提高了程序的可靠性和稳定性。


内存安全是编程语言中的一个重要概念，它指的是在程序执行过程中，确保所有内存访问都是合法的、有效的，不会导致内存泄漏、访问未初始化的内存或非法访问其他应用程序的内存等问题。Swift 是一种内存安全的语言，它通过一系列的机制来确保内存访问的安全性。

Swift - 内存安全


在 CSS 中，有多种不同的 sizing units（尺寸单位）可以用来定义元素的尺寸和位置，下面是一些常见的 sizing units：

- px（像素）：像素是 CSS 中最常用的尺寸单位之一，它指的是屏幕上的一个物理像素。因为像素是一个固定的尺寸，所以使用像素定义元素的大小可以确保它们在不同的设备上显示一致。
- %（百分比）：百分比单位是相对于父元素的大小来定义元素的尺寸。例如，如果一个元素的宽度设置为 50%，那么它的宽度将会是其父元素宽度的一半。
- em（字号）：em 是相对于元素的字体大小来定义尺寸的单位。例如，如果一个元素的字体大小为 16px，那么 1em 将等于 16px。
- rem（根字号）：rem 也是相对于字体大小来定义尺寸的单位，但是它是相对于根元素的字体大小来计算的。例如，如果根元素的字体大小为 16px，那么 1rem 将等于 16px。
- vw/vh（视窗宽度/高度）：vw 和 vh 是相对于视口宽度和高度来定义尺寸的单位。例如，如果一个元素的宽度设置为 50vw，那么它的宽度将会是视口宽度的一半。
- vmin/vmax（视口宽度/高度的较小或较大值）：vmin 和 vmax 也是相对于视口宽度和高度来定义尺寸的单位。vmin 指的是视口宽度和高度中较小的值，而 vmax 则指的是较大的值。

除了以上列举的 sizing units，CSS 还有一些其他的尺寸单位，如 pt（磅）、pc（派卡）等，但它们在网页设计中使用较少。需要注意的是，不同的 sizing units 适用于不同的场景，根据具体需求选择合适的尺寸单位来定义元素的尺寸和位置是非常重要的。

## 案例

以下是使用不同 sizing units 的 CSS 示例：

1. px（像素）

```css
div {
  width: 200px;
  height: 150px;
  font-size: 16px;
}
```

2. %（百分比）

```css
.parent {
  width: 500px;
  height: 300px;
}

.child {
  width: 50%;
  height: 50%;
}
```

3. em（字号）

```css
.parent {
  font-size: 16px;
}

.child {
  width: 10em;
  height: 5em;
}
```

4. rem（根字号）

```css
html {
  font-size: 16px;
}

.child {
  width: 20rem;
  height: 10rem;
}
```

5. vw/vh（视窗宽度/高度）

```css
.child {
  width: 50vw;
  height: 25vh;
}
```

6. vmin/vmax（视口宽度/高度的较小或较大值）

```css
.child {
  width: 50vmin;
  height: 50vmax;
}
```


css - 尺寸单位


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