在 Postgresql 中，FULL OUTER JOIN 是一种结合左外连接和右外连接结果的连接类型

Postgresql - FULL OUTER JOIN


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

JavaScript 是一种单线程的语言，意味着它只有一个调用栈和一个执行线程。当 JavaScript 执行一段代码时，它会按照代码的顺序将函数调用和表达式求值添加到调用栈中。调用栈是一种后进先出（LIFO）的数据结构，它保证了当前执行的代码是最后被添加到栈中的。

当 JavaScript 遇到异步代码时，它会将异步代码添加到任务队列中并继续执行后续代码。任务队列是一种先进先出（FIFO）的数据结构，它保证了先添加到队列中的任务会先被执行。

JavaScript 中的异步代码包括定时器、事件监听器、网络请求等。当这些异步操作完成时，它们会将回调函数添加到任务队列中。

当调用栈为空时，事件循环将从任务队列中取出一个任务并将其添加到调用栈中执行。当任务执行完成后，调用栈将被弹出，并且事件循环将继续从任务队列中取出下一个任务，直到任务队列为空。

在事件循环中，微任务队列是一种特殊类型的任务队列，它优先级高于任务队列。当任务队列中存在微任务时，事件循环将优先执行微任务队列中的任务，直到微任务队列为空。微任务包括 Promise 的回调函数和一些 DOM 操作的回调函数等。

当事件循环执行微任务时，它会一直执行微任务队列中的所有任务，直到微任务队列为空。然后它会继续从任务队列中取出下一个任务并执行，直到任务队列和微任务队列都为空。

事件循环包括以下几个主要概念：

- 调用栈（Call Stack）：调用栈是一种数据结构，它用于存储当前正在执行的函数调用的上下文信息。当一个函数被调用时，它的上下文信息被压入调用栈中，当函数执行完成时，它的上下文信息被从调用栈中弹出。
- 任务队列（Task Queue）：任务队列是一个队列，它用于存储待执行的任务。当一个任务被添加到任务队列中时，它会等待事件循环将它取出并执行。
- 事件循环（Event Loop）：事件循环是一个持续的过程，它不断地从任务队列中取出任务并执行它们。当调用栈为空时，事件循环将从任务队列中取出一个任务并将其压入调用栈中执行。
- 微任务队列（Microtask Queue）：微任务队列是一个队列，它用于存储微任务。微任务是一种特殊类型的任务，它会在当前任务执行完成后立即执行。微任务队列的优先级高于任务队列，这意味着当有微任务时，事件循环将先执行微任务队列中的所有任务，然后再执行任务队列中的任务。

事件循环的执行顺序如下：

- 当代码开始执行时，所有同步代码都会被按顺序添加到调用栈中执行。
- 如果遇到异步代码（例如定时器或事件监听器），则会将其添加到任务队列中并继续执行后续代码。
- 当调用栈为空时，事件循环将从任务队列中取出一个任务并将其压入调用栈中执行。
- 如果任务队列中有微任务，则事件循环将优先执行微任务队列中的所有任务，直到微任务队列为空。
- 重复执行步骤 3 和步骤 4，直到任务队列和微任务队列都为空


事件循环是每个前端开发必须理解的概念

事件循环


SwiftUI 的一个重要特性是它如何与 Xcode 预览集成，这使您可以在处理用户界面时看到实时的用户界面代码。预览提供了一种快速有效的方法来开发和迭代应用程序的 UI 设计。

可以通过使用画布窗口中的控件或直接在 Xcode 编辑器中编辑代码来操作预览。在对代码进行更改时，预览将实时更新，使您能够看到这些更改如何影响 UI 的外观。

下面是一个如何在 SwiftUI 中使用预览的例子:

```swift
import SwiftUI

struct ContentView: View {
  var body: some View {
    VStack {
      Text("Hello, SwiftUI!")
        .padding()
      Button(action: {
        print("Button tapped!")
      }) {
        Text("Tap me!")
      }
    }
  }
}

struct ContentView_Previews: PreviewProvider {
  static var previews: some View {
    ContentView()
      .previewDevice("iPhone 14 Pro")
  }
}
```

在本例中，我们有一个简单的 `VStack`，它包含一个 `Text` 视图和一个 `Button` 视图。`ContentView_Previews` 结构负责生成实时预览。

当你在 `Xcode` 运行这个程序并显示预览时，你会看到你的用户界面显示在 `iPhone14 Pro` 上。然后，可以通过修改代码或使用预览窗口中的工具实时操作此视图。

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

除了在不同的设备上预览 UI 之外，你还可以设置不同的预览配置，比如明暗外观、方向、可访问性设置等等。例如，可以将 `ContentView_Previews` 替换为以下内容:

```swift
struct ContentView_Previews: PreviewProvider {
  static var previews: some View {
    ContentView()
      .previewDevice("iPhone 14 Pro")
    ContentView()
      .preferredColorScheme(.dark)
    ContentView()
      .previewInterfaceOrientation(.landscapeLeft)
  }
}
```

现在可以在你的画布上看到3个不同的预览: 一个是 iPhone 14 Pro，一个是 Dark Mode，还有一个是横向的:

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

使用预览是使用 SwiftUI 开发用户界面的一个强大工具。通过一点点的练习，你将能够快速而轻松地迭代你的设计，创建漂亮而响应迅速的应用程序。


SwiftUI 的一个重要特性是它如何与 Xcode 预览集成，这使您可以在处理用户界面时看到实时的用户界面代码。预览提供了一种快速有效的方法来开发和迭代应用程序的 UI 设计。

Swift - 在 SwiftUI 中使用 Xcode 预览


## 创建函数

Swift 函数从 func 关键字开始，然后是函数名，然后`{}`。函数的所有主体——都放在大括号内。

```swift
// 创建函数
func printHelp() {
    let message = """
		Welcome to MyApp!

		Run this app inside a directory of images and
		MyApp will resize them all into thumbnails
		"""
    print(message)
}
// 调用函数printHelp
printHelp()
```

## 接收参数

函数接收参数，比如内置的`print`函数，参数定义数据类型表示接收的参数类型。

```swift
print("hello world") // hello world即为参数
```

创建函数打印平方值

```swift
func square(number: Int) {
    print(number * number)
}
// Int 表示参数只接受Int类型
square(number: 8) // 64
```

## 返回值

除了接收数据，函数还可以返回数据。通过`-> <数据类型>`告诉 swift 将返回什么数据类型的值。

```swift
func square(number: Int) -> Int {
    return number * number
}
// -> Int 表示将返回Int类型的值
let result = square(number: 8)
print(result) // 64
```

## 参数标签

每一个函数的形式参数都包含形式参数标签和形式参数名两部分

- 形式参数标签用在调用函数的时候
- 形式参数名用在函数的实现当中
- 在调用函数的时候，每一个形式参数前边都会有一个形式参数标签
- 默认情况下，形式参数使用它们的形式参数名作为形式参数标签
- 如果不想要形式参数标签，可以在形式参数名称前加上`_`

```swift
//这里的info1和info2就是形式参数标签
//name和age是形式参数名称
func personalInfo(info1 name : String, info2 age : Int) { //在函数的实现中使用形式参数名称 print("姓名：(name)，年龄：(age)")
}
//在函数调用的时候使用形式参数标签
personalInfo(info1: "norman", info2: 23)

//下面是默认写法
//此时，name和age既是形式参数标签，也是形式参数名称
func personalInfo(name : String, age : Int) { //在函数内部实现的时候，name和age是形式参数名称 print("姓名：(name)，年龄：(age)")
}
//在函数调用的时候，name和age是形式参数标签
personalInfo(name: "norman", age: 24)

//如果不想要形式参数标签，可以在形式参数名称前面加 _
func personalInfo(_ name : String, _ age : Int) { print("姓名：(name)，年龄：(age)")
}
//在函数调用的时候，没有形式参数标签
personalInfo("norman", 24)
```

## 默认参数

swift 允许设置参数默认值，如：

```swift
func greet(_ person: String, nicely: Bool = true) {
    if nicely == true {
        print("Hello, \(person)!")
    } else {
        print("Oh no, it's \(person) again...")
    }
}

// 调用
greet("Taylor")
greet("Taylor", nicely: false)
```

## 变量参数

当参数不确定，或者参数有多个，在类型后使用`...`，swift 会将传入的值转换为数组，因此可以在函数内部使用循环语句处理。如：

```swift
func square(numbers: Int...) {
    for number in numbers {
        print("\(number) squared is \(number * number)")
    }
}

square(numbers: 1, 2, 3, 4, 5)
```

## io 参数

一般默认在函数中定义的参数都是常量参数，也就是这个参数你只可以查询使用，不能改变它的值。

如果想要声明一个变量参数，可以在参数定义前加 inout 关键字，这样就可以改变这个参数的值了。

比如，如果你想将一个数字翻倍——即直接更改值，而不是返回一个新的值——你可以写一个这样的函数：

```swift
func doubleInPlace(number: inout Int) {
    number *= 2
}

var myNum = 10
doubleInPlace(number: &myNum)
```

## 处理错误

使用`do/try/catch`方式优雅的处理程序运行错误。

```swift
do{
  try checkPassword("password")
}catch{
  print("error")
}
```

## 输入参数

通常参数传递的值在函数内部不可更改，在`swift`中可通过`inout`更改。

```swift
func doubleInPlace(number: inout Int){
  number*=2
}

使用方式:

var myNum = 10
doubleInPlace(number: &myum)
```

## 函数总结

- 函数允许我们重复使用代码，而不需要重复声明。
- 函数可以接受参数——只需告诉 Swift 每个参数的类型。
- 函数可以返回值，同样，您只需指定要返回的类型。如果您想返回一些内容，可以使用元组。
- 可以在内部和外部对参数使用不同的名称，也可以完全忽略外部名称。
- 参数可以具有默认值，这有助于在通常使用特定值时编写更少的代码。
- 可变参数函数接受零个或多个特定参数，Swift 将输入转换为数组。
- 函数可以抛出错误，但必须使用 try 和 handle errors 来调用它们。
- 可以使用 inout 来更改函数内部的变量，但通常最好是返回一个新值。


一般来说，一个函数是可以通过外部代码调用的一个“子程序”（或在递归的情况下由内部函数调用）。像程序本身一样，一个函数由称为函数体的一系列语句组成。值可以传递给一个函数，函数将返回一个值。

Functions - 函数、参数、错误


全局(客户端)状态管理并不总是像今天这样。我清楚地记得有一段时间，在高阶组件中的状态管理最佳选择是使用`Redux`， `connect` 连接 `mapStateToProps` 和 `mapDispatchToProps`。

即使是`context api`，最初也不是那么符合需求 ，因为刚出的时候只支持自身`props`。

当然，hooks 出现后一切都变了。不仅现有的解决方案变得更容易使用，而且新的解决方案也诞生了。

## Zustand

其中增长迅速的像`Zustand`，它非常小而精悍，提供了简易`api`创建全局状态以及通过`selectors`过来状态。它类似`Redux`，又比`Redux`简易。

就像`React`，`Zustand`提供丰富的扩展，可以结合[immer](https://github.com/pmndrs/zustand/tree/2b29d736841dc7b3fd7dec8cbfea50fee7295974#sick-of-reducers-and-changing-nested-state-use-immer)，也可以使用其他[middlewares](https://github.com/pmndrs/zustand/tree/2b29d736841dc7b3fd7dec8cbfea50fee7295974#middleware)

`Zustand` 将 `createStore` 函数的返回值作为一个自定义 hook 来实现，其中为了让 `React` 组件能感知到状态更新，是利用 `useEffect` 来完成订阅操作，而状态更新发布后，则通过 `forceUpdate()` 来强制组件进行 `rerender` 以获取最新的状态。

实际上，用法和 `react-redux` 非常相似，但获取状态与更新状态均只需要使用 `useStore` 一个 API 即可完成业务。

我从 2018 年开始在大小项目中使用`Zustand`，我也为`Zustand`开源做过贡献，以下是一些在实践中积累的技巧。

### 仅导出自定义钩子

这是首要技巧，对于任何 React 开发都满足，我之前列出了很多[Hooks 优点](https://tkdodo.eu/blog/simplifying-use-effect#3-write-custom-hooks)。

```js
// ⬇️ not exported, so no one can subscribe to the whole store
const useBearStore = create((set) => ({
  bears: 0,
  fish: 0,
  increasePopulation: (by) => set((state) => ({bears: state.bears + by})),
  eatFish: () => set((state) => ({fish: state.fish - 1})),
  removeAllBears: () => set({bears: 0})
}))

// 💡 exported - consumers don't need to write selectors
export const useBears = () => useBearStore((state) => state.bears)
```

它们将为您提供更清晰的界面，并且您不需要在所有您希望只订阅状态的一个值的地方编写选择器。此外，它还避免了意外地订阅整个状态:

```js
// ❌ we could do this if useBearStore was exported
const {bears} = useBearStore()
```

虽然结果可能是相同的(你会得到 bear 的数量) ，上面的代码将订阅你的整个状态，这意味着你的组件将在某个状态更新后全部重新渲染 ，即使 bear 没有改变，比如，fish 的状态改变了。`Selectors`在 `Zustand` 是可选择的，但对我来说，他们真的不是。即使我们有一个只有一个状态值的存储，我也会编写自定义钩子，以便将来能够添加更多的状态。

### 多使用原子选择器

这个在[官方文档](https://github.com/pmndrs/zustand/tree/2b29d736841dc7b3fd7dec8cbfea50fee7295974#selecting-multiple-state-slices)也解释了，所以我会尽量简短，但是非常重要，因为错用、滥用它可能会导致渲染性能下降。

`Zustand` 通过比较选择器的结果和之前渲染的结果来决定何时通知组件更新。默认情况下，它通过严格的相等检查来完成。

实际上，这意味着选择器必须返回稳定的结果。如果返回一个新的 `Array` 或 `Object`，它将始终被视为更改，即使内容相同:

```js
// 🚨 selector returns a new Object in every invocation
const {bears, fish} = useBearStore((state) => ({
  bears: state.bears,
  fish: state.fish
}))

// 😮 so these two are equivalent
const {bears, fish} = useBearStore()
```

如果要从选择器返回 Object 或 Array，可以将比较函数调整为使用浅比较:

```js
import shallow from 'zustand/shallow'

// ⬇️ much better, because optimized
const {bears, fish} = useBearStore(
  (state) => ({bears: state.bears, fish: state.fish}),
  shallow
)
```

然而我更倾向于导出两个独立的`selectors`

```js
export const useBears = () => useBearStore((state) => state.bears)
export const useFish = () => useBearStore((state) => state.fish)
```

假如组件需要多个值，引入多个 hooks 即可。

### actions 和 state 分离

actions 是不变的静态函数，它更新 state 中的值，所以它们不是真正的“状态”。将它们作为一个额外的对象在我们的存储中分离将允许我们将它们作为一个钩子暴露出来，然后我们可以在组件中使用它们:

```js
const useBearStore = create((set) => ({
  bears: 0,
  fish: 0,
  // ⬇️ separate "namespace" for actions
  actions: {
    increasePopulation: (by) => set((state) => ({bears: state.bears + by})),
    eatFish: () => set((state) => ({fish: state.fish - 1})),
    removeAllBears: () => set({bears: 0})
  }
}))

export const useBears = () => useBearStore((state) => state.bears)
export const useFish = () => useBearStore((state) => state.fish)

// 🎉 one selector for all our actions
export const useBearActions = () => useBearStore((state) => state.actions)
```

现在可以只使用一个 hooks 导出所有的 actions

```js
const {increasePopulation} = useBearActions()
```

这看起来和上面提到的原子选择器相反，但是事实并非如此，由于 `actions` 不会改变，`actions` 可以看出是一个原子块。

### Model Actions as Events, not Setters

这是一个通用的提示，无论你是否使用 `useReducer`、 `Redux` 或 `Zustand`。
事实上，这个技巧直接来自 [Redux 风格指南](https://redux.js.org/style-guide/style-guide#model-actions-as-events-not-setters)。
它将帮助您将业务逻辑保留在存储中，而不是保留在组件中。
上面的例子已经使用了这种模式——逻辑(例如“增加人口”)存在于状态中。
组件只是调用操作，而存储决定如何处理它。

### 保持状态小型化

与 `Redux` 不同的是，`Zustand` 鼓励您拥有多个小型状态。每个状态可以对单个状态负责。如果你需要组合它们，你可以使用自定义钩子:

```js
const currentUser = useCredentialsStore((state) => state.currentUser)
const user = useUsersStore((state) => state.users[currentUser])
```

> 注意: Zustand 确实有另外一种将状态组合成切片的方法，但是我从来不需要这种方法。对我来说，它看起来不是很简单，尤其是涉及到 TypeScript 的时候。如果我真的需要它，我可能会选择 Redux Toolkit。

### 结合其他库

老实说，我并不经常需要组合多个 `Zustand` 状态，因为应用程序中的大多数状态要么是服务器状态，要么是 URL 状态。与将两个状态组合起来相比，我更有可能将 `Zustand` 状态与 `useQuery` 或 `useParams` 结合起来。不过，同样的原则也适用于: 如果你需要将另一个钩子与 `Zustand` 状态结合起来，自定义钩子也许是你最好的选择:

```js
const useFilterStore = create((set) => ({
  applied: [],
  actions: {
    addFilter: (filter) =>
      set((state) => ({applied: [...state.applied, filter]}))
  }
}))

export const useAppliedFilters = () => useFilterStore((state) => state.applied)

export const useFiltersActions = () => useFilterStore((state) => state.actions)

// 🚀 combine the zustand store with a query
export const useFilteredTodos = () => {
  const filters = useAppliedFilters()
  return useQuery({
    queryKey: ['todos', filters],
    queryFn: () => getTodos(filters)
  })
}
```

在这里，应用的筛选器驱动查询，因为筛选器是查询键的一部分。
每次调用 `addFilter` (可以在 UI 中的任何地方执行)时，都会自动触发一个新查询，这个查询也可以在 UI 中的任何地方使用。
我觉得这是一个非常简洁明了的说明，但又不会太神奇。


全局(客户端)状态管理并不总是像今天这样。我清楚地记得有一段时间，在高阶组件中的状态管理最佳选择是使用Redux， connect 连接 mapStateToProps 和 mapDispatchToProps。

Zustand-入门


Swift 中复杂类型包括：

- Array
- Set
- Tuple
- Dictionary
- Enums

### Array

> Swift 数组允许您存储相同类型的值，可以使用该值在数组中的位置来检索这些值。Swift 会强制检测元素类型，如果类型不同，会报错。

```swift
// 创建数组
var firstArray = ["hello","hello","world"]
var secondArray = ["swift","niubility"]

// 获取数组第一个元素
print(firstArray[0]) // hello

//添加数组
firstArray.append("manon")
firstArray+=["icu"]

// 循环数组
for item in firstArray{
	print(item) //hell hello world manon icu
}

// 修改数组元素
firstArray[0] = "swift"

// 合并数组
firstArray+secondArray

// 计算数组元素的个数
firstArray.count

// 判断数组是否为空
firstArray.isEmpty

// 删除数组元素
firstArray.remove(at: 0)
```

### Set

> 集合是用来存储类型相同且没有确定顺序的唯一的值，不允许插入已存在的值

```swift
// 创建集合
let firstSet = Set(["hello","world","manon","icu","swift"])
let secondSet = Set(["just","do","it"])

// 访问集合
for item in firstSet{
	print(item) //"hello","world","manon","icu","swift"
}

// 判断是否为空
firstSet.isEmpty // false

// 计算集合的长度
firstSet.count //5

// 判断是否包含某个元素
firstSet.contains("manon") //true

// 向集合添加元素
firstSet.insert("funny")

// 删除集合的元素
firstSet.remove("manon")

// 合并集合
firstSet.union(secondSet)
```

### Tuple

> Swift 中的 tuple 允许存储不同类型的固定数量的值。创建元组后，不能从该元组中添加或删除值。

```swift
// 创建tuple
let firstTuple = (name: "manon", level: 9000, Nationality: "china")

// 访问tuple
firstTuple.name // manon
```

### Dictionary

> Swift 字典用来存储无序的相同类型数据的集合，Swift 字典会强制检测元素的类型，如果类型不同则会报错。 Swift 字典每个值（value）都关联唯一的键（key），键作为字典中的这个值数据的标识符。和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。 Swift 字典的 key 没有类型限制可以是整型或字符串，但必须是唯一的。

```swift
// 创建字典
let firstDictionary = ["Gintama" : "Sakata Gintoki", "Haikyuu" : "Shoyo Hinata"]

// 访问字典
firstDictionary["Gintama"] // Sakata Gintoki

// 修改字典
firstDictionary.updateValue("manon",forKey:Gintama)
// 或
firstDictionary["Gintama"] = "manon"

// 删除字典元素
firstDictionary.removeValue("Gintama")

// 遍历字典
for (key,value) in firstDictionary{
	print("字典 key \(key) -  字典 value \(value)")
}

// 计算字典长度
firstDictionary.count

// 判断字典是否为空
firstDictionary.isEmpty
```

### Enums

> 根据 Swift 文档枚举的定义，它是“一组相关值的公共类型，使您能够在代码中以类型安全的方式处理这些值”。可以把它看作是一种特别用于 switch/conditions 的变量类型。

```swift
// 创建Enums
enum enumname {
   // 枚举定义放在这里
}

// 实例

import Cocoa

enum DaysofaWeek {
    case Sunday
    case Monday
    case TUESDAY
    case WEDNESDAY
    case THURSDAY
    case FRIDAY
    case Saturday
}

var weekDay = DaysofaWeek.THURSDAY
weekDay = .THURSDAY
switch weekDay{
	case .Sunday:
		print("星期天")
	case .Monday:
		print("星期一")
	case .TUESDAY:
		print("星期二")
	case .WEDNESDAY:
		print("星期三")
	case .THURSDAY:
		print("星期四")
	case .FRIDAY:
		print("星期五")
	case .Saturday:
		print("星期六")
}
```


Complex Types - 数组、字典、集合、枚举


到目前为止，使用 `Link` 组件从一个页面导航到另一个页面。使用 `Router` 组件也可以实现相同的功能。

更新`index.js`

```jsx
import Router from 'next/router'
import Head from 'next/head'

function HomePage(props) {
  return (
    <>
      <Head>
        <title>Welcome to Next.js!</title>
      </Head>
      <div>Welcome to Next.js!</div>
      <span onClick={() => Router.push('/posts/one')}>First Post</span>
      <br />
      <div>Next stars: {props.stars}</div>
      <img src="/logo.png" alt="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
```

验证结果

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