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

React Conditionals


## 语法

```sql
table_name AS alias_name
```

## 作用

假如在查询中，你想要查询一个表的所有数据，但是又不想要表的名字，可以使用别名。

```sql
a_very_long_table_name.column_name

a_very_long_table_name AS alias_name

alias.column_name
```

在`JOIN`语句中使用别名，可以避免重复的表名。

```sql
SELECT
	c.customer_id,
	first_name,
	amount,
	payment_date
FROM
	customer c
INNER JOIN payment p
    ON p.customer_id = c.customer_id
ORDER BY
   payment_date DESC;
```

在`self-join`中使用别名，可以避免重复的表名。

```sql
SELECT
    e.first_name employee,
    m .first_name manager
FROM
    employee e
INNER JOIN employee m
    ON m.employee_id = e.manager_id
ORDER BY manager;
```


Postgresql alias是一种把表名作为别名的方法，它可以让你更好的理解表的含义。

Postgresql - TABLE ALIAS


## 为什么要使用 debounce 和 throttle

防抖和节流就是针对响应跟不上触发频率这类问题的两种解决方案。在给 DOM 绑定事件时，有些事件我们是无法控制触发频率的。 如鼠标移动事件 onmousemove, 滚动滚动条事件 onscroll，窗口大小改变事件 onresize，瞬间的操作都会导致这些事件会被高频触发。 如果事件的回调函数较为复杂，就会导致响应跟不上触发，出现页面卡顿，假死现象。 在实时检查输入时，如果我们绑定 onkeyup 事件发请求去服务端检查，用户输入过程中，事件的触发频率也会很高，会导致大量的请求发出，响应速度会大大跟不上触发。

## 在 watcher 中使用 debounce

1. 在`created`生命周期将`this.debounce`绑定到`this`上，这样`this.debounce`就可以在`created`生命周期中使用。
2. 在`watch`函数中，使用`this.debounce`调用`debounce`函数，并传入`this.debounce`的回调函数。
3. 在事件销毁前，使用`this.debounce`调用`clear`函数，清除定时器。

```html
<template>
  <input v-model="value" type="text" />
  <p>{{ value }}</p>
</template>
<script>
  import debounce from 'lodash.debounce'
  export default {
    data() {
      return {
        value: ''
      }
    },
    watch: {
      value(...args) {
        this.debouncedWatch(...args)
      }
    },
    created() {
      this.debouncedWatch = debounce((newValue, oldValue) => {
        console.log('New value:', newValue)
      }, 500)
    },
    beforeUnmount() {
      this.debouncedWatch.cancel()
    }
  }
</script>
```

## 使用 debounce 处理事件

```html
<template>
  <input v-on:input="debouncedHandler" type="text" />
</template>
<script>
  import debounce from 'lodash.debounce'
  export default {
    created() {
      this.debouncedHandler = debounce((event) => {
        console.log('New value:', event.target.value)
      }, 500)
    },
    beforeUnmount() {
      this.debouncedHandler.cancel()
    }
  }
</script>
```

为什么不适用`debounce`或`throttle`直接绑定函数呢？比如：

```html
<template>
  <input v-on:input="debouncedHandler" type="text" />
</template>
<script>
  import debounce from 'lodash.debounce'
  export default {
    methods: {
      // Don't do this!
      debouncedHandler: debounce(function (event) {
        console.log('New value:', event.target.value)
      }, 500)
    }
  }
</script>
```

**使用`export default { ... }`从组件导出的 options 对象，包括方法，将被组件的所有实例重用。如果网页中有 2 个或更多的组件实例，那么所有的组件都将使用相同的`debounce`或`throttle`的函数方法。**

## 总结

在 `vue` 中使用 `debounce` 和 `throttle` 函数，应该在 `created` 和 `beforeUnmount` 生命周期中使用，而不是在 `watch` 中使用。

```html
<template>
  <input v-on:input="debouncedHandler" type="text" />
</template>
<script>
  export default {
    created() {
      this.debouncedCallback = debounce((...args) => {
        // The debounced
        callback
      }, 500)
    },
    watch: {
      value(...args) {
        this.debouncedCallback(...args)
      }
    }
  }
</script>
```


如input、resize、scroll、intersection observer 等事件可能发生得非常频繁，例如每秒发生几次，因此调用一个动作，比如对每个事件发出读取请求，并不是一个明智的方法。

如何在 vue 中使用 Debounce、Throttle


## 创建函数

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 - 函数、参数、错误


可选链（Optional Chaining）是 Swift 中一种用于在调用属性、方法或下标脚本时处理值可能为空的机制。

在 Swift 中，如果一个对象的属性或方法返回值类型是可选类型（Optional Type），则在访问这个属性或方法时，需要使用可选链来避免空值引用导致的运行时错误。

可选链使用问号 ? 表示，如果一个属性、方法或下标脚本可能为空，则在其名称后面加上问号 ? 表示可选链：

```swift
class Person {
    var name: String?
}

let person: Person? = Person()

// 如果 person 为 nil，则不执行 name 的赋值操作
person?.name = "Tom"
```

在上述示例中，如果 person 对象为空，即使尝试给 name 属性赋值也不会引发运行时错误。

同时，可选链也可以用于调用方法或下标脚本：

```swift
class Person {
    var name: String?

    func sayHello() {
        print("Hello, my name is \(name ?? "")")
    }

    subscript(index: Int) -> String? {
        return name
    }
}

let person: Person? = Person()

// 如果 person 为空，则不执行 sayHello 方法
person?.sayHello()

// 如果 person 为空，则返回 nil
let name = person?[0]
```

在上述示例中，使用可选链调用 sayHello 方法和获取下标脚本，即使 person 为空也不会引发运行时错误。

需要注意的是，当使用可选链调用属性或方法时，如果这个属性或方法返回的是非可选类型，那么返回的值会被自动包装为可选类型。因此，当使用可选链调用方法或属性后需要对返回的值进行解包。

```swift
class Person {
    var name: String?

    func sayHello() {
        print("Hello, my name is \(name ?? "")")
    }

    func getAge() -> Int {
        return 18
    }
}

let person: Person? = Person()

// 返回值为可选类型，需要对返回值进行解包
let age = person?.getAge()

// age 的类型为 Optional<Int>，需要对其进行解包
if let age = age {
  print(age)
}
```

在上述示例中，调用 getAge 方法返回的是一个 Int 类型，但是由于使用了可选链，返回的值被自动包装成了可选类型，需要对其进行解包。


可选链（Optional Chaining）是 Swift 中一种用于在调用属性、方法或下标脚本时处理值可能为空的机制。

Swift - 可选链


在 CSS 中，z-index 和层叠上下文（Stacking Context）是用于控制元素的层叠顺序和叠放顺序的两个关键概念。它们通常用于解决重叠元素的显示问题。

1. z-index：z-index 是一个 CSS 属性，用于控制元素在层叠顺序中的位置。它的取值可以是数字或 auto。数字越大，元素越靠近视口，也就是显示在前面。如果两个元素的 z-index 相同，它们的顺序将由它们在 HTML 中出现的顺序决定。z-index 只对已经定位（position）的元素有效。

2. 层叠上下文（Stacking Context）：层叠上下文是一种 HTML 元素的层叠环境。每个层叠上下文都有自己的层叠顺序，元素在其中的位置由层叠顺序和 z-index 值共同决定。当一个元素有层叠上下文时，它的子元素的层叠顺序和 z-index 将相对于其父元素进行计算。

层叠上下文有多种创建方式，包括：

- 根元素（HTML）和 window 对象是层叠上下文的根元素。
- position 值为 absolute 或 relative 且 z-index 值不为 auto 的元素。
- position 值为 fixed 或 sticky 的元素。
- 具有 opacity 值小于 1 的元素。
- 具有 transform、filter、perspective、clip-path、mask、mix-blend-mode 等属性的元素。
- 具有 isolation 属性设置为 isolate 的元素。
- 具有 will-change 属性的元素（例如 will-change: transform）。

当元素发生重叠时，可以通过改变层叠顺序和 z-index 值来控制它们的显示顺序。但是，应该注意避免滥用 z-index 和层叠上下文，因为它们可能会导致布局问题和难以维护的代码。建议尽可能使用更简单和可预测的布局方法，如 Flexbox 和 Grid，来避免这些问题。

以下是一个示例，说明如何使用 z-index 和层叠上下文来控制元素的层叠顺序：

HTML 代码：

```html
<div class="parent">
  <div class="child child1"></div>
  <div class="child child2"></div>
</div>
```

CSS 代码：

```css
.parent {
  position: relative;
}

.child {
  position: absolute;
  width: 100px;
  height: 100px;
}

.child1 {
  background-color: red;
  z-index: 1;
}

.child2 {
  background-color: blue;
  z-index: 2;
}
```

在这个例子中，父元素 .parent 有定位属性 position: relative;，使它成为一个层叠上下文。子元素 .child 都有绝对定位属性 position: absolute;，并设置了相同的宽度和高度。.child1 的 z-index 值为 1，.child2 的 z-index 值为 2，因此 .child2 会显示在 .child1 的前面，即蓝色盒子会显示在红色盒子上面。

通过使用 z-index 和层叠上下文，可以方便地控制元素的层叠顺序，以达到所需的布局效果。


css - Z-index & Stacking Context


实际上，大多数项目都将有一个或多个容器，这些容器需要相互通信。在这种情况下，Docker 提供了一些选项，以便容器可以相互通信。

假如现在有一个简单的应用程序，它由两个容器组成：一个 web 容器和一个数据库容器。web 容器需要与数据库容器通信，以便它可以从数据库中检索数据。

## 解决方案

- 使用暴露的端口访问数据库容器
- 使用 ip 和默认端口访问数据库容器

第一种方法设计从数据库容器中暴露端口，web 容器通过该端口连接，假设数据库容器的端口为 3306，那么 web 容器就可以通过 `http://localhost:3306` 访问数据库容器。

第二种方法使用 container inspect 命令来获取数据库容器的 IP 地址，然后使用该 IP 地址和默认端口访问数据库容器，假设数据库容器的 id 为 postgres，通过以下命令获得 IP 地址：

```bash
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' postgres
# 172.17.0.2
```

现在可以通过http://172.17.0.2:5432访问数据库容器。

两种方法都有缺点，因为它们都依赖于容器的 IP 地址，如果容器的 IP 地址发生变化，那么就需要更新 web 容器的配置。

正确的方式是放在一个网络中，这样就可以通过容器名称访问数据库容器，而不是通过 IP 地址。
