Next.js是基于React的框架，具有服务器端渲染功能。

Next.js - Use Font Awesome with Next.js


使用`WHERE`过滤`SELECT`返回行。

## 语法

```sql
SELECT select_list
FROM table_name
WHERE condition
ORDER BY sort_expression
```

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

**如果在语句中使用了列别名，就不能使用`WHERE`**

| Operator   | Description |
| ---------- | ----------- |
| =          | 等于        |
| `>`        | 大于        |
| `<`        | 小于        |
| `>=`       | 大于等于    |
| `<=`       | 小于等于    |
| `<>` or != | 不等于      |
| AND        | 逻辑与      |
| OR         | 逻辑或      |
| IN         | 包含        |
| BETWEEN    | 区间        |
| LIKE       | 相似匹配    |
| IS NULL    | 非空        |
| NOT        | 不是        |

## 示例

从示例数据库中查询

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

#### =

查询`first_name`等于`Jamie`

```sql
SELECT
	last_name,
	first_name
FROM
	customer
WHERE
	first_name = 'Jamie';
```

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

#### AND

查询`first_name`等于`Jamie`和`last_name`等于`Rice`

```sql
SELECT
	last_name,
	first_name
FROM
	customer
WHERE
	first_name = 'Jamie' AND
        last_name = 'Rice';
```

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

#### OR

查询`last_name`等于`Rodriguez`或`first_name`等于`Adam`

```sql
SELECT
	first_name,
	last_name
FROM
	customer
WHERE
	last_name = 'Rodriguez' OR
	first_name = 'Adam';
```

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

#### IN

查询包含`Ann、Anne、Annie`任何一个

```sql
SELECT
	first_name,
	last_name
FROM
	customer
WHERE
	first_name IN ('Ann','Anne','Annie');
```

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

#### LIKE

查询以`Ann`开头的`last_name`

```sql
SELECT
	first_name,
	last_name
FROM
	customer
WHERE
	first_name LIKE 'Ann%'
```

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

#### BETWEEN

查询`first_name`的长度大于等于 3 小于等于 5

```sql
SELECT
	first_name,
	LENGTH(first_name) name_length
FROM
	customer
WHERE
	first_name LIKE 'A%' AND
	LENGTH(first_name) BETWEEN 3 AND 5
ORDER BY
	name_length;
```

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

#### `<>`

查询`first_name`以`Bra`开头，而且`last_name`不等于`Motley`

```sql
SELECT
	first_name,
	last_name
FROM
	customer
WHERE
	first_name LIKE 'Bra%' AND
	last_name <> 'Motley';
```

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

`<>`和`!=`是相同的作用。


Postgresql - Where


Swift 支持多种控制流语句，包括条件语句、循环语句和控制转移语句。这些语句可以控制代码的执行流程，使程序能够根据不同的条件执行不同的代码路径。

以下是 Swift 中常用的控制流语句：

条件语句（if、else、else if）

```swift
let age = 20
if age < 18 {
  print("未成年人")
} else if age < 30 {
  print("年轻人")
} else {
  print("中年人")
}
```

循环语句（for、while、repeat-while）

```swift
// for 循环
for i in 1...5 {
  print(i)
}

// while 循环
var i = 0
while i < 5 {
  print(i)
  i += 1
}

// repeat-while 循环
i = 0
repeat {
  print(i)
  i += 1
} while i < 5
```

控制转移语句（break、continue、fallthrough、return、throw）

```swift
// break 语句
for i in 1...10 {
if i == 5 {
  break
}
print(i)
}

// continue 语句
for i in 1...10 {
if i % 2 == 0 {
  continue
}
print(i)
}

// fallthrough 语句
let score = 80
var grade = ""
switch score {
  case 0..<60:
  grade = "不及格"
  case 60..<70:
  grade = "及格"
  case 70..<80:
  grade = "中等"
  case 80..<90:
  grade = "良好"
  case 90...100:
  grade = "优秀"
  fallthrough
  default:
  print("你的成绩是 \(score)，评级是 \(grade)")
}

// return 语句
func sum(_ a: Int, _ b: Int) -> Int {
  return a + b
}

// throw 语句
enum MyError: Error {
  case error1
  case error2
}

func test() throws {
  throw MyError.error1
}
```

Swift 的控制流语句功能强大，使用灵活，可以编写出各种复杂的逻辑结构，从而满足不同的编程需求。需要根据具体的需求选择不同的控制流语句。


Swift 支持多种控制流语句，包括条件语句、循环语句和控制转移语句

Swift - 控制流


## Node.js 是什么？

Node.js 是一个用于创建网络和服务器端应用程序的跨平台环境和库，使用 JavaScript 语言编写。Node.js 基于 Google Chrome 的 V8 JavaScript 引擎，具有以下特色：

## Node.js 的特色

- `极快`：Node.js 代码执行速度非常快。
- `I/O是异步和事件驱动的`：Node.js 库的所有 API 都是异步的，即非阻塞。因此，基于 Node.js 的服务器永远不会等待 API 返回数据。服务器在调用后移动到下一个 API，Node.js 事件的通知机制有助于服务器从之前的 API 调用中获得响应。这也是它非常快的原因。
- `单线程`：Node.js 遵循带有事件循环的单线程模型。
- `高度可扩展`：Node.js 具有高度可扩展性，因为事件机制有助于服务器以非阻塞方式响应。
- `无缓冲`：Node.js 在上传音频和视频文件时缩短了整体处理时间。Node.js 应用程序从不缓冲任何数据。这些应用程序只需以块为数据输出。
- `开源`：Node.js 有一个开源社区，该社区产生了许多优秀的模块，为 Node.js 应用程序添加其他功能。
- `许可证`：Node.js 在 MIT 许可证下发布。

## Install On Windows

从 Node.js 官方网站（https://nodejs.org）下载 Windows 版本的安装包。
![lNsHpN](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/lNsHpN.jpg)

运行下载的安装包，按照向导的指示进行安装。建议选择“Custom”安装，勾选“Add to PATH”，并选择“Entire feature will be installed on local hard drive”。运行下载的安装包，按照向导的指示进行安装。建议选择“Custom”安装，勾选“Add to PATH”，并选择“Entire feature will be installed on local hard drive”。
![VZs1Rk](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/VZs1Rk.jpg)
![ojUC1D](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/ojUC1D.jpg)
![2i1T66](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/2i1T66.jpg)
![YtZQqr](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/YtZQqr.jpg)
![2Hp0BM](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/2Hp0BM.jpg)

验证安装
![hhq3GT](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/hhq3GT.jpg)

## Install On Linux、Macos

```bash
# linux
sudo yum install nodejs #centos
sudo apt-get install nodejs #ubuntu debain

# macos
brew install nodejs
```


Node.js - Intro & Install


Swift 中有三种主要的集合类型：数组、集合和字典。

## 数组（Arrays）

数组是一组有序的值的集合，可以使用下标来访问每个值。Swift 中的数组可以存储相同类型的值，也可以使用泛型来存储不同类型的值。

以下是创建和操作数组的示例：

```swift

// 创建数组
var numbers: [Int] = [1, 2, 3, 4, 5]
var strings = ["Apple", "Banana", "Orange"]

// 访问数组中的值
let firstNum = numbers[0] // 1
let lastStr = strings[strings.count - 1] // "Orange"

// 修改数组中的值
numbers[2] = 10
strings.append("Grape")

// 遍历数组中的所有值
for number in numbers {
print(number)
}
```

## 集合（Sets）

集合是一组无序的唯一值的集合。Swift 中的集合可以存储任何可哈希的值（Hashable），例如数字、字符串和布尔值等。集合中不允许存在重复的值。

以下是创建和操作集合的示例：

```swift

// 创建集合
var set1: Set<Int> = [1, 2, 3, 4, 5]
var set2: Set<String> = ["Apple", "Banana", "Orange"]

// 访问集合中的值
let hasThree = set1.contains(3) // true

// 修改集合中的值
set1.insert(6)
set2.remove("Banana")

// 遍历集合中的所有值
for element in set2 {
print(element)
}
```

## 字典（Dictionaries）

字典是一组无序的键值对的集合，每个键都唯一且与一个值相关联。Swift 中的字典可以存储任何可哈希的键（Hashable）和任何值，例如数字、字符串和布尔值等。

以下是创建和操作字典的示例：

```swift

// 创建字典
var dict1: [String: Int] = ["One": 1, "Two": 2, "Three": 3]
var dict2 = ["Red": "#FF0000", "Green": "#00FF00", "Blue": "#0000FF"]

// 访问字典中的值
let redCode = dict2["Red"] // "#FF0000"

// 修改字典中的值
dict1["One"] = 10
dict2["Yellow"] = "#FFFF00"

// 遍历字典中的所有键值对
for (key, value) in dict1 {
print("\(key): \(value)")
}
```

Swift 中的集合类型还提供了各种方法和属性，以支持常见的集合操作，例如排序、筛选、合并、查找等。如果您需要更深入地了解 Swift 中的集合类型，可以查看 Swift 官方文档中的相关章

## 元组（Tuples）

元组是将多个值组合在一起的一种方式，这些值可以是任何类型，并不要求是相同类型。元组中的每个值都可以通过名称或下标来访问。

以下是创建和操作元组的示例：

```swift

// 创建元组
let person = ("Tom", 25, true)

// 访问元组中的值
let name = person.0 // "Tom"
let age = person.1 // 25
let isMale = person.2 // true

// 创建带有标签的元组
let student = (name: "Alice", age: 20, isMale: false)

// 访问带有标签的元组中的值
let studentName = student.name // "Alice"
let studentAge = student.age // 20
let studentIsMale = student.isMale // false
```

## Range（区间）

区间是表示一定范围内值的类型。Swift 中有两种类型的区间：半开区间和闭区间。半开区间包含起始值，不包含结束值。闭区间包含起始值和结束值。

以下是创建和操作区间的示例：

```swift

// 创建区间
let range1 = 1..<5 // 半开区间，包含1，不包含5
let range2 = 1...5 // 闭区间，包含1和5

// 遍历区间中的所有值
for i in range1 {
print(i)
}

for i in range2.reversed() {
print(i)
}
```

Swift 的集合类型和区间类型提供了丰富的功能和操作，可以满足各种不同的需求。因此，在编写 Swift 代码时，选择正确的集合类型和区间类型非常重要，可以使代码更加简洁和高效。

## 字典（Dictionary）

字典是一种存储键值对的集合类型。在字典中，每个值都与一个唯一的键相关联。字典中的键必须是唯一的，并且必须是可哈希的（即可以用作字典键的类型必须符合 Hashable 协议）。

以下是创建和操作字典的示例：

```swift

// 创建字典
var scores = ["Tom": 80, "Jerry": 90, "Alice": 95]

// 添加和更新字典中的值
scores["Bob"] = 85 // 添加
scores["Tom"] = 85 // 更新

// 删除字典中的值
scores.removeValue(forKey: "Jerry")

// 遍历字典中的键值对
for (name, score) in scores {
print("\(name) scored \(score)")
}

// 获取字典中所有的键和值
let names = Array(scores.keys)
let scoresArray = Array(scores.values)
```

## 集合（Set）

集合是一种无序的、不重复的元素集合类型。集合中的每个元素必须是唯一的，并且必须是可哈希的（即可以用作集合元素的类型必须符合 Hashable 协议）。

以下是创建和操作集合的示例：

```swift

// 创建集合
var set1: Set<Int> = [1, 2, 3, 4, 5]
var set2: Set<Int> = [4, 5, 6, 7, 8]

// 集合运算
let union = set1.union(set2) // 并集
let intersection = set1.intersection(set2) // 交集
let difference = set1.symmetricDifference(set2) // 对称差集

// 添加和删除集合中的元素
set1.insert(6)
set1.remove(5)

// 遍历集合中的所有元素
for element in set1 {
print(element)
}
```

Swift 的集合类型提供了丰富的功能和操作，可以方便地对数据进行处理和操作。选择正确的集合类型可以使代码更加简洁和高效。

## 可选类型（Optional）

Swift 的可选类型是一种用于处理值缺失的类型。可选类型可以表示一个值存在或不存在。如果一个值存在，可选类型就包含这个值；如果一个值不存在，可选类型就是 nil。

以下是创建和操作可选类型的示例：

```swift

// 创建可选类型
var name: String? = "Tom"

// 访问可选类型中的值
if let unwrappedName = name {
print("Name is \(unwrappedName)")
} else {
print("Name is nil")
}

// 强制解包可选类型中的值
let unwrappedName2 = name!
print("Name is \(unwrappedName2)")

// 可选绑定
if let name = name {
print("Name is \(name)")
} else {
print("Name is nil")
}

// nil 合并运算符
let defaultName = "John"
let finalName = name ?? defaultName
print("Name is \(finalName)")
```

可选类型在 Swift 中经常使用，因为它可以很好地处理值缺失的情况。如果不使用可选类型，代码会变得非常冗长和复杂。因此，在 Swift 中，使用可选类型来处理值缺失的情况是一种很好的实践。


Swift中的集合类型（Collection Types）是一组相同类型的值的集合，可以使用这些集合类型来存储和操作数据

Swift - 集合类型


泛型（Generics）是 Swift 中一项非常强大的功能，它允许您编写灵活、可重用的函数和类型，可以在任何数据类型上进行工作。

使用泛型，您可以定义一组通用的操作，而不必在每种数据类型上编写单独的函数或方法。这使得代码更加灵活、可读性更高、易于维护，并提高了代码的重用性。

以下是一些基本概念：

## 泛型函数

泛型函数是可以在不同数据类型之间共享的函数。这些函数在调用时可以指定要使用的数据类型。在 Swift 中，泛型函数可以接受任何类型的参数，包括整数、浮点数、字符串和自定义类型。

下面是一个简单的泛型函数示例：

```swift
func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
  let temp = a
  a = b
  b = temp
}
```

在这个例子中，我们定义了一个函数 swapTwoValues，它接受两个参数 a 和 b，它们都是泛型类型 T。函数体内使用了一个临时变量 temp，来交换 a 和 b 的值。

这个函数中的 \<T> 声明了一个类型参数 T，用来指定函数参数的类型。调用函数时，可以将具体的数据类型作为参数传入：

```swift
var a = 10
var b = 20
swapTwoValues(&a, &b) // a is now 20, and b is now 10
```

在这个示例中，我们将 a 和 b 作为参数传递给 swapTwoValues 函数，并通过引用传递（使用 & 符号）将它们作为可变参数传递。函数交换了 a 和 b 的值，所以现在 a 的值为 20，b 的值为 10。

## 泛型类型

泛型类型是可以用于多个不同类型的类型。使用泛型类型，可以编写通用代码，而不必为每个特定类型编写单独的代码。在 Swift 中，可以使用类、结构体和枚举来定义泛型类型。

下面是一个简单的泛型结构体示例：

```swift
struct Stack<Element> {
var items = [Element]()

    mutating func push(_ item: Element) {
        items.append(item)
    }

    mutating func pop() -> Element? {
        return items.popLast()
    }
}
```

在这个例子中，我们定义了一个泛型结构体 Stack，它可以用于存储任意类型的元素。该结构体包含一个数组 items，用于存储元素。结构体还包含两个方法，用于将元素添加到堆栈中和从堆栈中删除元素。

可以在创建 Stack 实例时，使用类型参数 `Element

当我们编写代码时，我们经常需要同时处理多个不同类型的值，这些类型的值可能会在未来的某个时候发生变化。使用泛型可以让我们编写出灵活的代码，可以在编译时进行类型检查，同时可以在运行时自动适应类型。

Swift 中的泛型允许我们定义通用类型和函数，可以适用于各种数据类型。这使我们可以写出更加通用和重用的代码。

在 Swift 中，我们可以通过在类型、函数或方法名称后面使用尖括号（\<>）和一个或多个占位符来声明泛型。这些占位符可以用于指定类型参数，这些参数在调用函数或实例化类型时将被替换为实际类型。

以下是一个使用泛型的示例：

```swift
func swapValues<T>(_ a: inout T, _ b: inout T) {
  let temp = a
  a = b
  b = temp
}

var x = 10
var y = 20

swapValues(&x, &y) // x is now 20, y is now 10
```

在这个例子中，我们定义了一个函数 swapValues，它使用了一个类型参数 T。在函数体内，我们声明了一个名为 temp 的临时变量，然后交换了 a 和 b 的值。由于 a 和 b 都是 inout 参数，因此它们将被修改为新的值。

我们可以使用这个函数来交换任何两个相同类型的值，例如整数、浮点数、字符串、数组等等。在调用这个函数时，我们需要提供两个相同类型的值作为参数。

泛型在 Swift 中是非常强大和灵活的，它们可以帮助我们写出高效、可维护和可重用的代码。


使用泛型，您可以定义一组通用的操作，而不必在每种数据类型上编写单独的函数或方法。这使得代码更加灵活、可读性更高、易于维护，并提高了代码的重用性。

Swift - 泛型


> `useRef` 返回一个可变的 `ref` 对象，其 `.current` 属性被初始化为传入的参数（initialValue），返回的 `ref` 对象在组件的整个生命周期内保持不变。

例如：创建`VideoPlayer`组件

```tsx
import {useRef} from 'react'
import VideoPlayer from 'videoplayer'

function VideoPlayerComponent() {
  const playerRef = useRef(new VideoPlayer())
  //
}
```

对于上面的代码，在初始化组件时，调用`new VideoPlayer()`的结果将存储在`ref`中，在下一次渲染时，仍将调用`new VideoPlayer()`，但是`useef`不会再接收到其调用结果，这意味着`playerRef`可能为空。

同样的，`useState`也是存在这种情况，区别在于，`useState`可以接受初始化函数，比如

```tsx
import {useState} from 'react'
import VideoPlayer from 'videoplayer'
function VideoPlayerComponent() {
  const [player] = useState(() => new VideoPlayer())
  //
}
```

所以，在使用`playerRef`的时候，需要对它做个判断：

```tsx
import {useRef} from 'react'
import VideoPlayer from 'videoplayer'

function VideoPlayerComponent() {
  const playerRef = useRef<VideoPlayer | null>(null)

  if (playerRef.current === null) {
    playerRef.current = new VideoPlayer()
  }

  const onClick = () => {
    // Error: Object is possibly 'null'.
    playerRef.current.play()
  }
}
```

组件只会调用一次`new VideoPlayer()`并存储在`playerRef`中，但是 typescript 会检查并提示`Error: Object is possibly 'null'`

解决方法：

operation chaining - 可选链

`playerRef.current.play()` => `playerRef.current？.play()`

useImmutableRefValue

```tsx
import {useMemo, useRef} from 'react'

const useImmutableRefValue = <R,>(createRef: () => R) => {
  const ref = useRef<R>()

  const value = useMemo(() => {
    if (!ref.current) {
      ref.current = createRef()
    }

    return ref.current
    // Only one instance, no deps required.
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [])

  return value
}

export default useImmutableRefValue
```

```tsx
import VideoPlayer from 'videoplayer'
import useImmutableRefValue from 'useImmutableRefValue'

function Component() {
  const player = useImmutableRefValue(() => new VideoPlayer())

  const onClick = () => {
    player.play()
  }
}
```


useRef 返回一个可变的 ref 对象，其 .current 属性被初始化为传入的参数（initialValue），返回的 ref 对象在组件的整个生命周期内保持不变。